--- /dev/null
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.40
+ *
+ * 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.
+ * ----------------------------------------------------------------------------- */
+
+#define SWIGOCTAVE
+#define SWIG_name_d "ml"
+#define SWIG_name ml
+#define OCTAVE_API_VERSION_OPTION 0
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> 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<T>& rhs);
+ SwigValueWrapper(const SwigValueWrapper<T>& 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 <typename T> 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
+
+
+
+#include <octave/oct.h>
+#include <octave/parse.h>
+#include <octave/ov-fcn-handle.h>
+#include <octave/Cell.h>
+#include <octave/oct-map.h>
+
+/* -----------------------------------------------------------------------------
+ * 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 and 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 (<obj is ok>) {
+ if (<need new object>) {
+ *ptr = <ptr to new allocated object>;
+ return SWIG_NEWOBJ;
+ } else {
+ *ptr = <ptr to old object>;
+ 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
+# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#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<int>" == "Class<int >", 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 <name1>|<name2>|...
+ Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+ int equiv = 0;
+ const char* te = tb + strlen(tb);
+ const char* ne = nb;
+ while (!equiv && *ne) {
+ for (nb = ne; *ne; ++ne) {
+ if (*ne == '|') break;
+ }
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+ if (*ne) ++ne;
+ }
+ return equiv;
+}
+
+/*
+ Check type equivalence in a name list like <name1>|<name2>|...
+ Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCompare(const char *nb, const char *tb) {
+ int equiv = 0;
+ const char* te = tb + strlen(tb);
+ const char* ne = nb;
+ while (!equiv && *ne) {
+ for (nb = ne; *ne; ++ne) {
+ if (*ne == '|') break;
+ }
+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+ if (*ne) ++ne;
+ }
+ return equiv;
+}
+
+
+/*
+ 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) {
+ register size_t l = 0;
+ register size_t r = iter->size - 1;
+ do {
+ /* since l+r >= 0, we can (>> 1) instead (/ 2) */
+ register size_t i = (l + r) >> 1;
+ const char *iname = iter->types[i]->name;
+ if (iname) {
+ register 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 {
+ register 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";
+ register const unsigned char *u = (unsigned char *) ptr;
+ register const unsigned char *eu = u + sz;
+ for (; u != eu; ++u) {
+ register 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) {
+ register unsigned char *u = (unsigned char *) ptr;
+ register const unsigned char *eu = u + sz;
+ for (; u != eu; ++u) {
+ register char d = *(c++);
+ register 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
+
+
+
+
+#if OCTAVE_API_VERSION_OPTION>0
+#define USE_OCTAVE_API_VERSION OCTAVE_API_VERSION_OPTION
+#else
+
+#include <octave/version.h>
+#ifdef OCTAVE_API_VERSION_N
+#define USE_OCTAVE_API_VERSION OCTAVE_API_VERSION_N
+
+#else // Interim hack to distinguish between Octave 3.2 and earlier versions.
+
+#define ComplexLU __ignore
+#include <octave/CmplxLU.h>
+#undef ComplexLU
+#ifdef octave_Complex_LU_h
+#define USE_OCTAVE_API_VERSION 36
+#else
+#define USE_OCTAVE_API_VERSION 37
+#endif
+
+#endif
+
+#endif
+
+SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
+ if (num_args > max_args && !varargs)
+ error("function %s takes at most %i arguments", func_name, max_args);
+ else if (num_args < min_args)
+ error("function %s requires at least %i arguments", func_name, min_args);
+ else
+ return true;
+ return false;
+}
+
+SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
+ ovl->append(ov);
+ return ovl;
+}
+
+SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
+ switch (code) {
+ case SWIG_MemoryError:
+ return "SWIG_MemoryError";
+ case SWIG_IOError:
+ return "SWIG_IOError";
+ case SWIG_RuntimeError:
+ return "SWIG_RuntimeError";
+ case SWIG_IndexError:
+ return "SWIG_IndexError";
+ case SWIG_TypeError:
+ return "SWIG_TypeError";
+ case SWIG_DivisionByZero:
+ return "SWIG_DivisionByZero";
+ case SWIG_OverflowError:
+ return "SWIG_OverflowError";
+ case SWIG_SyntaxError:
+ return "SWIG_SyntaxError";
+ case SWIG_ValueError:
+ return "SWIG_ValueError";
+ case SWIG_SystemError:
+ return "SWIG_SystemError";
+ case SWIG_AttributeError:
+ return "SWIG_AttributeError";
+ }
+ return "SWIG unknown error";
+}
+
+SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
+ octave_value type(SWIG_ErrorType(code));
+ std::string r = msg;
+ r += " (" + type.string_value() + ")";
+ error(r.c_str());
+ return octave_value(r);
+}
+
+#define SWIG_fail goto fail
+
+#define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
+#define swig_owntype int
+
+#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
+
+#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
+
+#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
+
+#define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
+#define SWIG_MODULE_CLIENTDATA_TYPE void*
+
+#define Octave_Error_Occurred() 0
+#define SWIG_Octave_AddErrorMsg(msg) {;}
+
+SWIGRUNTIME swig_module_info *SWIG_Octave_GetModule(void *clientdata);
+SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer);
+
+// For backward compatibility only
+#define SWIG_POINTER_EXCEPTION 0
+#define SWIG_arg_fail(arg) 0
+
+// Runtime API implementation
+
+#include <map>
+#include <vector>
+#include <string>
+
+typedef octave_value_list(*octave_func) (const octave_value_list &, int);
+class octave_swig_type;
+
+namespace Swig {
+ class Director;
+
+ SWIGRUNTIME void swig_register_director(octave_swig_type *self, void *ptr, Director *d);
+ SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
+ SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
+
+ SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
+ SWIGRUNTIME octave_swig_type *swig_value_deref(octave_value ov);
+ SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
+
+ typedef std::map < void *, Director * > rtdir_map;
+
+ SWIGINTERN rtdir_map* get_rtdir_map() {
+ static swig_module_info *module = 0;
+ if (!module)
+ module = SWIG_GetModule(0);
+ if (!module)
+ return 0;
+ if (!module->clientdata)
+ module->clientdata = new rtdir_map;
+ return (rtdir_map *) module->clientdata;
+ }
+
+ SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d) {
+ rtdir_map* rm = get_rtdir_map();
+ if (rm)
+ (*rm)[vptr] = d;
+ }
+
+ SWIGINTERNINLINE void erase_rtdir(void *vptr) {
+ rtdir_map* rm = get_rtdir_map();
+ if (rm)
+ (*rm).erase(vptr);
+ }
+
+ SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
+ rtdir_map* rm = get_rtdir_map();
+ if (!rm)
+ return 0;
+ rtdir_map::const_iterator pos = rm->find(vptr);
+ Director *rtdir = (pos != rm->end())? pos->second : 0;
+ return rtdir;
+ }
+}
+
+ struct swig_octave_member {
+ const char *name;
+ octave_func method;
+ octave_func get_method;
+ octave_func set_method;
+ int flags; // 1 static, 2 global
+ const char *doc;
+ bool is_static() const {
+ return flags &1;
+ } bool is_global() const {
+ return flags &2;
+ }
+ };
+
+ struct swig_octave_class {
+ const char *name;
+ swig_type_info **type;
+ int director;
+ octave_func constructor;
+ const char *constructor_doc;
+ octave_func destructor;
+ const swig_octave_member *members;
+ const char **base_names;
+ const swig_type_info **base;
+ };
+
+ // octave_swig_type plays the role of both the shadow class and the class
+ // representation within Octave, since there is no support for classes.
+ //
+ // These should really be decoupled, with the class support added to Octave
+ // and the shadow class given by an m-file script. That would dramatically
+ // reduce the runtime complexity, and be more in line w/ other modules.
+
+ class octave_swig_type:public octave_base_value {
+ struct cpp_ptr {
+ void *ptr;
+ bool destroyed;
+ cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
+ }};
+ typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
+
+ mutable swig_module_info *module;
+
+ const swig_type_info *construct_type; // type of special type object
+ std::vector < type_ptr_pair > types; // our c++ base classes
+ int own; // whether we call c++ destructors when we die
+
+ typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
+ typedef std::map < std::string, member_value_pair > member_map;
+ member_map members;
+ bool always_static;
+
+ const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
+ if (!type->clientdata)
+ return 0;
+ swig_octave_class *c = (swig_octave_class *) type->clientdata;
+ const swig_octave_member *m;
+ for (m = c->members; m->name; ++m)
+ if (m->name == name)
+ return m;
+ for (int j = 0; c->base_names[j]; ++j) {
+ if (!c->base[j]) {
+ if (!module)
+ module = SWIG_GetModule(0);
+ assert(module);
+ c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
+ }
+ if (!c->base[j])
+ return 0;
+ if ((m = find_member(c->base[j], name)))
+ return m;
+ }
+ return 0;
+ }
+
+ member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
+ member_map::iterator it = members.find(name);
+ if (it != members.end())
+ return &it->second;
+ const swig_octave_member *m;
+ for (unsigned int j = 0; j < types.size(); ++j)
+ if ((m = find_member(types[j].first, name)))
+ return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
+ if (!insert_if_not_found)
+ return 0;
+ return &members[name];
+ }
+
+ const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
+ if (!base) {
+ for (unsigned int j = 0; j < types.size(); ++j) {
+ assert(types[j].first->clientdata);
+ swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
+ if (cj->name == name)
+ return types[j].first;
+ }
+ return 0;
+ }
+ assert(base->clientdata);
+ swig_octave_class *c = (swig_octave_class *) base->clientdata;
+ for (int j = 0; c->base_names[j]; ++j) {
+ if (!c->base[j]) {
+ if (!module)
+ module = SWIG_GetModule(0);
+ assert(module);
+ c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
+ }
+ if (!c->base[j])
+ return 0;
+ assert(c->base[j]->clientdata);
+ swig_octave_class *cj = (swig_octave_class *) c->base[j]->clientdata;
+ if (cj->name == name)
+ return c->base[j];
+ }
+ return 0;
+ }
+
+ void load_members(const swig_octave_class* c,member_map& out) const {
+ for (const swig_octave_member *m = c->members; m->name; ++m) {
+ if (out.find(m->name) == out.end())
+ out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
+ }
+ for (int j = 0; c->base_names[j]; ++j) {
+ if (!c->base[j]) {
+ if (!module)
+ module = SWIG_GetModule(0);
+ assert(module);
+ c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
+ }
+ if (!c->base[j])
+ continue;
+ assert(c->base[j]->clientdata);
+ const swig_octave_class *cj =
+ (const swig_octave_class *) c->base[j]->clientdata;
+ load_members(cj,out);
+ }
+ }
+
+ void load_members(member_map& out) const {
+ out=members;
+ for (unsigned int j = 0; j < types.size(); ++j)
+ if (types[j].first->clientdata)
+ load_members((const swig_octave_class *) types[j].first->clientdata, out);
+ }
+
+ octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
+ if (m->second.is_defined())
+ return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
+ else if (m->first && m->first->method)
+ return m->first->method(args, nargout);
+ error("member not defined or not invocable");
+ return octave_value_list();
+ }
+
+ bool dispatch_unary_op(const std::string &symbol, octave_value &ret) {
+ member_value_pair *m = find_member(symbol, false);
+ if (!m || m->first->is_static() || m->first->is_global())
+ return false;
+ octave_value_list args;
+ args.append(as_value());
+ octave_value_list argout(member_invoke(m, args, 1));
+ if (argout.length() < 1)
+ return false;
+ ret = argout(0);
+ return true;
+ }
+
+ bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) {
+ member_value_pair *m = find_member(symbol, false);
+ if (!m || m->first->is_static() || m->first->is_global())
+ return false;
+ octave_value_list args;
+ args.append(as_value());
+ args.append(make_value_hack(rhs));
+ octave_value_list argout(member_invoke(m, args, 1));
+ if (argout.length() < 1)
+ return false;
+ ret = argout(0);
+ return true;
+ }
+
+ bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) {
+ member_value_pair *m = find_member(symbol, false);
+ if (!m || m->first->is_static() || m->first->is_global())
+ return false;
+ octave_value_list args;
+ args.append(as_value());
+ args.append(rhs);
+ octave_value_list argout(member_invoke(m, args, 1));
+ if (argout.length() >= 1)
+ ret = argout(0);
+ return true;
+ }
+
+ octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
+ if (m->second.is_defined())
+ return m->second;
+ else if (m->first) {
+ if (m->first->get_method)
+ return m->first->get_method(args, 1);
+ else if (m->first->method)
+ return octave_value(new octave_builtin(m->first->method));
+ }
+ error("undefined member");
+ return octave_value_list();
+ }
+
+ static octave_value make_value_hack(const octave_base_value &x) {
+ ((octave_swig_type &) x).count++;
+ return octave_value((octave_base_value *) &x);
+ }
+
+ octave_swig_type(const octave_swig_type &x);
+ octave_swig_type &operator=(const octave_swig_type &rhs);
+ public:
+
+ octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
+ bool _always_static = false)
+ : module(0), construct_type(_ptr ? 0 : _type), own(_own),
+ always_static(_always_static) {
+ if (_type || _ptr)
+ types.push_back(std::make_pair(_type, _ptr));
+ if (_ptr) {
+ Swig::Director *d = Swig::get_rtdir(_ptr);
+ if (d)
+ Swig::swig_director_set_self(d, this);
+ }
+ }
+
+ ~octave_swig_type() {
+ if (own) {
+ ++count;
+ for (unsigned int j = 0; j < types.size(); ++j) {
+ if (!types[j].first || !types[j].first->clientdata)
+ continue;
+ swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
+ if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
+ c->destructor(as_value(), 0);
+ }
+ }
+ }
+ for (unsigned int j = 0; j < types.size(); ++j)
+ Swig::erase_rtdir(types[j].second.ptr);
+ }
+
+ octave_value as_value() {
+ ++count;
+ return Swig::swig_value_ref(this);
+ }
+
+ void incref() {
+ ++count;
+ }
+
+ void decref() {
+ if (!--count)
+ delete this;
+ }
+
+ long swig_this() const {
+ if (!types.size())
+ return (long) this;
+ return (long) types[0].second.ptr;
+ }
+ const char* help_text() const {
+ if (!types.size())
+ return 0;
+ if (!types[0].first->clientdata)
+ return 0;
+ swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
+ return c->constructor_doc;
+ }
+
+ std::string swig_type_name() const {
+ // * need some way to manually name subclasses.
+ // * eg optional first arg to subclass(), or named_subclass()
+ std::string ret;
+ for (unsigned int j = 0; j < types.size(); ++j) {
+ if (j)
+ ret += "_";
+ if (types[j].first->clientdata) {
+ swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
+ ret += c->name;
+ } else
+ ret += types[j].first->name;
+ }
+ return ret;
+ }
+
+ void merge(octave_swig_type &rhs) {
+ rhs.own = 0;
+ for (unsigned int j = 0; j < rhs.types.size(); ++j) {
+ assert(!rhs.types[j].second.destroyed);
+ Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
+ if (d)
+ Swig::swig_director_set_self(d, this);
+ }
+ types.insert(types.end(), rhs.types.begin(), rhs.types.end());
+ members.insert(rhs.members.begin(), rhs.members.end());
+ rhs.types.clear();
+ rhs.members.clear();
+ }
+
+ void install_global() {
+ for (member_map::const_iterator it = members.begin(); it != members.end(); ++it) {
+ if (it->second.first && it->second.first->method)
+ install_builtin_function(it->second.first->method, it->first,
+ it->second.first->doc?it->second.first->doc:std::string());
+ else if (it->second.second.is_defined()) {
+#if USE_OCTAVE_API_VERSION<37
+ link_to_global_variable(curr_sym_tab->lookup(it->first, true));
+#else
+ symbol_table::varref(it->first);
+ symbol_table::mark_global(it->first);
+#endif
+ set_global_value(it->first, it->second.second);
+
+#if USE_OCTAVE_API_VERSION<37
+ octave_swig_type *ost = Swig::swig_value_deref(it->second.second);
+ if (ost) {
+ const char* h = ost->help_text();
+ if (h) {
+ symbol_record *sr = global_sym_tab->lookup (it->first, true);
+ sr->document(h);
+ }
+ }
+#endif
+ }
+ }
+ }
+
+ void *cast(swig_type_info *type, int *_own, int flags) {
+ if (_own)
+ *_own = own;
+ if (flags &SWIG_POINTER_DISOWN)
+ own = 0;
+ if (!type && types.size())
+ return types[0].second.ptr;
+ for (unsigned int j = 0; j < types.size(); ++j)
+ if (type == types[j].first)
+ return types[j].second.ptr;
+ for (unsigned int j = 0; j < types.size(); ++j) {
+ swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
+ if (!tc)
+ continue;
+ int newmemory = 0;
+ void *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
+ assert(!newmemory); // newmemory handling not yet implemented
+ return vptr;
+ }
+ return 0;
+ }
+
+ bool is_owned() const {
+ return own;
+ }
+
+ void director_destroyed(Swig::Director *d) {
+ bool found = false;
+ for (unsigned int j = 0; j < types.size(); ++j) {
+ Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
+ if (dj == d) {
+ types[j].second.destroyed = true;
+ found = true;
+ }
+ }
+ assert(found);
+ }
+
+ void assign(const std::string &name, const octave_value &ov) {
+ members[name] = std::make_pair((const swig_octave_member *) 0, ov);
+ }
+
+ void assign(const std::string &name, const swig_octave_member *m) {
+ members[name] = std::make_pair(m, octave_value());
+ }
+
+ octave_base_value *clone() const {
+ // pass-by-value is probably not desired, and is harder;
+ // requires calling copy constructors of contained types etc.
+ assert(0);
+ *(int *) 0 = 0;
+ return 0;
+ }
+
+ octave_base_value *empty_clone() const {
+ return new octave_swig_type();
+ }
+
+ bool is_defined() const {
+ return true;
+ }
+
+ virtual bool is_map() const {
+ return true;
+ }
+
+ virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
+ octave_value_list ovl = subsref(ops, idx, 1);
+ return ovl.length()? ovl(0) : octave_value();
+ }
+
+ virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
+ assert(ops.size() > 0);
+ assert(ops.size() == idx.size());
+
+ std::list < octave_value_list >::const_iterator idx_it = idx.begin();
+ int skip = 0;
+ octave_value_list sub_ovl;
+
+ // constructor invocation
+ if (ops[skip] == '(' && construct_type) {
+ assert(construct_type->clientdata);
+ swig_octave_class *c = (swig_octave_class *) construct_type->clientdata;
+ if (!c->constructor) {
+ error("cannot create instance");
+ return octave_value_list();
+ }
+ octave_value_list args;
+ if (c->director)
+ args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
+ args.append(*idx_it++);
+ ++skip;
+ sub_ovl = c->constructor(args, nargout);
+ }
+ // member dereference or invocation
+ else if (ops[skip] == '.') {
+ std::string subname;
+ const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
+ for (;;) {
+ octave_value_list subname_ovl(*idx_it++);
+ ++skip;
+ assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
+ subname = subname_ovl(0).string_value();
+
+ const swig_type_info *next_base = find_base(subname, base);
+ if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
+ break;
+ base = next_base;
+ }
+
+ member_value_pair tmp, *m = &tmp;
+ if (!base || !(m->first = find_member(base, subname)))
+ m = find_member(subname, false);
+ if (!m) {
+ error("member not found");
+ return octave_value_list();
+ }
+
+ octave_value_list args;
+ if (!always_static &&
+ (!m->first || (!m->first->is_static() && !m->first->is_global())))
+ args.append(as_value());
+ if (skip < (int) ops.size() && ops[skip] == '(' &&
+ ((m->first && m->first->method) || m->second.is_function() ||
+ m->second.is_function_handle())) {
+ args.append(*idx_it++);
+ ++skip;
+ sub_ovl = member_invoke(m, args, nargout);
+ } else {
+ sub_ovl = member_deref(m, args);
+ }
+ }
+ // index operator
+ else {
+ if (ops[skip] == '(' || ops[skip] == '{') {
+ const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
+ octave_value_list args;
+ args.append(*idx_it++);
+ ++skip;
+ if (!dispatch_index_op(op_name, args, sub_ovl)) {
+ error("error evaluating index operator");
+ return octave_value_list();
+ }
+ } else {
+ error("unsupported subsref");
+ return octave_value_list();
+ }
+ }
+
+ if (skip >= (int) ops.size())
+ return sub_ovl;
+ if (sub_ovl.length() < 1) {
+ error("bad subs ref");
+ return octave_value_list();
+ }
+ return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
+ }
+
+ octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
+ assert(ops.size() > 0);
+ assert(ops.size() == idx.size());
+
+ std::list < octave_value_list >::const_iterator idx_it = idx.begin();
+ int skip = 0;
+
+ if (ops.size() > 1) {
+ std::list < octave_value_list >::const_iterator last = idx.end();
+ --last;
+ std::list < octave_value_list > next_idx(idx.begin(), last);
+ octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
+ next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
+ }
+
+ else if (ops[skip] == '(' || ops[skip] == '{') {
+ const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
+ member_value_pair *m = find_member(op_name, false);
+ if (m) {
+ octave_value_list args;
+ args.append(as_value());
+ args.append(*idx_it);
+ args.append(rhs);
+ member_invoke(m, args, 1);
+ } else
+ error("%s member not found", op_name);
+ }
+
+ else if (ops[skip] == '.') {
+ octave_value_list subname_ovl(*idx_it++);
+ ++skip;
+ assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
+ std::string subname = subname_ovl(0).string_value();
+
+ member_value_pair *m = find_member(subname, true);
+ if (!m->first || !m->first->set_method) {
+ m->first = 0;
+ m->second = rhs;
+ } else if (m->first->set_method) {
+ octave_value_list args;
+ if (!m->first->is_static() && !m->first->is_global())
+ args.append(as_value());
+ args.append(rhs);
+ m->first->set_method(args, 1);
+ } else
+ error("member not assignable");
+ } else
+ error("unsupported subsasgn");
+
+ return as_value();
+ }
+
+ virtual bool is_string() const {
+ octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
+ return !!nc_this->find_member("__str__", false);
+ }
+
+ virtual std::string string_value(bool force = false) const {
+ octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
+ member_value_pair *m = nc_this->find_member("__str__", false);
+ if (!m) {
+ error("__str__ method not defined");
+ return std::string();
+ }
+ octave_value_list outarg = nc_this->member_invoke(m, octave_value_list(nc_this->as_value()), 1);
+ if (outarg.length() < 1 || !outarg(0).is_string()) {
+ error("__str__ method did not return a string");
+ return std::string();
+ }
+ return outarg(0).string_value();
+ }
+
+ virtual Octave_map map_value() const {
+ return Octave_map();
+ }
+
+ virtual string_vector map_keys() const {
+ member_map tmp;
+ load_members(tmp);
+
+ string_vector keys(tmp.size());
+ int k = 0;
+ for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
+ keys(k++) = it->first;
+
+ return keys;
+ }
+
+ virtual bool save_ascii (std::ostream& os) {
+ return true;
+ }
+
+ virtual bool load_ascii (std::istream& is) {
+ return true;
+ }
+
+ virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
+ return true;
+ }
+
+ virtual bool load_binary (std::istream& is, bool swap,
+ oct_mach_info::float_format fmt) {
+ return true;
+ }
+
+#if defined (HAVE_HDF5)
+ virtual bool
+ save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
+ return true;
+ }
+
+ virtual bool
+ load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
+ return true;
+ }
+#endif
+
+ virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
+ return string_value();
+ }
+
+ virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
+ return string_value();
+ }
+
+ static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
+ // we assume that "op_"-prefixed functions are installed in global namespace
+ // (rather than any module namespace).
+
+ octave_value fcn = get_global_value(symbol, true);
+ if (!fcn.is_function() && !fcn.is_function_handle())
+ return false;
+ ret = fcn.subsref("(", std::list < octave_value_list > (1, args));
+ return true;
+ }
+
+ static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
+ octave_swig_type *ost = Swig::swig_value_deref(x);
+ assert(ost);
+
+ octave_value ret;
+ if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
+ return ret;
+ std::string symbol = "op_" + ost->swig_type_name() + "_" + op_name;
+ octave_value_list args;
+ args.append(make_value_hack(x));
+ if (dispatch_global_op(symbol, args, ret))
+ return ret;
+
+ error("could not dispatch unary operator");
+ return octave_value();
+ }
+
+ static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
+ octave_swig_type *lhs_ost = Swig::swig_value_deref(lhs);
+ octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
+
+ octave_value ret;
+ if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
+ return ret;
+
+ std::string symbol;
+ octave_value_list args;
+ args.append(make_value_hack(lhs));
+ args.append(make_value_hack(rhs));
+
+ symbol = "op_";
+ symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
+ symbol += "_";
+ symbol += op_name;
+ symbol += "_";
+ symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
+ if (dispatch_global_op(symbol, args, ret))
+ return ret;
+
+ symbol = "op_";
+ symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
+ symbol += "_";
+ symbol += op_name;
+ symbol += "_";
+ symbol += "any";
+ if (dispatch_global_op(symbol, args, ret))
+ return ret;
+
+ symbol = "op_";
+ symbol += "any";
+ symbol += "_";
+ symbol += op_name;
+ symbol += "_";
+ symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
+ if (dispatch_global_op(symbol, args, ret))
+ return ret;
+
+ error("could not dispatch binary operator");
+ return octave_value();
+ }
+
+ void print(std::ostream &os, bool pr_as_read_syntax = false) const {
+ if (is_string()) {
+ os << string_value();
+ return;
+ }
+
+ member_map tmp;
+ load_members(tmp);
+
+ os << "{" << std::endl;
+ for (unsigned int j = 0; j < types.size(); ++j) {
+ if (types[j].first->clientdata) {
+ const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
+ os << " " << c->name << ", ptr = " << types[j].second.ptr << std::endl;
+ } else {
+ os << " " << types[j].first->name << ", ptr = " << types[j].second.ptr << std::endl;
+ }
+ }
+ for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
+ if (it->second.first) {
+ const char *objtype = it->second.first->method ? "method" : "variable";
+ const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
+ os << " " << it->second.first->name << " (" << modifier << objtype << ")" << std::endl;
+ assert(it->second.first->name == it->first);
+ } else {
+ os << " " << it->first << std::endl;
+ }
+ }
+ os << "}" << std::endl;
+ }
+ };
+
+ // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
+ // will call clone() via make_unique() if there is more than one outstanding
+ // reference to the lhs, and forces the clone's reference count to 1
+ // (so you can't just increment your own count and return this).
+ //
+ // One way to fix this (without modifying Octave) is to add a level of
+ // indirection such that clone copies ref-counted pointer and we keep
+ // pass-by-ref semantics (which are more natural/expected for C++ bindings).
+ //
+ // Supporting both pass-by-{ref,value} and toggling via %feature/option
+ // might be nice.
+
+ class octave_swig_ref:public octave_base_value {
+ octave_swig_type *ptr;
+ public:
+ octave_swig_ref(octave_swig_type *_ptr = 0)
+ :ptr(_ptr) { }
+
+ ~octave_swig_ref()
+ { if (ptr) ptr->decref(); }
+
+ octave_swig_type *get_ptr() const
+ { return ptr; }
+
+ octave_base_value *clone() const
+ { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
+
+ octave_base_value *empty_clone() const
+ { return new octave_swig_ref(0); }
+
+ bool is_defined() const
+ { return ptr->is_defined(); }
+
+ virtual bool is_map() const
+ { return ptr->is_map(); }
+
+ virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
+ { return ptr->subsref(ops, idx); }
+
+ virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
+ { return ptr->subsref(ops, idx, nargout); }
+
+ octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
+ { return ptr->subsasgn(ops, idx, rhs); }
+
+ virtual bool is_string() const
+ { return ptr->is_string(); }
+
+ virtual std::string string_value(bool force = false) const
+ { return ptr->string_value(force); }
+
+ virtual Octave_map map_value() const
+ { return ptr->map_value(); }
+
+ virtual string_vector map_keys() const
+ { return ptr->map_keys(); }
+
+ virtual bool save_ascii (std::ostream& os)
+ { return ptr->save_ascii(os); }
+
+ virtual bool load_ascii (std::istream& is)
+ { return ptr->load_ascii(is); }
+
+ virtual bool save_binary (std::ostream& os, bool& save_as_floats)
+ { return ptr->save_binary(os, save_as_floats); }
+
+ virtual bool load_binary (std::istream& is, bool swap,
+ oct_mach_info::float_format fmt)
+ { return ptr->load_binary(is, swap, fmt); }
+
+#if defined (HAVE_HDF5)
+ virtual bool
+ save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
+ { return ptr->save_hdf5(loc_id, name, save_as_floats); }
+
+ virtual bool
+ load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
+ { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
+#endif
+
+ virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
+ { return ptr->convert_to_str(pad, force, type); }
+
+ virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
+ { return ptr->convert_to_str_internal(pad, force, type); }
+
+ void print(std::ostream &os, bool pr_as_read_syntax = false) const
+ { return ptr->print(os, pr_as_read_syntax); }
+
+ private:
+ DECLARE_OCTAVE_ALLOCATOR;
+ DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA;
+ };
+ DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref);
+ DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref");
+
+ class octave_swig_packed:public octave_base_value {
+ swig_type_info *type;
+ std::vector < char > buf;
+ public:
+
+ octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
+ : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len) {
+ }
+
+ bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
+ if (outtype && outtype != type)
+ return false;
+ assert(sz <= buf.size());
+ std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
+ return true;
+ }
+
+ octave_base_value *clone() const {
+ return new octave_swig_packed(*this);
+ }
+
+ octave_base_value *empty_clone() const {
+ return new octave_swig_packed();
+ }
+
+ bool is_defined() const {
+ return true;
+ }
+
+ void print(std::ostream &os, bool pr_as_read_syntax = false) const {
+ os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size() << std::endl;
+ }
+
+
+ virtual bool save_ascii (std::ostream& os) {
+ return true;
+ }
+
+ virtual bool load_ascii (std::istream& is) {
+ return true;
+ }
+
+ virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
+ return true;
+ }
+
+ virtual bool load_binary (std::istream& is, bool swap,
+ oct_mach_info::float_format fmt) {
+ return true;
+ }
+
+#if defined (HAVE_HDF5)
+ virtual bool
+ save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
+ return true;
+ }
+
+ virtual bool
+ load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
+ return true;
+ }
+#endif
+
+ private:
+ DECLARE_OCTAVE_ALLOCATOR;
+ DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA;
+ };
+ DEFINE_OCTAVE_ALLOCATOR(octave_swig_packed);
+ DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_packed, "swig_packed", "swig_packed");
+
+ static octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
+ error("attempt to set immutable member variable");
+ return octave_value_list();
+ }
+
+ struct octave_value_ref {
+ const octave_value_list &ovl;
+ int j;
+
+ octave_value_ref(const octave_value_list &_ovl, int _j)
+ :ovl(_ovl), j(_j) { }
+
+ operator octave_value() const {
+ return ovl(j);
+ }
+
+ octave_value operator*() const {
+ return ovl(j);
+ }
+ };
+
+ octave_value_list swig_subclass(const octave_value_list &args, int nargout) {
+ octave_swig_type *top = new octave_swig_type;
+ for (int j = 0; j < args.length(); ++j) {
+ if (args(j).type_id() == octave_swig_ref::static_type_id()) {
+ octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
+ octave_swig_type *ost = osr->get_ptr();
+ if (!ost->is_owned()) {
+ error("cannot subclass object not constructed on octave side");
+ return octave_value_list();
+ }
+ top->merge(*ost);
+ } else if (args(j).is_function_handle()) {
+ top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
+ } else if (args(j).is_string()) {
+ if (j + 1 >= args.length()) {
+ error("member assignments must be of string,value form");
+ return octave_value_list();
+ }
+ top->assign(args(j).string_value(), args(j + 1));
+ ++j;
+ } else {
+ error("invalid arguments to subclass");
+ return octave_value_list();
+ }
+ }
+ return octave_value(Swig::swig_value_ref(top));
+ }
+
+ octave_value_list swig_type(const octave_value_list &args, int nargout) {
+ if (args.length() != 1) {
+ error("swig_typeinfo must be called with only a single object");
+ return octave_value_list();
+ }
+ octave_swig_type *ost = Swig::swig_value_deref(args(0));
+ if (!ost) {
+ error("object is not a swig_ref");
+ return octave_value_list();
+ }
+ return octave_value(ost->swig_type_name());
+ }
+
+ octave_value_list swig_typequery(const octave_value_list &args, int nargout) {
+ if (args.length() != 1 || !args(0).is_string()) {
+ error("swig_typeinfo must be called with single string argument");
+ return octave_value_list();
+ }
+ swig_module_info *module = SWIG_GetModule(0);
+ swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
+ if (!type)
+ return octave_value("<unknown>");
+ return octave_value(type->name);
+ }
+
+ octave_value_list swig_this(const octave_value_list &args, int nargout) {
+ if (args.length() != 1) {
+ error("swig_typeinfo must be called with only a single object");
+ return octave_value_list();
+ }
+ if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
+ return octave_value(octave_uint64(0));
+ octave_swig_type *ost = Swig::swig_value_deref(args(0));
+ if (!ost) {
+ error("object is not a swig_ref");
+ return octave_value_list();
+ }
+ return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
+ }
+
+#define SWIG_DIRECTORS
+
+namespace Swig {
+ class Director {
+ octave_swig_type *self;
+ bool disowned;
+
+ Director(const Director &x);
+ Director &operator=(const Director &rhs);
+ public:
+
+ Director(void *vptr):self(0), disowned(false) {
+ set_rtdir(vptr, this);
+ }
+
+ ~Director() {
+ swig_director_destroyed(self, this);
+ if (disowned)
+ self->decref();
+ }
+
+ void swig_set_self(octave_swig_type *new_self) {
+ assert(!disowned);
+ self = new_self;
+ }
+
+ octave_swig_type *swig_get_self() const {
+ return self;
+ }
+
+ void swig_disown() {
+ if (disowned)
+ return;
+ disowned = true;
+ self->incref();
+ }
+ };
+
+ struct DirectorTypeMismatchException {
+ static void raise(const char *msg) {
+ // ... todo
+ throw(DirectorTypeMismatchException());
+ }
+
+ static void raise(const octave_value &ov, const char *msg) {
+ // ... todo
+ raise(msg);
+ }
+ };
+ struct DirectorPureVirtualException {
+ static void raise(const char *msg) {
+ // ... todo
+ throw(DirectorPureVirtualException());
+ }
+
+ static void raise(const octave_value &ov, const char *msg) {
+ // ... todo
+ raise(msg);
+ }
+ };
+
+}
+
+ SWIGRUNTIME void swig_acquire_ownership(void *vptr) {
+ // assert(0);
+ // ... todo
+ }
+
+ SWIGRUNTIME void swig_acquire_ownership_array(void *vptr) {
+ // assert(0);
+ // ... todo
+ }
+
+ SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own) {
+ // assert(0);
+ // ... todo
+ }
+
+ namespace Swig {
+ SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d) {
+ self->director_destroyed(d);
+ }
+
+ SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self) {
+ d->swig_set_self(self);
+ }
+
+ SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost) {
+ return new octave_swig_ref(ost);
+ }
+
+ SWIGRUNTIME octave_swig_type *swig_value_deref(octave_value ov) {
+ if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
+ ov = ov.cell_value()(0);
+ return swig_value_deref(*ov.internal_rep());
+ }
+
+ SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
+ if (ov.type_id() != octave_swig_ref::static_type_id())
+ return 0;
+ const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
+ return osr->get_ptr();
+ }
+
+ }
+
+#define swig_unary_op(name) \
+SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
+ return octave_swig_type::dispatch_unary_op(x,#name); \
+}
+#define swig_binary_op(name) \
+SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
+ return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
+}
+#define swigreg_unary_op(name) \
+if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
+octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
+#define swigreg_binary_op(name) \
+if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
+octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
+
+ swig_unary_op(not);
+ swig_unary_op(uplus);
+ swig_unary_op(uminus);
+ swig_unary_op(transpose);
+ swig_unary_op(hermitian);
+ swig_unary_op(incr);
+ swig_unary_op(decr);
+
+ swig_binary_op(add);
+ swig_binary_op(sub);
+ swig_binary_op(mul);
+ swig_binary_op(div);
+ swig_binary_op(pow);
+ swig_binary_op(ldiv);
+ swig_binary_op(lshift);
+ swig_binary_op(rshift);
+ swig_binary_op(lt);
+ swig_binary_op(le);
+ swig_binary_op(eq);
+ swig_binary_op(ge);
+ swig_binary_op(gt);
+ swig_binary_op(ne);
+ swig_binary_op(el_mul);
+ swig_binary_op(el_div);
+ swig_binary_op(el_pow);
+ swig_binary_op(el_ldiv);
+ swig_binary_op(el_and);
+ swig_binary_op(el_or);
+
+ SWIGRUNTIME void SWIG_InstallUnaryOps(int tid) {
+ swigreg_unary_op(not);
+ swigreg_unary_op(uplus);
+ swigreg_unary_op(uminus);
+ swigreg_unary_op(transpose);
+ swigreg_unary_op(hermitian);
+ swigreg_unary_op(incr);
+ swigreg_unary_op(decr);
+ }
+ SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
+ swigreg_binary_op(add);
+ swigreg_binary_op(sub);
+ swigreg_binary_op(mul);
+ swigreg_binary_op(div);
+ swigreg_binary_op(pow);
+ swigreg_binary_op(ldiv);
+ swigreg_binary_op(lshift);
+ swigreg_binary_op(rshift);
+ swigreg_binary_op(lt);
+ swigreg_binary_op(le);
+ swigreg_binary_op(eq);
+ swigreg_binary_op(ge);
+ swigreg_binary_op(gt);
+ swigreg_binary_op(ne);
+ swigreg_binary_op(el_mul);
+ swigreg_binary_op(el_div);
+ swigreg_binary_op(el_pow);
+ swigreg_binary_op(el_ldiv);
+ swigreg_binary_op(el_and);
+ swigreg_binary_op(el_or);
+ }
+ SWIGRUNTIME void SWIG_InstallOps(int tid) {
+ // here we assume that tid are conseq integers increasing from zero, and
+ // that our tid is the last one. might be better to have explicit string
+ // list of types we should bind to, and use lookup_type to resolve their tid.
+
+ SWIG_InstallUnaryOps(tid);
+ SWIG_InstallBinaryOps(tid, tid);
+ for (int j = 0; j < tid; ++j) {
+ SWIG_InstallBinaryOps(j, tid);
+ SWIG_InstallBinaryOps(tid, j);
+ }
+ }
+
+SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
+ int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
+
+ Swig::Director *d = Swig::get_rtdir(ptr);
+ if (d && d->swig_get_self())
+ return d->swig_get_self()->as_value();
+ return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
+}
+
+SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
+ if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
+ ov = ov.cell_value()(0);
+ if (!ov.is_defined() ||
+ (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
+ if (ptr)
+ *ptr = 0;
+ return SWIG_OK;
+ }
+ if (ov.type_id() != octave_swig_ref::static_type_id())
+ return SWIG_ERROR;
+ octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
+ octave_swig_type *ost = osr->get_ptr();
+ void *vptr = ost->cast(type, own, flags);
+ if (!vptr)
+ return SWIG_ERROR;
+ if (ptr)
+ *ptr = vptr;
+ return SWIG_OK;
+}
+
+SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
+ return new octave_swig_packed(type, (char *) ptr, sz);
+}
+
+SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
+ if (!ov.is_defined())
+ return SWIG_ERROR;
+ if (ov.type_id() != octave_swig_packed::static_type_id())
+ return SWIG_ERROR;
+ octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
+ return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
+}
+
+void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
+ module_ns->assign(name, ov);
+}
+
+SWIGRUNTIME swig_module_info *SWIG_Octave_GetModule(void *clientdata) {
+ octave_value ov = get_global_value("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION, true);
+ if (!ov.is_defined() ||
+ ov.type_id() != octave_swig_packed::static_type_id())
+ return 0;
+ const octave_swig_packed* osp =
+ static_cast < const octave_swig_packed *> (ov.internal_rep());
+ swig_module_info *pointer = 0;
+ osp->copy(0, &pointer, sizeof(swig_module_info *));
+ return pointer;
+}
+
+SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
+ octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
+ const char *module_var = "__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION;
+#if USE_OCTAVE_API_VERSION<37
+ link_to_global_variable(curr_sym_tab->lookup(module_var, true));
+#else
+ symbol_table::varref(module_var);
+ symbol_table::mark_global(module_var);
+#endif
+ set_global_value(module_var, ov);
+}
+
+
+
+#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)
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_m_CvSVMKernel__f_int_int_p_p_q_const__float_p_q_const__float_p_float__void swig_types[0]
+#define SWIGTYPE_m_CvSVMSolver__f_int_p_float_p_float_bool__p_float swig_types[1]
+#define SWIGTYPE_m_CvSVMSolver__f_r_double_r_double__void swig_types[2]
+#define SWIGTYPE_m_CvSVMSolver__f_r_int_r_int__bool swig_types[3]
+#define SWIGTYPE_p_Calc swig_types[4]
+#define SWIGTYPE_p_CalcRho swig_types[5]
+#define SWIGTYPE_p_Cv32suf swig_types[6]
+#define SWIGTYPE_p_Cv64suf swig_types[7]
+#define SWIGTYPE_p_CvANN_MLP swig_types[8]
+#define SWIGTYPE_p_CvANN_MLP_TrainParams swig_types[9]
+#define SWIGTYPE_p_CvAttrList swig_types[10]
+#define SWIGTYPE_p_CvAvgComp swig_types[11]
+#define SWIGTYPE_p_CvBoost swig_types[12]
+#define SWIGTYPE_p_CvBoostParams swig_types[13]
+#define SWIGTYPE_p_CvBoostTree swig_types[14]
+#define SWIGTYPE_p_CvBox2D swig_types[15]
+#define SWIGTYPE_p_CvChain swig_types[16]
+#define SWIGTYPE_p_CvChainPtReader swig_types[17]
+#define SWIGTYPE_p_CvConDensation swig_types[18]
+#define SWIGTYPE_p_CvConnectedComp swig_types[19]
+#define SWIGTYPE_p_CvContour swig_types[20]
+#define SWIGTYPE_p_CvContourTree swig_types[21]
+#define SWIGTYPE_p_CvConvexityDefect swig_types[22]
+#define SWIGTYPE_p_CvDTree swig_types[23]
+#define SWIGTYPE_p_CvDTreeNode swig_types[24]
+#define SWIGTYPE_p_CvDTreeParams swig_types[25]
+#define SWIGTYPE_p_CvDTreeSplit swig_types[26]
+#define SWIGTYPE_p_CvDTreeTrainData swig_types[27]
+#define SWIGTYPE_p_CvEM swig_types[28]
+#define SWIGTYPE_p_CvEMParams swig_types[29]
+#define SWIGTYPE_p_CvERTreeTrainData swig_types[30]
+#define SWIGTYPE_p_CvERTrees swig_types[31]
+#define SWIGTYPE_p_CvFileNode swig_types[32]
+#define SWIGTYPE_p_CvFileStorage swig_types[33]
+#define SWIGTYPE_p_CvFilter swig_types[34]
+#define SWIGTYPE_p_CvFont swig_types[35]
+#define SWIGTYPE_p_CvForestERTree swig_types[36]
+#define SWIGTYPE_p_CvForestTree swig_types[37]
+#define SWIGTYPE_p_CvGenericHash swig_types[38]
+#define SWIGTYPE_p_CvGraph swig_types[39]
+#define SWIGTYPE_p_CvGraphEdge swig_types[40]
+#define SWIGTYPE_p_CvGraphScanner swig_types[41]
+#define SWIGTYPE_p_CvGraphVtx swig_types[42]
+#define SWIGTYPE_p_CvGraphVtx2D swig_types[43]
+#define SWIGTYPE_p_CvHaarClassifier swig_types[44]
+#define SWIGTYPE_p_CvHaarClassifierCascade swig_types[45]
+#define SWIGTYPE_p_CvHaarFeature swig_types[46]
+#define SWIGTYPE_p_CvHaarStageClassifier swig_types[47]
+#define SWIGTYPE_p_CvHidHaarClassifierCascade swig_types[48]
+#define SWIGTYPE_p_CvHistogram swig_types[49]
+#define SWIGTYPE_p_CvHuMoments swig_types[50]
+#define SWIGTYPE_p_CvKNearest swig_types[51]
+#define SWIGTYPE_p_CvKalman swig_types[52]
+#define SWIGTYPE_p_CvLineIterator swig_types[53]
+#define SWIGTYPE_p_CvMLData swig_types[54]
+#define SWIGTYPE_p_CvMSERParams swig_types[55]
+#define SWIGTYPE_p_CvMat swig_types[56]
+#define SWIGTYPE_p_CvMatND swig_types[57]
+#define SWIGTYPE_p_CvMatrix3 swig_types[58]
+#define SWIGTYPE_p_CvMemBlock swig_types[59]
+#define SWIGTYPE_p_CvMemStorage swig_types[60]
+#define SWIGTYPE_p_CvMemStoragePos swig_types[61]
+#define SWIGTYPE_p_CvModuleInfo swig_types[62]
+#define SWIGTYPE_p_CvMoments swig_types[63]
+#define SWIGTYPE_p_CvNArrayIterator swig_types[64]
+#define SWIGTYPE_p_CvNextEdgeType swig_types[65]
+#define SWIGTYPE_p_CvNormalBayesClassifier swig_types[66]
+#define SWIGTYPE_p_CvPOSITObject swig_types[67]
+#define SWIGTYPE_p_CvPair16u32s swig_types[68]
+#define SWIGTYPE_p_CvParamGrid swig_types[69]
+#define SWIGTYPE_p_CvPluginFuncInfo swig_types[70]
+#define SWIGTYPE_p_CvPoint swig_types[71]
+#define SWIGTYPE_p_CvPoint2D32f swig_types[72]
+#define SWIGTYPE_p_CvPoint2D64f swig_types[73]
+#define SWIGTYPE_p_CvPoint3D32f swig_types[74]
+#define SWIGTYPE_p_CvPoint3D64f swig_types[75]
+#define SWIGTYPE_p_CvQuadEdge2D swig_types[76]
+#define SWIGTYPE_p_CvRNG_Wrapper swig_types[77]
+#define SWIGTYPE_p_CvRTParams swig_types[78]
+#define SWIGTYPE_p_CvRTrees swig_types[79]
+#define SWIGTYPE_p_CvRect swig_types[80]
+#define SWIGTYPE_p_CvSURFParams swig_types[81]
+#define SWIGTYPE_p_CvSURFPoint swig_types[82]
+#define SWIGTYPE_p_CvSVM swig_types[83]
+#define SWIGTYPE_p_CvSVMDecisionFunc swig_types[84]
+#define SWIGTYPE_p_CvSVMKernel swig_types[85]
+#define SWIGTYPE_p_CvSVMKernelRow swig_types[86]
+#define SWIGTYPE_p_CvSVMParams swig_types[87]
+#define SWIGTYPE_p_CvSVMSolutionInfo swig_types[88]
+#define SWIGTYPE_p_CvSVMSolver swig_types[89]
+#define SWIGTYPE_p_CvScalar swig_types[90]
+#define SWIGTYPE_p_CvSeq swig_types[91]
+#define SWIGTYPE_p_CvSeqBlock swig_types[92]
+#define SWIGTYPE_p_CvSeqReader swig_types[93]
+#define SWIGTYPE_p_CvSeqWriter swig_types[94]
+#define SWIGTYPE_p_CvSet swig_types[95]
+#define SWIGTYPE_p_CvSetElem swig_types[96]
+#define SWIGTYPE_p_CvSize swig_types[97]
+#define SWIGTYPE_p_CvSize2D32f swig_types[98]
+#define SWIGTYPE_p_CvSlice swig_types[99]
+#define SWIGTYPE_p_CvSparseMat swig_types[100]
+#define SWIGTYPE_p_CvSparseMatIterator swig_types[101]
+#define SWIGTYPE_p_CvSparseNode swig_types[102]
+#define SWIGTYPE_p_CvStarDetectorParams swig_types[103]
+#define SWIGTYPE_p_CvStarKeypoint swig_types[104]
+#define SWIGTYPE_p_CvStatModel swig_types[105]
+#define SWIGTYPE_p_CvStereoBMState swig_types[106]
+#define SWIGTYPE_p_CvStereoGCState swig_types[107]
+#define SWIGTYPE_p_CvString swig_types[108]
+#define SWIGTYPE_p_CvStringHashNode swig_types[109]
+#define SWIGTYPE_p_CvSubdiv2D swig_types[110]
+#define SWIGTYPE_p_CvSubdiv2DEdge_Wrapper swig_types[111]
+#define SWIGTYPE_p_CvSubdiv2DPoint swig_types[112]
+#define SWIGTYPE_p_CvSubdiv2DPointLocation swig_types[113]
+#define SWIGTYPE_p_CvTermCriteria swig_types[114]
+#define SWIGTYPE_p_CvTrainTestSplit swig_types[115]
+#define SWIGTYPE_p_CvTrainTestSplit_class_part swig_types[116]
+#define SWIGTYPE_p_CvTrainTestSplit_train_sample_part swig_types[117]
+#define SWIGTYPE_p_CvTreeNodeIterator swig_types[118]
+#define SWIGTYPE_p_CvTypeInfo swig_types[119]
+#define SWIGTYPE_p_CvVectors swig_types[120]
+#define SWIGTYPE_p_CvVectors_data swig_types[121]
+#define SWIGTYPE_p_GetRow swig_types[122]
+#define SWIGTYPE_p_SelectWorkingSet swig_types[123]
+#define SWIGTYPE_p__IplConvKernel swig_types[124]
+#define SWIGTYPE_p__IplConvKernelFP swig_types[125]
+#define SWIGTYPE_p__IplImage swig_types[126]
+#define SWIGTYPE_p__IplROI swig_types[127]
+#define SWIGTYPE_p__IplTileInfo swig_types[128]
+#define SWIGTYPE_p_bool swig_types[129]
+#define SWIGTYPE_p_char swig_types[130]
+#define SWIGTYPE_p_double swig_types[131]
+#define SWIGTYPE_p_float swig_types[132]
+#define SWIGTYPE_p_int swig_types[133]
+#define SWIGTYPE_p_int64_t swig_types[134]
+#define SWIGTYPE_p_p_CvMat swig_types[135]
+#define SWIGTYPE_p_p_double swig_types[136]
+#define SWIGTYPE_p_p_float swig_types[137]
+#define SWIGTYPE_p_p_int swig_types[138]
+#define SWIGTYPE_p_p_unsigned_char swig_types[139]
+#define SWIGTYPE_p_signed_char swig_types[140]
+#define SWIGTYPE_p_size_t swig_types[141]
+#define SWIGTYPE_p_uint64_t swig_types[142]
+#define SWIGTYPE_p_unsigned_char swig_types[143]
+#define SWIGTYPE_p_unsigned_short swig_types[144]
+#define SWIGTYPE_p_vectorT_float_t swig_types[145]
+#define SWIGTYPE_p_vectorT_vectorT_float_t_t swig_types[146]
+#define SWIGTYPE_p_vectorT_vectorT_int_t_t swig_types[147]
+#define SWIGTYPE_p_void swig_types[148]
+static swig_type_info *swig_types[150];
+static swig_module_info swig_module = {swig_types, 149, 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) -------- */
+
+
+#define SWIGVERSION 0x010340
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) (void *)((const void *)(a))
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
+
+
+#include <stdexcept>
+
+
+#include <ml.h>
+#include <cxtypes.h>
+#include <cv.h>
+#include <highgui.h>
+#include "octhelpers.h"
+#include "octcvseq.hpp"
+
+
+
+
+ static inline bool OctSwigObject_Check(const octave_value& ov) {
+ return ov.type_id()==octave_swig_ref::static_type_id();
+ }
+
+ static CvArr * OctObject_to_CvArr(octave_value obj, bool * freearg);
+ static CvArr * OctSequence_to_CvArr( octave_value obj );
+
+ // convert a octave sequence/array/list object into a c-array
+#define OctObject_AsArrayImpl(func, ctype, ptype) \
+ int func(octave_value obj, ctype * array, int len){ \
+ void * mat_vptr=NULL; \
+ void * im_vptr=NULL; \
+ if(OctNumber_Check(obj)){ \
+ memset( array, 0, sizeof(ctype)*len ); \
+ array[0] = OctObject_As##ptype( obj ); \
+ } \
+ else if(OctList_Check(obj) || OctTuple_Check(obj)){ \
+ int seqsize = OctSequence_Size(obj); \
+ for(int i=0; i<len && i<seqsize; i++){ \
+ if(i<seqsize){ \
+ array[i] = OctObject_As##ptype( OctSequence_GetItem(obj, i) ); \
+ } \
+ else{ \
+ array[i] = 0; \
+ } \
+ } \
+ } \
+ else if( SWIG_ConvertPtr(obj, &mat_vptr, SWIGTYPE_p_CvMat, 0)!=-1 || \
+ SWIG_ConvertPtr(obj, &im_vptr, SWIGTYPE_p__IplImage, 0)!=-1) \
+ { \
+ CvMat * mat = (CvMat *) mat_vptr; \
+ CvMat stub; \
+ if(im_vptr) mat = cvGetMat(im_vptr, &stub); \
+ if( mat->rows!=1 && mat->cols!=1 ){ \
+ error("OctObject_As*Array: CvArr must be row or column vector" ); \
+ return -1; \
+ } \
+ if( mat->rows==1 && mat->cols==1 ){ \
+ CvScalar val; \
+ if( len!=CV_MAT_CN(mat->type) ){ \
+ error("OctObject_As*Array: CvArr channels != length" ); \
+ return -1; \
+ } \
+ val = cvGet1D(mat, 0); \
+ for(int i=0; i<len; i++){ \
+ array[i] = (ctype) val.val[i]; \
+ } \
+ } \
+ else{ \
+ mat = cvReshape(mat, &stub, -1, mat->rows*mat->cols); \
+ if( mat->rows != len ){ \
+ error("OctObject_As*Array: CvArr rows or cols must equal length" ); \
+ return -1; \
+ } \
+ for(int i=0; i<len; i++){ \
+ CvScalar val = cvGet1D(mat, i); \
+ array[i] = (ctype) val.val[0]; \
+ } \
+ } \
+ } \
+ else{ \
+ error("OctObject_As*Array: Expected a number, sequence or CvArr" ); \
+ return -1; \
+ } \
+ return 0; \
+ }
+
+ OctObject_AsArrayImpl( OctObject_AsFloatArray, float, Double );
+ OctObject_AsArrayImpl( OctObject_AsDoubleArray, double, Double );
+ OctObject_AsArrayImpl( OctObject_AsLongArray, int, Long );
+
+ static CvPoint OctObject_to_CvPoint(octave_value obj){
+ CvPoint val;
+ CvPoint *ptr;
+ CvPoint2D32f * ptr2D32f;
+ CvScalar * scalar;
+
+ if( SWIG_ConvertPtr(obj, (void**)&ptr, SWIGTYPE_p_CvPoint, 0) != -1) {
+ return *ptr;
+ }
+ if( SWIG_ConvertPtr(obj, (void**)&ptr2D32f, SWIGTYPE_p_CvPoint2D32f, 0) != -1) {
+ return cvPointFrom32f( *ptr2D32f );
+ }
+ if( SWIG_ConvertPtr(obj, (void**)&scalar, SWIGTYPE_p_CvScalar, 0) != -1) {
+ return cvPointFrom32f(cvPoint2D32f( scalar->val[0], scalar->val[1] ));
+ }
+ if(OctObject_AsLongArray(obj, (int *) &val, 2) != -1){
+ return val;
+ }
+
+ error("could not convert to CvPoint");
+ return cvPoint(0,0);
+ }
+
+ static CvPoint2D32f OctObject_to_CvPoint2D32f(octave_value obj){
+ CvPoint2D32f val;
+ CvPoint2D32f *ptr2D32f;
+ CvPoint *ptr;
+ CvScalar * scalar;
+ if( SWIG_ConvertPtr(obj, (void**)&ptr2D32f, SWIGTYPE_p_CvPoint2D32f, 0) != -1) {
+ return *ptr2D32f;
+ }
+ if( SWIG_ConvertPtr(obj, (void**)&ptr, SWIGTYPE_p_CvPoint, 0) != -1) {
+ return cvPointTo32f(*ptr);
+ }
+ if( SWIG_ConvertPtr(obj, (void**)&scalar, SWIGTYPE_p_CvScalar, 0) != -1) {
+ return cvPoint2D32f( scalar->val[0], scalar->val[1] );
+ }
+ if(OctObject_AsFloatArray(obj, (float *) &val, 2) != -1){
+ return val;
+ }
+ error("could not convert to CvPoint2D32f");
+ return cvPoint2D32f(0,0);
+ }
+
+ static CvScalar OctObject_to_CvScalar(octave_value obj){
+ CvScalar val;
+ CvScalar * ptr;
+ CvPoint2D32f *ptr2D32f;
+ CvPoint *pt_ptr;
+ void * vptr;
+ if( SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvScalar, 0 ) != -1)
+ {
+ ptr = (CvScalar *) vptr;
+ return *ptr;
+ }
+ if( SWIG_ConvertPtr(obj, (void**)&ptr2D32f, SWIGTYPE_p_CvPoint2D32f, 0) != -1) {
+ return cvScalar(ptr2D32f->x, ptr2D32f->y);
+ }
+ if( SWIG_ConvertPtr(obj, (void**)&pt_ptr, SWIGTYPE_p_CvPoint, 0) != -1) {
+ return cvScalar(pt_ptr->x, pt_ptr->y);
+ }
+ if(OctObject_AsDoubleArray(obj, val.val, 4)!=-1){
+ return val;
+ }
+ return cvScalar(-1,-1,-1,-1);
+ }
+
+ // if octave sequence type, convert to CvMat or CvMatND
+ static CvArr * OctObject_to_CvArr(octave_value obj, bool * freearg){
+ CvArr * cvarr;
+ *freearg = false;
+
+ // check if OpenCV type
+ if ( OctSwigObject_Check(obj) ){
+ SWIG_ConvertPtr(obj, &cvarr, 0, SWIG_POINTER_EXCEPTION);
+ }
+ else if (OctList_Check(obj) || OctTuple_Check(obj)){
+ cvarr = OctSequence_to_CvArr( obj );
+ *freearg = (cvarr != NULL);
+ }
+ else if (OctLong_Check(obj) && OctLong_AsLong(obj)==0){
+ return NULL;
+ }
+ else {
+ SWIG_ConvertPtr(obj, (void**)&cvarr, 0, SWIG_POINTER_EXCEPTION);
+ }
+ return cvarr;
+ }
+
+ static int OctObject_GetElemType(octave_value obj){
+ void *vptr;
+ if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint, 0) != -1) return CV_32SC2;
+ if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvSize, 0) != -1) return CV_32SC2;
+ if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvRect, 0) != -1) return CV_32SC4;
+ if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvSize2D32f, 0) != -1) return CV_32FC2;
+ if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint2D32f, 0) != -1) return CV_32FC2;
+ if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint3D32f, 0) != -1) return CV_32FC3;
+ if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint2D64f, 0) != -1) return CV_64FC2;
+ if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint3D64f, 0) != -1) return CV_64FC3;
+ if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvScalar, 0) != -1) return CV_64FC4;
+ if(OctTuple_Check(obj) || OctList_Check(obj)) return CV_MAKE_TYPE(CV_32F, OctSequence_Size( obj ));
+ if(OctLong_Check(obj)) return CV_32S;
+ return CV_32F;
+ }
+
+ // Would like this to convert Octave lists to CvMat
+ // Also lists of CvPoints, CvScalars, CvMats? etc
+ static CvArr * OctSequence_to_CvArr( octave_value obj ){
+ int dims[CV_MAX_DIM] = {1,1,1};
+ int ndim=0;
+ int cvtype;
+ octave_value item;
+
+ // figure out dimensions
+ for(item = obj;
+ (OctTuple_Check(item) || OctList_Check(item));
+ item = OctSequence_GetItem(item, 0))
+ {
+ dims[ndim] = OctSequence_Size( item );
+ ndim++;
+ }
+
+ if(ndim==0){
+ error("Cannot convert an empty octave object to a CvArr");
+ return NULL;
+ }
+
+ cvtype = OctObject_GetElemType(item);
+ // collapse last dim into NCH if we found a single channel, but the last dim is <=3
+ if(CV_MAT_CN(cvtype)==1 && dims[ndim-1]>1 && dims[ndim-1]<4){
+ cvtype=CV_MAKE_TYPE(cvtype, dims[ndim-1]);
+ dims[ndim-1]=1;
+ ndim--;
+ }
+
+ if(cvtype==-1){
+ error("Could not determine OpenCV element type of Octave sequence");
+ return NULL;
+ }
+
+ // CvMat
+ if(ndim<=2){
+ CvMat *m = cvCreateMat(dims[0], dims[1], cvtype);
+ for(int i=0; i<dims[0]; i++){
+ octave_value rowobj = OctSequence_GetItem(obj, i);
+ if( dims[1] > 1 ){
+ // double check size
+ assert((OctTuple_Check(rowobj) || OctList_Check(rowobj)) &&
+ OctSequence_Size(rowobj) == dims[1]);
+
+ for(int j=0; j<dims[1]; j++){
+ octave_value colobj = OctSequence_GetItem(rowobj, j);
+ cvSet2D( m, i, j, OctObject_to_CvScalar( colobj ) );
+ }
+ }
+ else{
+ cvSet1D(m, i, OctObject_to_CvScalar( rowobj ) );
+ }
+ }
+ return (CvArr *) m;
+ }
+
+ // CvMatND
+ error("Cannot convert Octave Object to CvArr -- ndim > 3");
+ return NULL;
+ }
+
+
+ // Wrapper class
+ class CvRNG_Wrapper {
+ private:
+ CvRNG m_val;
+ public:
+ CvRNG_Wrapper( const CvRNG & val ) :
+ m_val(val)
+ {
+ }
+ CvRNG * ptr() { return &m_val; }
+ CvRNG & ref() { return m_val; }
+ bool operator==(const CvRNG_Wrapper & x){
+ return m_val==x.m_val;
+ }
+ bool operator!=(const CvRNG_Wrapper & x){
+ return m_val!=x.m_val;
+ }
+ };
+
+
+SWIGINTERNINLINE octave_value
+ SWIG_From_bool (bool value)
+{
+ return octave_value(value);
+}
+
+
+ // Wrapper class
+ class CvSubdiv2DEdge_Wrapper {
+ private:
+ CvSubdiv2DEdge m_val;
+ public:
+ CvSubdiv2DEdge_Wrapper( const CvSubdiv2DEdge & val ) :
+ m_val(val)
+ {
+ }
+ CvSubdiv2DEdge * ptr() { return &m_val; }
+ CvSubdiv2DEdge & ref() { return m_val; }
+ bool operator==(const CvSubdiv2DEdge_Wrapper & x){
+ return m_val==x.m_val;
+ }
+ bool operator!=(const CvSubdiv2DEdge_Wrapper & x){
+ return m_val!=x.m_val;
+ }
+ };
+
+
+ SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
+ {
+ if (!ov.is_scalar_type())
+ return SWIG_TypeError;
+ if (ov.is_complex_scalar())
+ return SWIG_TypeError;
+ if (ov.is_double_type()||ov.is_single_type()) {
+ double v=ov.double_value();
+ if (v<0)
+ return SWIG_OverflowError;
+ if (v!=floor(v))
+ return SWIG_TypeError;
+ }
+ if (ov.is_int8_type()||ov.is_int16_type()||
+ ov.is_int32_type()) {
+ long v=ov.long_value();
+ if (v<0)
+ return SWIG_OverflowError;
+ }
+ if (ov.is_int64_type()) {
+ long long v=ov.int64_scalar_value().value();
+ if (v<0)
+ return SWIG_OverflowError;
+ }
+ if (val)
+ *val = ov.ulong_value();
+ return SWIG_OK;
+ }
+
+
+SWIGINTERNINLINE int
+SWIG_AsVal_size_t (octave_value obj, size_t *val)
+{
+ unsigned long v;
+ int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
+ if (SWIG_IsOK(res) && val) *val = (size_t)(v);
+ return res;
+}
+
+
+ SWIGINTERNINLINE octave_value SWIG_From_long (long value)
+ {
+ return octave_value(value);
+ }
+
+
+SWIGINTERNINLINE octave_value
+SWIG_From_int (int value)
+{
+ return SWIG_From_long (value);
+}
+
+
+#include <limits.h>
+#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_long (const octave_value& ov, long* val)
+ {
+ if (!ov.is_scalar_type())
+ return SWIG_TypeError;
+ if (ov.is_complex_scalar())
+ return SWIG_TypeError;
+ if (ov.is_double_type()||ov.is_single_type()) {
+ double v=ov.double_value();
+ if (v!=floor(v))
+ return SWIG_TypeError;
+ }
+ if (val)
+ *val = ov.long_value();
+ return SWIG_OK;
+ }
+
+
+SWIGINTERN int
+SWIG_AsVal_int (octave_value 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 = (int)(v);
+ }
+ }
+ return res;
+}
+
+
+typedef union {
+ uchar** ptr;
+ float** fl;
+ double** db;
+ } CvVectors_data;
+
+
+
+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;
+}
+
+
+SWIGINTERNINLINE octave_value
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+ return std::string(carray,carray+size);
+}
+
+
+SWIGINTERNINLINE octave_value
+SWIG_FromCharPtr(const char *cptr)
+{
+ return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
+{
+ if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
+ ov = ov.cell_value()(0);
+ if (!ov.is_string())
+ return SWIG_TypeError;
+
+ std::string str=ov.string_value();
+ size_t len=str.size();
+ char* cstr=(char*)str.c_str();
+ if (alloc) {
+ *cptr = (char*)(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
+ *alloc = SWIG_NEWOBJ;
+ } else if (cptr)
+ *cptr = cstr;
+ if (psize)
+ *psize = len + 1;
+ return SWIG_OK;
+}
+
+
+
+
+
+ SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
+ {
+ if (!ov.is_scalar_type())
+ return SWIG_TypeError;
+ if (ov.is_complex_scalar())
+ return SWIG_TypeError;
+ if (val)
+ *val = ov.double_value();
+ return SWIG_OK;
+ }
+
+
+ SWIGINTERNINLINE octave_value SWIG_From_double (double value)
+ {
+ return octave_value(value);
+ }
+
+
+SWIGINTERN int
+SWIG_AsVal_bool (const octave_value& ov, bool *val)
+{
+ if (!ov.is_bool_type())
+ return SWIG_ERROR;
+ if (val)
+ *val = ov.bool_value();
+ return SWIG_OK;
+}
+
+
+SWIGINTERNINLINE octave_value
+SWIG_From_float (float value)
+{
+ return SWIG_From_double (value);
+}
+
+SWIGINTERN octave_value CvEM_get_covs(CvEM *self){
+ CvMat ** pointers = const_cast<CvMat **> (self->get_covs());
+ int n = self->get_nclusters();
+
+ octave_value result = OctTuple_New(n);
+ for (int i=0; i<n; ++i)
+ {
+ octave_value obj = SWIG_NewPointerObj(pointers[i], SWIGTYPE_p_CvMat, 0);
+ OctTuple_SetItem(result, i, obj);
+ }
+
+ return result;
+ }
+
+#include <float.h>
+
+
+SWIGINTERN int
+SWIG_AsVal_float (octave_value obj, float *val)
+{
+ double v;
+ int res = SWIG_AsVal_double (obj, &v);
+ if (SWIG_IsOK(res)) {
+ if ((v < -FLT_MAX || v > FLT_MAX)) {
+ return SWIG_OverflowError;
+ } else {
+ if (val) *val = (float)(v);
+ }
+ }
+ return res;
+}
+
+
+typedef union {
+ int *count;
+ float *portion;
+ } CvTrainTestSplit_class_part;
+
+
+
+typedef union {
+ int count;
+ float portion;
+ } CvTrainTestSplit_train_sample_part;
+
+
+
+SWIGINTERN int
+SWIG_AsCharArray(octave_value obj, char *val, size_t size)
+{
+ char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
+ int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
+ if (SWIG_IsOK(res)) {
+ if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
+ if (csize <= size) {
+ if (val) {
+ if (csize) memcpy(val, cptr, csize*sizeof(char));
+ if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
+ }
+ if (alloc == SWIG_NEWOBJ) {
+ delete[] cptr;
+ res = SWIG_DelNewMask(res);
+ }
+ return res;
+ }
+ if (alloc == SWIG_NEWOBJ) delete[] cptr;
+ }
+ return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_char (octave_value obj, char *val)
+{
+ int res = SWIG_AsCharArray(obj, val, 1);
+ if (!SWIG_IsOK(res)) {
+ long v;
+ res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
+ if (SWIG_IsOK(res)) {
+ if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
+ if (val) *val = (char)(v);
+ } else {
+ res = SWIG_OverflowError;
+ }
+ }
+ }
+ return res;
+}
+
+
+SWIGINTERNINLINE octave_value
+SWIG_From_char (char c)
+{
+ return SWIG_FromCharPtrAndSize(&c,1);
+}
+
+
+static octave_value_list _wrap_new_CvRNG_Wrapper (const octave_value_list& args, int nargout) {
+ CvRNG *arg1 = 0 ;
+ void *argp1 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvRNG_Wrapper *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvRNG_Wrapper",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1, SWIGTYPE_p_uint64_t, 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvRNG_Wrapper" "', argument " "1"" of type '" "CvRNG const &""'");
+ }
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvRNG_Wrapper" "', argument " "1"" of type '" "CvRNG const &""'");
+ }
+ arg1 = (CvRNG *)(argp1);
+ result = (CvRNG_Wrapper *)new CvRNG_Wrapper((CvRNG const &)*arg1);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRNG_Wrapper, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRNG_Wrapper_ptr (const octave_value_list& args, int nargout) {
+ CvRNG_Wrapper *arg1 = (CvRNG_Wrapper *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvRNG *result = 0 ;
+
+ if (!SWIG_check_num_args("CvRNG_Wrapper_ptr",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRNG_Wrapper, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRNG_Wrapper_ptr" "', argument " "1"" of type '" "CvRNG_Wrapper *""'");
+ }
+ arg1 = (CvRNG_Wrapper *)(argp1);
+ result = (CvRNG *)(arg1)->ptr();
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uint64_t, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRNG_Wrapper_ref (const octave_value_list& args, int nargout) {
+ CvRNG_Wrapper *arg1 = (CvRNG_Wrapper *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvRNG *result = 0 ;
+
+ if (!SWIG_check_num_args("CvRNG_Wrapper_ref",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRNG_Wrapper, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRNG_Wrapper_ref" "', argument " "1"" of type '" "CvRNG_Wrapper *""'");
+ }
+ arg1 = (CvRNG_Wrapper *)(argp1);
+ result = (CvRNG *) &(arg1)->ref();
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uint64_t, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRNG_Wrapper___eq__ (const octave_value_list& args, int nargout) {
+ CvRNG_Wrapper *arg1 = (CvRNG_Wrapper *) 0 ;
+ CvRNG_Wrapper *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvRNG_Wrapper___eq__",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRNG_Wrapper, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRNG_Wrapper___eq__" "', argument " "1"" of type '" "CvRNG_Wrapper *""'");
+ }
+ arg1 = (CvRNG_Wrapper *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvRNG_Wrapper, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRNG_Wrapper___eq__" "', argument " "2"" of type '" "CvRNG_Wrapper const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvRNG_Wrapper___eq__" "', argument " "2"" of type '" "CvRNG_Wrapper const &""'");
+ }
+ arg2 = (CvRNG_Wrapper *)(argp2);
+ result = (bool)(arg1)->operator ==((CvRNG_Wrapper const &)*arg2);
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRNG_Wrapper___ne__ (const octave_value_list& args, int nargout) {
+ CvRNG_Wrapper *arg1 = (CvRNG_Wrapper *) 0 ;
+ CvRNG_Wrapper *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvRNG_Wrapper___ne__",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRNG_Wrapper, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRNG_Wrapper___ne__" "', argument " "1"" of type '" "CvRNG_Wrapper *""'");
+ }
+ arg1 = (CvRNG_Wrapper *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvRNG_Wrapper, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRNG_Wrapper___ne__" "', argument " "2"" of type '" "CvRNG_Wrapper const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvRNG_Wrapper___ne__" "', argument " "2"" of type '" "CvRNG_Wrapper const &""'");
+ }
+ arg2 = (CvRNG_Wrapper *)(argp2);
+ result = (bool)(arg1)->operator !=((CvRNG_Wrapper const &)*arg2);
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvRNG_Wrapper (const octave_value_list& args, int nargout) {
+ CvRNG_Wrapper *arg1 = (CvRNG_Wrapper *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvRNG_Wrapper",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRNG_Wrapper, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvRNG_Wrapper" "', argument " "1"" of type '" "CvRNG_Wrapper *""'");
+ }
+ arg1 = (CvRNG_Wrapper *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvRNG_Wrapper_members[] = {
+{"ptr",_wrap_CvRNG_Wrapper_ptr,0,0,0,0},
+{"ref",_wrap_CvRNG_Wrapper_ref,0,0,0,0},
+{"__eq__",_wrap_CvRNG_Wrapper___eq__,0,0,0,0},
+{"__ne__",_wrap_CvRNG_Wrapper___ne__,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvRNG_Wrapper_base_names[] = {0};
+static const swig_type_info *swig_CvRNG_Wrapper_base[] = {0};
+static swig_octave_class _wrap_class_CvRNG_Wrapper = {"CvRNG_Wrapper", &SWIGTYPE_p_CvRNG_Wrapper,0,_wrap_new_CvRNG_Wrapper,0,_wrap_delete_CvRNG_Wrapper,swig_CvRNG_Wrapper_members,swig_CvRNG_Wrapper_base_names,swig_CvRNG_Wrapper_base };
+
+static octave_value_list _wrap_new_CvSubdiv2DEdge_Wrapper (const octave_value_list& args, int nargout) {
+ CvSubdiv2DEdge *arg1 = 0 ;
+ CvSubdiv2DEdge temp1 ;
+ size_t val1 ;
+ int ecode1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSubdiv2DEdge_Wrapper *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSubdiv2DEdge_Wrapper",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_size_t(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvSubdiv2DEdge_Wrapper" "', argument " "1"" of type '" "CvSubdiv2DEdge""'");
+ }
+ temp1 = (CvSubdiv2DEdge)(val1);
+ arg1 = &temp1;
+ result = (CvSubdiv2DEdge_Wrapper *)new CvSubdiv2DEdge_Wrapper((CvSubdiv2DEdge const &)*arg1);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSubdiv2DEdge_Wrapper_ptr (const octave_value_list& args, int nargout) {
+ CvSubdiv2DEdge_Wrapper *arg1 = (CvSubdiv2DEdge_Wrapper *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSubdiv2DEdge *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSubdiv2DEdge_Wrapper_ptr",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DEdge_Wrapper_ptr" "', argument " "1"" of type '" "CvSubdiv2DEdge_Wrapper *""'");
+ }
+ arg1 = (CvSubdiv2DEdge_Wrapper *)(argp1);
+ result = (CvSubdiv2DEdge *)(arg1)->ptr();
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_size_t, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSubdiv2DEdge_Wrapper_ref (const octave_value_list& args, int nargout) {
+ CvSubdiv2DEdge_Wrapper *arg1 = (CvSubdiv2DEdge_Wrapper *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSubdiv2DEdge *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSubdiv2DEdge_Wrapper_ref",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DEdge_Wrapper_ref" "', argument " "1"" of type '" "CvSubdiv2DEdge_Wrapper *""'");
+ }
+ arg1 = (CvSubdiv2DEdge_Wrapper *)(argp1);
+ result = (CvSubdiv2DEdge *) &(arg1)->ref();
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_size_t, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSubdiv2DEdge_Wrapper___eq__ (const octave_value_list& args, int nargout) {
+ CvSubdiv2DEdge_Wrapper *arg1 = (CvSubdiv2DEdge_Wrapper *) 0 ;
+ CvSubdiv2DEdge_Wrapper *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSubdiv2DEdge_Wrapper___eq__",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DEdge_Wrapper___eq__" "', argument " "1"" of type '" "CvSubdiv2DEdge_Wrapper *""'");
+ }
+ arg1 = (CvSubdiv2DEdge_Wrapper *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2DEdge_Wrapper___eq__" "', argument " "2"" of type '" "CvSubdiv2DEdge_Wrapper const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSubdiv2DEdge_Wrapper___eq__" "', argument " "2"" of type '" "CvSubdiv2DEdge_Wrapper const &""'");
+ }
+ arg2 = (CvSubdiv2DEdge_Wrapper *)(argp2);
+ result = (bool)(arg1)->operator ==((CvSubdiv2DEdge_Wrapper const &)*arg2);
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSubdiv2DEdge_Wrapper___ne__ (const octave_value_list& args, int nargout) {
+ CvSubdiv2DEdge_Wrapper *arg1 = (CvSubdiv2DEdge_Wrapper *) 0 ;
+ CvSubdiv2DEdge_Wrapper *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSubdiv2DEdge_Wrapper___ne__",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DEdge_Wrapper___ne__" "', argument " "1"" of type '" "CvSubdiv2DEdge_Wrapper *""'");
+ }
+ arg1 = (CvSubdiv2DEdge_Wrapper *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2DEdge_Wrapper___ne__" "', argument " "2"" of type '" "CvSubdiv2DEdge_Wrapper const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSubdiv2DEdge_Wrapper___ne__" "', argument " "2"" of type '" "CvSubdiv2DEdge_Wrapper const &""'");
+ }
+ arg2 = (CvSubdiv2DEdge_Wrapper *)(argp2);
+ result = (bool)(arg1)->operator !=((CvSubdiv2DEdge_Wrapper const &)*arg2);
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvSubdiv2DEdge_Wrapper (const octave_value_list& args, int nargout) {
+ CvSubdiv2DEdge_Wrapper *arg1 = (CvSubdiv2DEdge_Wrapper *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvSubdiv2DEdge_Wrapper",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSubdiv2DEdge_Wrapper" "', argument " "1"" of type '" "CvSubdiv2DEdge_Wrapper *""'");
+ }
+ arg1 = (CvSubdiv2DEdge_Wrapper *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvSubdiv2DEdge_Wrapper_members[] = {
+{"ptr",_wrap_CvSubdiv2DEdge_Wrapper_ptr,0,0,0,0},
+{"ref",_wrap_CvSubdiv2DEdge_Wrapper_ref,0,0,0,0},
+{"__eq__",_wrap_CvSubdiv2DEdge_Wrapper___eq__,0,0,0,0},
+{"__ne__",_wrap_CvSubdiv2DEdge_Wrapper___ne__,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvSubdiv2DEdge_Wrapper_base_names[] = {0};
+static const swig_type_info *swig_CvSubdiv2DEdge_Wrapper_base[] = {0};
+static swig_octave_class _wrap_class_CvSubdiv2DEdge_Wrapper = {"CvSubdiv2DEdge_Wrapper", &SWIGTYPE_p_CvSubdiv2DEdge_Wrapper,0,_wrap_new_CvSubdiv2DEdge_Wrapper,0,_wrap_delete_CvSubdiv2DEdge_Wrapper,swig_CvSubdiv2DEdge_Wrapper_members,swig_CvSubdiv2DEdge_Wrapper_base_names,swig_CvSubdiv2DEdge_Wrapper_base };
+
+static octave_value_list _wrap_CvVectors_type_set (const octave_value_list& args, int nargout) {
+ CvVectors *arg1 = (CvVectors *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvVectors_type_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_type_set" "', argument " "1"" of type '" "CvVectors *""'");
+ }
+ arg1 = (CvVectors *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvVectors_type_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->type = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvVectors_type_get (const octave_value_list& args, int nargout) {
+ CvVectors *arg1 = (CvVectors *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvVectors_type_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_type_get" "', argument " "1"" of type '" "CvVectors *""'");
+ }
+ arg1 = (CvVectors *)(argp1);
+ result = (int) ((arg1)->type);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvVectors_dims_set (const octave_value_list& args, int nargout) {
+ CvVectors *arg1 = (CvVectors *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvVectors_dims_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_dims_set" "', argument " "1"" of type '" "CvVectors *""'");
+ }
+ arg1 = (CvVectors *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvVectors_dims_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->dims = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvVectors_dims_get (const octave_value_list& args, int nargout) {
+ CvVectors *arg1 = (CvVectors *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvVectors_dims_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_dims_get" "', argument " "1"" of type '" "CvVectors *""'");
+ }
+ arg1 = (CvVectors *)(argp1);
+ result = (int) ((arg1)->dims);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvVectors_count_set (const octave_value_list& args, int nargout) {
+ CvVectors *arg1 = (CvVectors *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvVectors_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_count_set" "', argument " "1"" of type '" "CvVectors *""'");
+ }
+ arg1 = (CvVectors *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvVectors_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvVectors_count_get (const octave_value_list& args, int nargout) {
+ CvVectors *arg1 = (CvVectors *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvVectors_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_count_get" "', argument " "1"" of type '" "CvVectors *""'");
+ }
+ arg1 = (CvVectors *)(argp1);
+ result = (int) ((arg1)->count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvVectors_next_set (const octave_value_list& args, int nargout) {
+ CvVectors *arg1 = (CvVectors *) 0 ;
+ CvVectors *arg2 = (CvVectors *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvVectors_next_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_next_set" "', argument " "1"" of type '" "CvVectors *""'");
+ }
+ arg1 = (CvVectors *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvVectors, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvVectors_next_set" "', argument " "2"" of type '" "CvVectors *""'");
+ }
+ arg2 = (CvVectors *)(argp2);
+ if (arg1) (arg1)->next = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvVectors_next_get (const octave_value_list& args, int nargout) {
+ CvVectors *arg1 = (CvVectors *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvVectors *result = 0 ;
+
+ if (!SWIG_check_num_args("CvVectors_next_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_next_get" "', argument " "1"" of type '" "CvVectors *""'");
+ }
+ arg1 = (CvVectors *)(argp1);
+ result = (CvVectors *) ((arg1)->next);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvVectors, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvVectors_data_get (const octave_value_list& args, int nargout) {
+ CvVectors *arg1 = (CvVectors *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvVectors_data *result = 0 ;
+
+ if (!SWIG_check_num_args("CvVectors_data_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_data_get" "', argument " "1"" of type '" "CvVectors *""'");
+ }
+ arg1 = (CvVectors *)(argp1);
+ result = (CvVectors_data *)& ((arg1)->data);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvVectors_data, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvVectors (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvVectors *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvVectors",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvVectors *)new CvVectors();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvVectors, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvVectors (const octave_value_list& args, int nargout) {
+ CvVectors *arg1 = (CvVectors *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvVectors",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvVectors" "', argument " "1"" of type '" "CvVectors *""'");
+ }
+ arg1 = (CvVectors *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvVectors_members[] = {
+{"type",0,_wrap_CvVectors_type_get,_wrap_CvVectors_type_set,0,0},
+{"dims",0,_wrap_CvVectors_dims_get,_wrap_CvVectors_dims_set,0,0},
+{"count",0,_wrap_CvVectors_count_get,_wrap_CvVectors_count_set,0,0},
+{"next",0,_wrap_CvVectors_next_get,_wrap_CvVectors_next_set,0,0},
+{"data",0,_wrap_CvVectors_data_get,octave_set_immutable,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvVectors_base_names[] = {0};
+static const swig_type_info *swig_CvVectors_base[] = {0};
+static swig_octave_class _wrap_class_CvVectors = {"CvVectors", &SWIGTYPE_p_CvVectors,0,_wrap_new_CvVectors,0,_wrap_delete_CvVectors,swig_CvVectors_members,swig_CvVectors_base_names,swig_CvVectors_base };
+
+static octave_value_list _wrap_CvVectors_data_ptr_set (const octave_value_list& args, int nargout) {
+ CvVectors_data *arg1 = (CvVectors_data *) 0 ;
+ uchar **arg2 = (uchar **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvVectors_data_ptr_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors_data, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_data_ptr_set" "', argument " "1"" of type '" "CvVectors_data *""'");
+ }
+ arg1 = (CvVectors_data *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvVectors_data_ptr_set" "', argument " "2"" of type '" "uchar **""'");
+ }
+ arg2 = (uchar **)(argp2);
+ if (arg1) (arg1)->ptr = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvVectors_data_ptr_get (const octave_value_list& args, int nargout) {
+ CvVectors_data *arg1 = (CvVectors_data *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ uchar **result = 0 ;
+
+ if (!SWIG_check_num_args("CvVectors_data_ptr_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors_data, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_data_ptr_get" "', argument " "1"" of type '" "CvVectors_data *""'");
+ }
+ arg1 = (CvVectors_data *)(argp1);
+ result = (uchar **) ((arg1)->ptr);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_unsigned_char, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvVectors_data_fl_set (const octave_value_list& args, int nargout) {
+ CvVectors_data *arg1 = (CvVectors_data *) 0 ;
+ float **arg2 = (float **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *vptr2 ;
+ float *buffer2 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvVectors_data_fl_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors_data, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_data_fl_set" "', argument " "1"" of type '" "CvVectors_data *""'");
+ }
+ arg1 = (CvVectors_data *)(argp1);
+ {
+ if ((SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer2 = (float *) vptr2;
+ arg2=&buffer2;
+ }
+ if (arg1) (arg1)->fl = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvVectors_data_fl_get (const octave_value_list& args, int nargout) {
+ CvVectors_data *arg1 = (CvVectors_data *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float **result = 0 ;
+
+ if (!SWIG_check_num_args("CvVectors_data_fl_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors_data, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_data_fl_get" "', argument " "1"" of type '" "CvVectors_data *""'");
+ }
+ arg1 = (CvVectors_data *)(argp1);
+ result = (float **) ((arg1)->fl);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvVectors_data_db_set (const octave_value_list& args, int nargout) {
+ CvVectors_data *arg1 = (CvVectors_data *) 0 ;
+ double **arg2 = (double **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvVectors_data_db_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors_data, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_data_db_set" "', argument " "1"" of type '" "CvVectors_data *""'");
+ }
+ arg1 = (CvVectors_data *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvVectors_data_db_set" "', argument " "2"" of type '" "double **""'");
+ }
+ arg2 = (double **)(argp2);
+ if (arg1) (arg1)->db = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvVectors_data_db_get (const octave_value_list& args, int nargout) {
+ CvVectors_data *arg1 = (CvVectors_data *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double **result = 0 ;
+
+ if (!SWIG_check_num_args("CvVectors_data_db_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors_data, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvVectors_data_db_get" "', argument " "1"" of type '" "CvVectors_data *""'");
+ }
+ arg1 = (CvVectors_data *)(argp1);
+ result = (double **) ((arg1)->db);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_double, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvVectors_data (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvVectors_data *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvVectors_data",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvVectors_data *)new CvVectors_data();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvVectors_data, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvVectors_data (const octave_value_list& args, int nargout) {
+ CvVectors_data *arg1 = (CvVectors_data *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvVectors_data",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvVectors_data, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvVectors_data" "', argument " "1"" of type '" "CvVectors_data *""'");
+ }
+ arg1 = (CvVectors_data *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvVectors_data_members[] = {
+{"ptr",0,_wrap_CvVectors_data_ptr_get,_wrap_CvVectors_data_ptr_set,0,0},
+{"fl",0,_wrap_CvVectors_data_fl_get,_wrap_CvVectors_data_fl_set,0,0},
+{"db",0,_wrap_CvVectors_data_db_get,_wrap_CvVectors_data_db_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvVectors_data_base_names[] = {0};
+static const swig_type_info *swig_CvVectors_data_base[] = {0};
+static swig_octave_class _wrap_class_CvVectors_data = {"CvVectors_data", &SWIGTYPE_p_CvVectors_data,0,_wrap_new_CvVectors_data,0,_wrap_delete_CvVectors_data,swig_CvVectors_data_members,swig_CvVectors_data_base_names,swig_CvVectors_data_base };
+
+static octave_value_list _wrap_new_CvStatModel (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvStatModel *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvStatModel",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvStatModel *)new CvStatModel();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStatModel, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvStatModel (const octave_value_list& args, int nargout) {
+ CvStatModel *arg1 = (CvStatModel *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvStatModel",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStatModel, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvStatModel" "', argument " "1"" of type '" "CvStatModel *""'");
+ }
+ arg1 = (CvStatModel *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvStatModel_clear (const octave_value_list& args, int nargout) {
+ CvStatModel *arg1 = (CvStatModel *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvStatModel_clear",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStatModel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStatModel_clear" "', argument " "1"" of type '" "CvStatModel *""'");
+ }
+ arg1 = (CvStatModel *)(argp1);
+ {
+ try {
+ (arg1)->clear();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvStatModel_save__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvStatModel *arg1 = (CvStatModel *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvStatModel_save",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStatModel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStatModel_save" "', argument " "1"" of type '" "CvStatModel const *""'");
+ }
+ arg1 = (CvStatModel *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStatModel_save" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvStatModel_save" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ {
+ try {
+ ((CvStatModel const *)arg1)->save((char const *)arg2,(char const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvStatModel_save__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvStatModel *arg1 = (CvStatModel *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvStatModel_save",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStatModel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStatModel_save" "', argument " "1"" of type '" "CvStatModel const *""'");
+ }
+ arg1 = (CvStatModel *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStatModel_save" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ {
+ try {
+ ((CvStatModel const *)arg1)->save((char const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvStatModel_save (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[3]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvStatModel, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvStatModel_save__SWIG_1(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvStatModel, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvStatModel_save__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvStatModel_load__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvStatModel *arg1 = (CvStatModel *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvStatModel_load",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStatModel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStatModel_load" "', argument " "1"" of type '" "CvStatModel *""'");
+ }
+ arg1 = (CvStatModel *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStatModel_load" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvStatModel_load" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ {
+ try {
+ (arg1)->load((char const *)arg2,(char const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvStatModel_load__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvStatModel *arg1 = (CvStatModel *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvStatModel_load",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStatModel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStatModel_load" "', argument " "1"" of type '" "CvStatModel *""'");
+ }
+ arg1 = (CvStatModel *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStatModel_load" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ {
+ try {
+ (arg1)->load((char const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvStatModel_load (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[3]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvStatModel, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvStatModel_load__SWIG_1(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvStatModel, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvStatModel_load__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvStatModel_write (const octave_value_list& args, int nargout) {
+ CvStatModel *arg1 = (CvStatModel *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ char *arg3 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvStatModel_write",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStatModel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStatModel_write" "', argument " "1"" of type '" "CvStatModel const *""'");
+ }
+ arg1 = (CvStatModel *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStatModel_write" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvStatModel_write" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ {
+ try {
+ ((CvStatModel const *)arg1)->write(arg2,(char const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvStatModel_read (const octave_value_list& args, int nargout) {
+ CvStatModel *arg1 = (CvStatModel *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvStatModel_read",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStatModel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStatModel_read" "', argument " "1"" of type '" "CvStatModel *""'");
+ }
+ arg1 = (CvStatModel *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStatModel_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvStatModel_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ {
+ try {
+ (arg1)->read(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvStatModel_members[] = {
+{"clear",_wrap_CvStatModel_clear,0,0,0,0},
+{"save",_wrap_CvStatModel_save,0,0,0,0},
+{"load",_wrap_CvStatModel_load,0,0,0,0},
+{"write",_wrap_CvStatModel_write,0,0,0,0},
+{"read",_wrap_CvStatModel_read,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvStatModel_base_names[] = {0};
+static const swig_type_info *swig_CvStatModel_base[] = {0};
+static swig_octave_class _wrap_class_CvStatModel = {"CvStatModel", &SWIGTYPE_p_CvStatModel,0,_wrap_new_CvStatModel,0,_wrap_delete_CvStatModel,swig_CvStatModel_members,swig_CvStatModel_base_names,swig_CvStatModel_base };
+
+static octave_value_list _wrap_new_CvParamGrid__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvParamGrid *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvParamGrid",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvParamGrid *)new CvParamGrid();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvParamGrid, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvParamGrid__SWIG_1 (const octave_value_list& args, int nargout) {
+ double arg1 ;
+ double arg2 ;
+ double arg3 ;
+ double val1 ;
+ int ecode1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvParamGrid *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvParamGrid",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_double(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvParamGrid" "', argument " "1"" of type '" "double""'");
+ }
+ arg1 = (double)(val1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvParamGrid" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ ecode3 = SWIG_AsVal_double(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvParamGrid" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ {
+ try {
+ result = (CvParamGrid *)new CvParamGrid(arg1,arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvParamGrid, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvParamGrid (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[3]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvParamGrid__SWIG_0(args, nargout);
+ }
+ if (argc == 3) {
+ int _v;
+ {
+ int res = SWIG_AsVal_double(argv[0], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvParamGrid__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvParamGrid_check (const octave_value_list& args, int nargout) {
+ CvParamGrid *arg1 = (CvParamGrid *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvParamGrid_check",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvParamGrid, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvParamGrid_check" "', argument " "1"" of type '" "CvParamGrid const *""'");
+ }
+ arg1 = (CvParamGrid *)(argp1);
+ {
+ try {
+ result = (bool)((CvParamGrid const *)arg1)->check();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvParamGrid_min_val_set (const octave_value_list& args, int nargout) {
+ CvParamGrid *arg1 = (CvParamGrid *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvParamGrid_min_val_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvParamGrid, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvParamGrid_min_val_set" "', argument " "1"" of type '" "CvParamGrid *""'");
+ }
+ arg1 = (CvParamGrid *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvParamGrid_min_val_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->min_val = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvParamGrid_min_val_get (const octave_value_list& args, int nargout) {
+ CvParamGrid *arg1 = (CvParamGrid *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvParamGrid_min_val_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvParamGrid, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvParamGrid_min_val_get" "', argument " "1"" of type '" "CvParamGrid *""'");
+ }
+ arg1 = (CvParamGrid *)(argp1);
+ result = (double) ((arg1)->min_val);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvParamGrid_max_val_set (const octave_value_list& args, int nargout) {
+ CvParamGrid *arg1 = (CvParamGrid *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvParamGrid_max_val_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvParamGrid, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvParamGrid_max_val_set" "', argument " "1"" of type '" "CvParamGrid *""'");
+ }
+ arg1 = (CvParamGrid *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvParamGrid_max_val_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->max_val = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvParamGrid_max_val_get (const octave_value_list& args, int nargout) {
+ CvParamGrid *arg1 = (CvParamGrid *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvParamGrid_max_val_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvParamGrid, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvParamGrid_max_val_get" "', argument " "1"" of type '" "CvParamGrid *""'");
+ }
+ arg1 = (CvParamGrid *)(argp1);
+ result = (double) ((arg1)->max_val);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvParamGrid_step_set (const octave_value_list& args, int nargout) {
+ CvParamGrid *arg1 = (CvParamGrid *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvParamGrid_step_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvParamGrid, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvParamGrid_step_set" "', argument " "1"" of type '" "CvParamGrid *""'");
+ }
+ arg1 = (CvParamGrid *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvParamGrid_step_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->step = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvParamGrid_step_get (const octave_value_list& args, int nargout) {
+ CvParamGrid *arg1 = (CvParamGrid *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvParamGrid_step_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvParamGrid, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvParamGrid_step_get" "', argument " "1"" of type '" "CvParamGrid *""'");
+ }
+ arg1 = (CvParamGrid *)(argp1);
+ result = (double) ((arg1)->step);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvParamGrid (const octave_value_list& args, int nargout) {
+ CvParamGrid *arg1 = (CvParamGrid *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvParamGrid",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvParamGrid, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvParamGrid" "', argument " "1"" of type '" "CvParamGrid *""'");
+ }
+ arg1 = (CvParamGrid *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvParamGrid_members[] = {
+{"check",_wrap_CvParamGrid_check,0,0,0,0},
+{"min_val",0,_wrap_CvParamGrid_min_val_get,_wrap_CvParamGrid_min_val_set,0,0},
+{"max_val",0,_wrap_CvParamGrid_max_val_get,_wrap_CvParamGrid_max_val_set,0,0},
+{"step",0,_wrap_CvParamGrid_step_get,_wrap_CvParamGrid_step_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvParamGrid_base_names[] = {0};
+static const swig_type_info *swig_CvParamGrid_base[] = {0};
+static swig_octave_class _wrap_class_CvParamGrid = {"CvParamGrid", &SWIGTYPE_p_CvParamGrid,0,_wrap_new_CvParamGrid,0,_wrap_delete_CvParamGrid,swig_CvParamGrid_members,swig_CvParamGrid_base_names,swig_CvParamGrid_base };
+
+static octave_value_list _wrap_new_CvNormalBayesClassifier__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvNormalBayesClassifier *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvNormalBayesClassifier",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvNormalBayesClassifier *)new CvNormalBayesClassifier();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvNormalBayesClassifier, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvNormalBayesClassifier (const octave_value_list& args, int nargout) {
+ CvNormalBayesClassifier *arg1 = (CvNormalBayesClassifier *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvNormalBayesClassifier",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNormalBayesClassifier, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvNormalBayesClassifier" "', argument " "1"" of type '" "CvNormalBayesClassifier *""'");
+ }
+ arg1 = (CvNormalBayesClassifier *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvNormalBayesClassifier__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvNormalBayesClassifier *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvNormalBayesClassifier",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvNormalBayesClassifier" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvNormalBayesClassifier" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvNormalBayesClassifier" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvNormalBayesClassifier" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (CvNormalBayesClassifier *)new CvNormalBayesClassifier((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvNormalBayesClassifier, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvNormalBayesClassifier__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvNormalBayesClassifier *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvNormalBayesClassifier",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvNormalBayesClassifier" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvNormalBayesClassifier" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvNormalBayesClassifier" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (CvNormalBayesClassifier *)new CvNormalBayesClassifier((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvNormalBayesClassifier, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvNormalBayesClassifier__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvNormalBayesClassifier *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvNormalBayesClassifier",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvNormalBayesClassifier" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvNormalBayesClassifier" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ result = (CvNormalBayesClassifier *)new CvNormalBayesClassifier((CvMat const *)arg1,(CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvNormalBayesClassifier, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvNormalBayesClassifier (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[4]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvNormalBayesClassifier__SWIG_0(args, nargout);
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvNormalBayesClassifier__SWIG_3(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvNormalBayesClassifier__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvNormalBayesClassifier__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvNormalBayesClassifier_train__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvNormalBayesClassifier *arg1 = (CvNormalBayesClassifier *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ bool arg6 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ bool val6 ;
+ int ecode6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvNormalBayesClassifier_train",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNormalBayesClassifier, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNormalBayesClassifier_train" "', argument " "1"" of type '" "CvNormalBayesClassifier *""'");
+ }
+ arg1 = (CvNormalBayesClassifier *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNormalBayesClassifier_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvNormalBayesClassifier_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvNormalBayesClassifier_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvNormalBayesClassifier_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ ecode6 = SWIG_AsVal_bool(args(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvNormalBayesClassifier_train" "', argument " "6"" of type '" "bool""'");
+ }
+ arg6 = (bool)(val6);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvNormalBayesClassifier_train__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvNormalBayesClassifier *arg1 = (CvNormalBayesClassifier *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvNormalBayesClassifier_train",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNormalBayesClassifier, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNormalBayesClassifier_train" "', argument " "1"" of type '" "CvNormalBayesClassifier *""'");
+ }
+ arg1 = (CvNormalBayesClassifier *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNormalBayesClassifier_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvNormalBayesClassifier_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvNormalBayesClassifier_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvNormalBayesClassifier_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvNormalBayesClassifier_train__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvNormalBayesClassifier *arg1 = (CvNormalBayesClassifier *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvNormalBayesClassifier_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNormalBayesClassifier, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNormalBayesClassifier_train" "', argument " "1"" of type '" "CvNormalBayesClassifier *""'");
+ }
+ arg1 = (CvNormalBayesClassifier *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNormalBayesClassifier_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvNormalBayesClassifier_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvNormalBayesClassifier_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvNormalBayesClassifier_train__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvNormalBayesClassifier *arg1 = (CvNormalBayesClassifier *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvNormalBayesClassifier_train",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNormalBayesClassifier, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNormalBayesClassifier_train" "', argument " "1"" of type '" "CvNormalBayesClassifier *""'");
+ }
+ arg1 = (CvNormalBayesClassifier *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNormalBayesClassifier_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvNormalBayesClassifier_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvNormalBayesClassifier_train (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[6]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5)
+ };
+
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvNormalBayesClassifier, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvNormalBayesClassifier_train__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvNormalBayesClassifier, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvNormalBayesClassifier_train__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvNormalBayesClassifier, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvNormalBayesClassifier_train__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvNormalBayesClassifier, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[5], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvNormalBayesClassifier_train__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvNormalBayesClassifier_predict__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvNormalBayesClassifier *arg1 = (CvNormalBayesClassifier *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvNormalBayesClassifier_predict",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNormalBayesClassifier, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNormalBayesClassifier_predict" "', argument " "1"" of type '" "CvNormalBayesClassifier const *""'");
+ }
+ arg1 = (CvNormalBayesClassifier *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNormalBayesClassifier_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvNormalBayesClassifier_predict" "', argument " "3"" of type '" "CvMat *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (float)((CvNormalBayesClassifier const *)arg1)->predict((CvMat const *)arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvNormalBayesClassifier_predict__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvNormalBayesClassifier *arg1 = (CvNormalBayesClassifier *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvNormalBayesClassifier_predict",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNormalBayesClassifier, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNormalBayesClassifier_predict" "', argument " "1"" of type '" "CvNormalBayesClassifier const *""'");
+ }
+ arg1 = (CvNormalBayesClassifier *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNormalBayesClassifier_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ result = (float)((CvNormalBayesClassifier const *)arg1)->predict((CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvNormalBayesClassifier_predict (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[3]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvNormalBayesClassifier, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvNormalBayesClassifier_predict__SWIG_1(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvNormalBayesClassifier, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvNormalBayesClassifier_predict__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvNormalBayesClassifier_clear (const octave_value_list& args, int nargout) {
+ CvNormalBayesClassifier *arg1 = (CvNormalBayesClassifier *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvNormalBayesClassifier_clear",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNormalBayesClassifier, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNormalBayesClassifier_clear" "', argument " "1"" of type '" "CvNormalBayesClassifier *""'");
+ }
+ arg1 = (CvNormalBayesClassifier *)(argp1);
+ {
+ try {
+ (arg1)->clear();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvNormalBayesClassifier_write (const octave_value_list& args, int nargout) {
+ CvNormalBayesClassifier *arg1 = (CvNormalBayesClassifier *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ char *arg3 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvNormalBayesClassifier_write",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNormalBayesClassifier, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNormalBayesClassifier_write" "', argument " "1"" of type '" "CvNormalBayesClassifier const *""'");
+ }
+ arg1 = (CvNormalBayesClassifier *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNormalBayesClassifier_write" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvNormalBayesClassifier_write" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ {
+ try {
+ ((CvNormalBayesClassifier const *)arg1)->write(arg2,(char const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvNormalBayesClassifier_read (const octave_value_list& args, int nargout) {
+ CvNormalBayesClassifier *arg1 = (CvNormalBayesClassifier *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvNormalBayesClassifier_read",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNormalBayesClassifier, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNormalBayesClassifier_read" "', argument " "1"" of type '" "CvNormalBayesClassifier *""'");
+ }
+ arg1 = (CvNormalBayesClassifier *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNormalBayesClassifier_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvNormalBayesClassifier_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ {
+ try {
+ (arg1)->read(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvNormalBayesClassifier_members[] = {
+{"train",_wrap_CvNormalBayesClassifier_train,0,0,0,0},
+{"predict",_wrap_CvNormalBayesClassifier_predict,0,0,0,0},
+{"clear",_wrap_CvNormalBayesClassifier_clear,0,0,0,0},
+{"write",_wrap_CvNormalBayesClassifier_write,0,0,0,0},
+{"read",_wrap_CvNormalBayesClassifier_read,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvNormalBayesClassifier_base_names[] = {"_p_CvStatModel",0};
+static const swig_type_info *swig_CvNormalBayesClassifier_base[] = {0,0};
+static swig_octave_class _wrap_class_CvNormalBayesClassifier = {"CvNormalBayesClassifier", &SWIGTYPE_p_CvNormalBayesClassifier,0,_wrap_new_CvNormalBayesClassifier,0,_wrap_delete_CvNormalBayesClassifier,swig_CvNormalBayesClassifier_members,swig_CvNormalBayesClassifier_base_names,swig_CvNormalBayesClassifier_base };
+
+static octave_value_list _wrap_new_CvKNearest__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvKNearest *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvKNearest",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvKNearest *)new CvKNearest();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvKNearest, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvKNearest (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvKNearest",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvKNearest" "', argument " "1"" of type '" "CvKNearest *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvKNearest__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ bool arg4 ;
+ int arg5 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ bool val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvKNearest *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvKNearest",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvKNearest" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvKNearest" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvKNearest" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ ecode4 = SWIG_AsVal_bool(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvKNearest" "', argument " "4"" of type '" "bool""'");
+ }
+ arg4 = (bool)(val4);
+ ecode5 = SWIG_AsVal_int(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CvKNearest" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ {
+ try {
+ result = (CvKNearest *)new CvKNearest((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvKNearest, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvKNearest__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ bool arg4 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ bool val4 ;
+ int ecode4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvKNearest *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvKNearest",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvKNearest" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvKNearest" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvKNearest" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ ecode4 = SWIG_AsVal_bool(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvKNearest" "', argument " "4"" of type '" "bool""'");
+ }
+ arg4 = (bool)(val4);
+ {
+ try {
+ result = (CvKNearest *)new CvKNearest((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvKNearest, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvKNearest__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvKNearest *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvKNearest",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvKNearest" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvKNearest" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvKNearest" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (CvKNearest *)new CvKNearest((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvKNearest, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvKNearest__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvKNearest *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvKNearest",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvKNearest" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvKNearest" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ result = (CvKNearest *)new CvKNearest((CvMat const *)arg1,(CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvKNearest, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvKNearest (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[5]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvKNearest__SWIG_0(args, nargout);
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvKNearest__SWIG_4(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvKNearest__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[3], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvKNearest__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 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_new_CvKNearest__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvKNearest_train__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ bool arg5 ;
+ int arg6 ;
+ bool arg7 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ bool val5 ;
+ int ecode5 = 0 ;
+ int val6 ;
+ int ecode6 = 0 ;
+ bool val7 ;
+ int ecode7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvKNearest_train",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_train" "', argument " "1"" of type '" "CvKNearest *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKNearest_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvKNearest_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvKNearest_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ ecode5 = SWIG_AsVal_bool(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvKNearest_train" "', argument " "5"" of type '" "bool""'");
+ }
+ arg5 = (bool)(val5);
+ ecode6 = SWIG_AsVal_int(args(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvKNearest_train" "', argument " "6"" of type '" "int""'");
+ }
+ arg6 = (int)(val6);
+ ecode7 = SWIG_AsVal_bool(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvKNearest_train" "', argument " "7"" of type '" "bool""'");
+ }
+ arg7 = (bool)(val7);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,arg5,arg6,arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_train__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ bool arg5 ;
+ int arg6 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ bool val5 ;
+ int ecode5 = 0 ;
+ int val6 ;
+ int ecode6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvKNearest_train",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_train" "', argument " "1"" of type '" "CvKNearest *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKNearest_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvKNearest_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvKNearest_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ ecode5 = SWIG_AsVal_bool(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvKNearest_train" "', argument " "5"" of type '" "bool""'");
+ }
+ arg5 = (bool)(val5);
+ ecode6 = SWIG_AsVal_int(args(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvKNearest_train" "', argument " "6"" of type '" "int""'");
+ }
+ arg6 = (int)(val6);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_train__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ bool arg5 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ bool val5 ;
+ int ecode5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvKNearest_train",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_train" "', argument " "1"" of type '" "CvKNearest *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKNearest_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvKNearest_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvKNearest_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ ecode5 = SWIG_AsVal_bool(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvKNearest_train" "', argument " "5"" of type '" "bool""'");
+ }
+ arg5 = (bool)(val5);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_train__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvKNearest_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_train" "', argument " "1"" of type '" "CvKNearest *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKNearest_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvKNearest_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvKNearest_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_train__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvKNearest_train",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_train" "', argument " "1"" of type '" "CvKNearest *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKNearest_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvKNearest_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_train (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[7]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6)
+ };
+
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvKNearest, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvKNearest_train__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvKNearest, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvKNearest_train__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvKNearest, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[4], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvKNearest_train__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvKNearest, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[4], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[5], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvKNearest_train__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvKNearest, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[4], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(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_CvKNearest_train__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvKNearest_find_nearest__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ float **arg5 = (float **) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *vptr5 ;
+ float *buffer5 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvKNearest_find_nearest",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_find_nearest" "', argument " "1"" of type '" "CvKNearest const *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKNearest_find_nearest" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvKNearest_find_nearest" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvKNearest_find_nearest" "', argument " "4"" of type '" "CvMat *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ if ((SWIG_ConvertPtr(args(4), &vptr5, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer5 = (float *) vptr5;
+ arg5=&buffer5;
+ }
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvKNearest_find_nearest" "', argument " "6"" of type '" "CvMat *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvKNearest_find_nearest" "', argument " "7"" of type '" "CvMat *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ {
+ try {
+ result = (float)((CvKNearest const *)arg1)->find_nearest((CvMat const *)arg2,arg3,arg4,(float const **)arg5,arg6,arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_find_nearest__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ float **arg5 = (float **) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *vptr5 ;
+ float *buffer5 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvKNearest_find_nearest",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_find_nearest" "', argument " "1"" of type '" "CvKNearest const *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKNearest_find_nearest" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvKNearest_find_nearest" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvKNearest_find_nearest" "', argument " "4"" of type '" "CvMat *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ if ((SWIG_ConvertPtr(args(4), &vptr5, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer5 = (float *) vptr5;
+ arg5=&buffer5;
+ }
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvKNearest_find_nearest" "', argument " "6"" of type '" "CvMat *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ {
+ try {
+ result = (float)((CvKNearest const *)arg1)->find_nearest((CvMat const *)arg2,arg3,arg4,(float const **)arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_find_nearest__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ float **arg5 = (float **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *vptr5 ;
+ float *buffer5 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvKNearest_find_nearest",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_find_nearest" "', argument " "1"" of type '" "CvKNearest const *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKNearest_find_nearest" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvKNearest_find_nearest" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvKNearest_find_nearest" "', argument " "4"" of type '" "CvMat *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ if ((SWIG_ConvertPtr(args(4), &vptr5, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer5 = (float *) vptr5;
+ arg5=&buffer5;
+ }
+ {
+ try {
+ result = (float)((CvKNearest const *)arg1)->find_nearest((CvMat const *)arg2,arg3,arg4,(float const **)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_find_nearest__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvKNearest_find_nearest",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_find_nearest" "', argument " "1"" of type '" "CvKNearest const *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKNearest_find_nearest" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvKNearest_find_nearest" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvKNearest_find_nearest" "', argument " "4"" of type '" "CvMat *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (float)((CvKNearest const *)arg1)->find_nearest((CvMat const *)arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_find_nearest__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvKNearest_find_nearest",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_find_nearest" "', argument " "1"" of type '" "CvKNearest const *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvKNearest_find_nearest" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvKNearest_find_nearest" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ try {
+ result = (float)((CvKNearest const *)arg1)->find_nearest((CvMat const *)arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_find_nearest (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[7]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6)
+ };
+
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvKNearest, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvKNearest_find_nearest__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvKNearest, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvKNearest_find_nearest__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvKNearest, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvKNearest_find_nearest__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvKNearest, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvKNearest_find_nearest__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvKNearest, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvKNearest_find_nearest__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvKNearest_clear (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvKNearest_clear",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_clear" "', argument " "1"" of type '" "CvKNearest *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ {
+ try {
+ (arg1)->clear();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_get_max_k (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvKNearest_get_max_k",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_get_max_k" "', argument " "1"" of type '" "CvKNearest const *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ {
+ try {
+ result = (int)((CvKNearest const *)arg1)->get_max_k();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_get_var_count (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvKNearest_get_var_count",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_get_var_count" "', argument " "1"" of type '" "CvKNearest const *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ {
+ try {
+ result = (int)((CvKNearest const *)arg1)->get_var_count();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_get_sample_count (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvKNearest_get_sample_count",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_get_sample_count" "', argument " "1"" of type '" "CvKNearest const *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ {
+ try {
+ result = (int)((CvKNearest const *)arg1)->get_sample_count();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvKNearest_is_regression (const octave_value_list& args, int nargout) {
+ CvKNearest *arg1 = (CvKNearest *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvKNearest_is_regression",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKNearest, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKNearest_is_regression" "', argument " "1"" of type '" "CvKNearest const *""'");
+ }
+ arg1 = (CvKNearest *)(argp1);
+ {
+ try {
+ result = (bool)((CvKNearest const *)arg1)->is_regression();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvKNearest_members[] = {
+{"train",_wrap_CvKNearest_train,0,0,0,0},
+{"find_nearest",_wrap_CvKNearest_find_nearest,0,0,0,0},
+{"clear",_wrap_CvKNearest_clear,0,0,0,0},
+{"get_max_k",_wrap_CvKNearest_get_max_k,0,0,0,0},
+{"get_var_count",_wrap_CvKNearest_get_var_count,0,0,0,0},
+{"get_sample_count",_wrap_CvKNearest_get_sample_count,0,0,0,0},
+{"is_regression",_wrap_CvKNearest_is_regression,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvKNearest_base_names[] = {"_p_CvStatModel",0};
+static const swig_type_info *swig_CvKNearest_base[] = {0,0};
+static swig_octave_class _wrap_class_CvKNearest = {"CvKNearest", &SWIGTYPE_p_CvKNearest,0,_wrap_new_CvKNearest,0,_wrap_delete_CvKNearest,swig_CvKNearest_members,swig_CvKNearest_base_names,swig_CvKNearest_base };
+
+static octave_value_list _wrap_new_CvSVMParams__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVMParams",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvSVMParams *)new CvSVMParams();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVMParams__SWIG_1 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int arg2 ;
+ double arg3 ;
+ double arg4 ;
+ double arg5 ;
+ double arg6 ;
+ double arg7 ;
+ double arg8 ;
+ CvMat *arg9 = (CvMat *) 0 ;
+ CvTermCriteria arg10 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ double val5 ;
+ int ecode5 = 0 ;
+ double val6 ;
+ int ecode6 = 0 ;
+ double val7 ;
+ int ecode7 = 0 ;
+ double val8 ;
+ int ecode8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ void *argp10 ;
+ int res10 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVMParams",args.length(),10,10,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvSVMParams" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvSVMParams" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvSVMParams" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ ecode4 = SWIG_AsVal_double(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvSVMParams" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = (double)(val4);
+ ecode5 = SWIG_AsVal_double(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CvSVMParams" "', argument " "5"" of type '" "double""'");
+ }
+ arg5 = (double)(val5);
+ ecode6 = SWIG_AsVal_double(args(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CvSVMParams" "', argument " "6"" of type '" "double""'");
+ }
+ arg6 = (double)(val6);
+ ecode7 = SWIG_AsVal_double(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CvSVMParams" "', argument " "7"" of type '" "double""'");
+ }
+ arg7 = (double)(val7);
+ ecode8 = SWIG_AsVal_double(args(7), &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CvSVMParams" "', argument " "8"" of type '" "double""'");
+ }
+ arg8 = (double)(val8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CvSVMParams" "', argument " "9"" of type '" "CvMat *""'");
+ }
+ arg9 = (CvMat *)(argp9);
+ {
+ res10 = SWIG_ConvertPtr(args(9), &argp10, SWIGTYPE_p_CvTermCriteria, 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CvSVMParams" "', argument " "10"" of type '" "CvTermCriteria""'");
+ }
+ if (!argp10) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvSVMParams" "', argument " "10"" of type '" "CvTermCriteria""'");
+ } else {
+ arg10 = *((CvTermCriteria *)(argp10));
+ }
+ }
+ {
+ try {
+ result = (CvSVMParams *)new CvSVMParams(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVMParams (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[10]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8),octave_value_ref(args,9)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvSVMParams__SWIG_0(args, nargout);
+ }
+ if (argc == 10) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[3], NULL);
+ _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_double(argv[6], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[7], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_CvTermCriteria, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvSVMParams__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvSVMParams_svm_type_set (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMParams_svm_type_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_svm_type_set" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMParams_svm_type_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->svm_type = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_svm_type_get (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvSVMParams_svm_type_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_svm_type_get" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ result = (int) ((arg1)->svm_type);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_kernel_type_set (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMParams_kernel_type_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_kernel_type_set" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMParams_kernel_type_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->kernel_type = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_kernel_type_get (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvSVMParams_kernel_type_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_kernel_type_get" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ result = (int) ((arg1)->kernel_type);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_degree_set (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMParams_degree_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_degree_set" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMParams_degree_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->degree = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_degree_get (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvSVMParams_degree_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_degree_get" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ result = (double) ((arg1)->degree);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_gamma_set (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMParams_gamma_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_gamma_set" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMParams_gamma_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->gamma = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_gamma_get (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvSVMParams_gamma_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_gamma_get" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ result = (double) ((arg1)->gamma);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_coef0_set (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMParams_coef0_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_coef0_set" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMParams_coef0_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->coef0 = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_coef0_get (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvSVMParams_coef0_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_coef0_get" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ result = (double) ((arg1)->coef0);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_C_set (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMParams_C_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_C_set" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMParams_C_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->C = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_C_get (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvSVMParams_C_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_C_get" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ result = (double) ((arg1)->C);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_nu_set (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMParams_nu_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_nu_set" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMParams_nu_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->nu = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_nu_get (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvSVMParams_nu_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_nu_get" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ result = (double) ((arg1)->nu);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_p_set (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMParams_p_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_p_set" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMParams_p_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->p = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_p_get (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvSVMParams_p_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_p_get" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ result = (double) ((arg1)->p);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_class_weights_set (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMParams_class_weights_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_class_weights_set" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMParams_class_weights_set" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->class_weights = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_class_weights_get (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMParams_class_weights_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_class_weights_get" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ result = (CvMat *) ((arg1)->class_weights);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_term_crit_set (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ CvTermCriteria *arg2 = (CvTermCriteria *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMParams_term_crit_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_term_crit_set" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTermCriteria, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMParams_term_crit_set" "', argument " "2"" of type '" "CvTermCriteria *""'");
+ }
+ arg2 = (CvTermCriteria *)(argp2);
+ if (arg1) (arg1)->term_crit = *arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMParams_term_crit_get (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvTermCriteria *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMParams_term_crit_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMParams_term_crit_get" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ result = (CvTermCriteria *)& ((arg1)->term_crit);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTermCriteria, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvSVMParams (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvSVMParams",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSVMParams" "', argument " "1"" of type '" "CvSVMParams *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvSVMParams_members[] = {
+{"svm_type",0,_wrap_CvSVMParams_svm_type_get,_wrap_CvSVMParams_svm_type_set,0,0},
+{"kernel_type",0,_wrap_CvSVMParams_kernel_type_get,_wrap_CvSVMParams_kernel_type_set,0,0},
+{"degree",0,_wrap_CvSVMParams_degree_get,_wrap_CvSVMParams_degree_set,0,0},
+{"gamma",0,_wrap_CvSVMParams_gamma_get,_wrap_CvSVMParams_gamma_set,0,0},
+{"coef0",0,_wrap_CvSVMParams_coef0_get,_wrap_CvSVMParams_coef0_set,0,0},
+{"C",0,_wrap_CvSVMParams_C_get,_wrap_CvSVMParams_C_set,0,0},
+{"nu",0,_wrap_CvSVMParams_nu_get,_wrap_CvSVMParams_nu_set,0,0},
+{"p",0,_wrap_CvSVMParams_p_get,_wrap_CvSVMParams_p_set,0,0},
+{"class_weights",0,_wrap_CvSVMParams_class_weights_get,_wrap_CvSVMParams_class_weights_set,0,0},
+{"term_crit",0,_wrap_CvSVMParams_term_crit_get,_wrap_CvSVMParams_term_crit_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvSVMParams_base_names[] = {0};
+static const swig_type_info *swig_CvSVMParams_base[] = {0};
+static swig_octave_class _wrap_class_CvSVMParams = {"CvSVMParams", &SWIGTYPE_p_CvSVMParams,0,_wrap_new_CvSVMParams,0,_wrap_delete_CvSVMParams,swig_CvSVMParams_members,swig_CvSVMParams_base_names,swig_CvSVMParams_base };
+
+static octave_value_list _wrap_new_CvSVMKernel__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMKernel *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVMKernel",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvSVMKernel *)new CvSVMKernel();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMKernel, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVMKernel__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvSVMParams *arg1 = (CvSVMParams *) 0 ;
+ CvSVMKernel::Calc arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMKernel *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVMKernel",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvSVMKernel" "', argument " "1"" of type '" "CvSVMParams const *""'");
+ }
+ arg1 = (CvSVMParams *)(argp1);
+ {
+ int res = SWIG_ConvertMember(args(1), SWIG_as_voidptr(&arg2), sizeof(CvSVMKernel::Calc),SWIGTYPE_m_CvSVMKernel__f_int_int_p_p_q_const__float_p_q_const__float_p_float__void);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvSVMKernel" "', argument " "2"" of type '" "CvSVMKernel::Calc""'");
+ }
+ }
+ {
+ try {
+ result = (CvSVMKernel *)new CvSVMKernel((CvSVMParams const *)arg1,arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMKernel, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVMKernel (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[2]={
+ octave_value_ref(args,0),octave_value_ref(args,1)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvSVMKernel__SWIG_0(args, nargout);
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_m_CvSVMKernel__f_int_int_p_p_q_const__float_p_q_const__float_p_float__void, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvSVMKernel__SWIG_1(args, nargout);
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvSVMKernel_create (const octave_value_list& args, int nargout) {
+ CvSVMKernel *arg1 = (CvSVMKernel *) 0 ;
+ CvSVMParams *arg2 = (CvSVMParams *) 0 ;
+ CvSVMKernel::Calc arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVMKernel_create",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernel_create" "', argument " "1"" of type '" "CvSVMKernel *""'");
+ }
+ arg1 = (CvSVMKernel *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMKernel_create" "', argument " "2"" of type '" "CvSVMParams const *""'");
+ }
+ arg2 = (CvSVMParams *)(argp2);
+ {
+ int res = SWIG_ConvertMember(args(2), SWIG_as_voidptr(&arg3), sizeof(CvSVMKernel::Calc),SWIGTYPE_m_CvSVMKernel__f_int_int_p_p_q_const__float_p_q_const__float_p_float__void);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvSVMKernel_create" "', argument " "3"" of type '" "CvSVMKernel::Calc""'");
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->create((CvSVMParams const *)arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvSVMKernel (const octave_value_list& args, int nargout) {
+ CvSVMKernel *arg1 = (CvSVMKernel *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvSVMKernel",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernel, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSVMKernel" "', argument " "1"" of type '" "CvSVMKernel *""'");
+ }
+ arg1 = (CvSVMKernel *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernel_clear (const octave_value_list& args, int nargout) {
+ CvSVMKernel *arg1 = (CvSVMKernel *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMKernel_clear",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernel_clear" "', argument " "1"" of type '" "CvSVMKernel *""'");
+ }
+ arg1 = (CvSVMKernel *)(argp1);
+ {
+ try {
+ (arg1)->clear();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernel_calc (const octave_value_list& args, int nargout) {
+ CvSVMKernel *arg1 = (CvSVMKernel *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ float **arg4 = (float **) 0 ;
+ float *arg5 = (float *) 0 ;
+ float *arg6 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *vptr4 ;
+ float *buffer4 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMKernel_calc",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernel_calc" "', argument " "1"" of type '" "CvSVMKernel *""'");
+ }
+ arg1 = (CvSVMKernel *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMKernel_calc" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSVMKernel_calc" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ if ((SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer4 = (float *) vptr4;
+ arg4=&buffer4;
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVMKernel_calc" "', argument " "5"" of type '" "float const *""'");
+ }
+ arg5 = (float *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVMKernel_calc" "', argument " "6"" of type '" "float *""'");
+ }
+ arg6 = (float *)(argp6);
+ {
+ try {
+ (arg1)->calc(arg2,arg3,(float const **)arg4,(float const *)arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernel_params_set (const octave_value_list& args, int nargout) {
+ CvSVMKernel *arg1 = (CvSVMKernel *) 0 ;
+ CvSVMParams *arg2 = (CvSVMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMKernel_params_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernel_params_set" "', argument " "1"" of type '" "CvSVMKernel *""'");
+ }
+ arg1 = (CvSVMKernel *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSVMParams, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMKernel_params_set" "', argument " "2"" of type '" "CvSVMParams const *""'");
+ }
+ arg2 = (CvSVMParams *)(argp2);
+ if (arg1) (arg1)->params = (CvSVMParams const *)arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernel_params_get (const octave_value_list& args, int nargout) {
+ CvSVMKernel *arg1 = (CvSVMKernel *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMParams *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMKernel_params_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernel_params_get" "', argument " "1"" of type '" "CvSVMKernel *""'");
+ }
+ arg1 = (CvSVMKernel *)(argp1);
+ result = (CvSVMParams *) ((arg1)->params);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernel_calc_func_set (const octave_value_list& args, int nargout) {
+ CvSVMKernel *arg1 = (CvSVMKernel *) 0 ;
+ CvSVMKernel::Calc arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMKernel_calc_func_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernel_calc_func_set" "', argument " "1"" of type '" "CvSVMKernel *""'");
+ }
+ arg1 = (CvSVMKernel *)(argp1);
+ {
+ int res = SWIG_ConvertMember(args(1), SWIG_as_voidptr(&arg2), sizeof(CvSVMKernel::Calc),SWIGTYPE_m_CvSVMKernel__f_int_int_p_p_q_const__float_p_q_const__float_p_float__void);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvSVMKernel_calc_func_set" "', argument " "2"" of type '" "CvSVMKernel::Calc""'");
+ }
+ }
+ if (arg1) (arg1)->calc_func = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernel_calc_func_get (const octave_value_list& args, int nargout) {
+ CvSVMKernel *arg1 = (CvSVMKernel *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMKernel::Calc result;
+
+ if (!SWIG_check_num_args("CvSVMKernel_calc_func_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernel_calc_func_get" "', argument " "1"" of type '" "CvSVMKernel *""'");
+ }
+ arg1 = (CvSVMKernel *)(argp1);
+ result = (CvSVMKernel::Calc) ((arg1)->calc_func);
+ _outv = SWIG_NewMemberObj(SWIG_as_voidptr(&result), sizeof(CvSVMKernel::Calc), SWIGTYPE_m_CvSVMKernel__f_int_int_p_p_q_const__float_p_q_const__float_p_float__void);
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernel_calc_non_rbf_base (const octave_value_list& args, int nargout) {
+ CvSVMKernel *arg1 = (CvSVMKernel *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ float **arg4 = (float **) 0 ;
+ float *arg5 = (float *) 0 ;
+ float *arg6 = (float *) 0 ;
+ double arg7 ;
+ double arg8 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *vptr4 ;
+ float *buffer4 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ double val7 ;
+ int ecode7 = 0 ;
+ double val8 ;
+ int ecode8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMKernel_calc_non_rbf_base",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernel_calc_non_rbf_base" "', argument " "1"" of type '" "CvSVMKernel *""'");
+ }
+ arg1 = (CvSVMKernel *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMKernel_calc_non_rbf_base" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSVMKernel_calc_non_rbf_base" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ if ((SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer4 = (float *) vptr4;
+ arg4=&buffer4;
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVMKernel_calc_non_rbf_base" "', argument " "5"" of type '" "float const *""'");
+ }
+ arg5 = (float *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVMKernel_calc_non_rbf_base" "', argument " "6"" of type '" "float *""'");
+ }
+ arg6 = (float *)(argp6);
+ ecode7 = SWIG_AsVal_double(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvSVMKernel_calc_non_rbf_base" "', argument " "7"" of type '" "double""'");
+ }
+ arg7 = (double)(val7);
+ ecode8 = SWIG_AsVal_double(args(7), &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvSVMKernel_calc_non_rbf_base" "', argument " "8"" of type '" "double""'");
+ }
+ arg8 = (double)(val8);
+ {
+ try {
+ (arg1)->calc_non_rbf_base(arg2,arg3,(float const **)arg4,(float const *)arg5,arg6,arg7,arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernel_calc_linear (const octave_value_list& args, int nargout) {
+ CvSVMKernel *arg1 = (CvSVMKernel *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ float **arg4 = (float **) 0 ;
+ float *arg5 = (float *) 0 ;
+ float *arg6 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *vptr4 ;
+ float *buffer4 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMKernel_calc_linear",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernel_calc_linear" "', argument " "1"" of type '" "CvSVMKernel *""'");
+ }
+ arg1 = (CvSVMKernel *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMKernel_calc_linear" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSVMKernel_calc_linear" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ if ((SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer4 = (float *) vptr4;
+ arg4=&buffer4;
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVMKernel_calc_linear" "', argument " "5"" of type '" "float const *""'");
+ }
+ arg5 = (float *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVMKernel_calc_linear" "', argument " "6"" of type '" "float *""'");
+ }
+ arg6 = (float *)(argp6);
+ {
+ try {
+ (arg1)->calc_linear(arg2,arg3,(float const **)arg4,(float const *)arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernel_calc_rbf (const octave_value_list& args, int nargout) {
+ CvSVMKernel *arg1 = (CvSVMKernel *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ float **arg4 = (float **) 0 ;
+ float *arg5 = (float *) 0 ;
+ float *arg6 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *vptr4 ;
+ float *buffer4 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMKernel_calc_rbf",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernel_calc_rbf" "', argument " "1"" of type '" "CvSVMKernel *""'");
+ }
+ arg1 = (CvSVMKernel *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMKernel_calc_rbf" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSVMKernel_calc_rbf" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ if ((SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer4 = (float *) vptr4;
+ arg4=&buffer4;
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVMKernel_calc_rbf" "', argument " "5"" of type '" "float const *""'");
+ }
+ arg5 = (float *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVMKernel_calc_rbf" "', argument " "6"" of type '" "float *""'");
+ }
+ arg6 = (float *)(argp6);
+ {
+ try {
+ (arg1)->calc_rbf(arg2,arg3,(float const **)arg4,(float const *)arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernel_calc_poly (const octave_value_list& args, int nargout) {
+ CvSVMKernel *arg1 = (CvSVMKernel *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ float **arg4 = (float **) 0 ;
+ float *arg5 = (float *) 0 ;
+ float *arg6 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *vptr4 ;
+ float *buffer4 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMKernel_calc_poly",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernel_calc_poly" "', argument " "1"" of type '" "CvSVMKernel *""'");
+ }
+ arg1 = (CvSVMKernel *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMKernel_calc_poly" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSVMKernel_calc_poly" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ if ((SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer4 = (float *) vptr4;
+ arg4=&buffer4;
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVMKernel_calc_poly" "', argument " "5"" of type '" "float const *""'");
+ }
+ arg5 = (float *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVMKernel_calc_poly" "', argument " "6"" of type '" "float *""'");
+ }
+ arg6 = (float *)(argp6);
+ {
+ try {
+ (arg1)->calc_poly(arg2,arg3,(float const **)arg4,(float const *)arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernel_calc_sigmoid (const octave_value_list& args, int nargout) {
+ CvSVMKernel *arg1 = (CvSVMKernel *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ float **arg4 = (float **) 0 ;
+ float *arg5 = (float *) 0 ;
+ float *arg6 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *vptr4 ;
+ float *buffer4 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMKernel_calc_sigmoid",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernel_calc_sigmoid" "', argument " "1"" of type '" "CvSVMKernel *""'");
+ }
+ arg1 = (CvSVMKernel *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMKernel_calc_sigmoid" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSVMKernel_calc_sigmoid" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ if ((SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer4 = (float *) vptr4;
+ arg4=&buffer4;
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVMKernel_calc_sigmoid" "', argument " "5"" of type '" "float const *""'");
+ }
+ arg5 = (float *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVMKernel_calc_sigmoid" "', argument " "6"" of type '" "float *""'");
+ }
+ arg6 = (float *)(argp6);
+ {
+ try {
+ (arg1)->calc_sigmoid(arg2,arg3,(float const **)arg4,(float const *)arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvSVMKernel_members[] = {
+{"create",_wrap_CvSVMKernel_create,0,0,0,0},
+{"clear",_wrap_CvSVMKernel_clear,0,0,0,0},
+{"calc",_wrap_CvSVMKernel_calc,0,0,0,0},
+{"params",0,_wrap_CvSVMKernel_params_get,_wrap_CvSVMKernel_params_set,0,0},
+{"calc_func",0,_wrap_CvSVMKernel_calc_func_get,_wrap_CvSVMKernel_calc_func_set,0,0},
+{"calc_non_rbf_base",_wrap_CvSVMKernel_calc_non_rbf_base,0,0,0,0},
+{"calc_linear",_wrap_CvSVMKernel_calc_linear,0,0,0,0},
+{"calc_rbf",_wrap_CvSVMKernel_calc_rbf,0,0,0,0},
+{"calc_poly",_wrap_CvSVMKernel_calc_poly,0,0,0,0},
+{"calc_sigmoid",_wrap_CvSVMKernel_calc_sigmoid,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvSVMKernel_base_names[] = {0};
+static const swig_type_info *swig_CvSVMKernel_base[] = {0};
+static swig_octave_class _wrap_class_CvSVMKernel = {"CvSVMKernel", &SWIGTYPE_p_CvSVMKernel,0,_wrap_new_CvSVMKernel,0,_wrap_delete_CvSVMKernel,swig_CvSVMKernel_members,swig_CvSVMKernel_base_names,swig_CvSVMKernel_base };
+
+static octave_value_list _wrap_CvSVMKernelRow_prev_set (const octave_value_list& args, int nargout) {
+ CvSVMKernelRow *arg1 = (CvSVMKernelRow *) 0 ;
+ CvSVMKernelRow *arg2 = (CvSVMKernelRow *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMKernelRow_prev_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernelRow, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernelRow_prev_set" "', argument " "1"" of type '" "CvSVMKernelRow *""'");
+ }
+ arg1 = (CvSVMKernelRow *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSVMKernelRow, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMKernelRow_prev_set" "', argument " "2"" of type '" "CvSVMKernelRow *""'");
+ }
+ arg2 = (CvSVMKernelRow *)(argp2);
+ if (arg1) (arg1)->prev = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernelRow_prev_get (const octave_value_list& args, int nargout) {
+ CvSVMKernelRow *arg1 = (CvSVMKernelRow *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMKernelRow *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMKernelRow_prev_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernelRow, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernelRow_prev_get" "', argument " "1"" of type '" "CvSVMKernelRow *""'");
+ }
+ arg1 = (CvSVMKernelRow *)(argp1);
+ result = (CvSVMKernelRow *) ((arg1)->prev);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMKernelRow, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernelRow_next_set (const octave_value_list& args, int nargout) {
+ CvSVMKernelRow *arg1 = (CvSVMKernelRow *) 0 ;
+ CvSVMKernelRow *arg2 = (CvSVMKernelRow *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMKernelRow_next_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernelRow, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernelRow_next_set" "', argument " "1"" of type '" "CvSVMKernelRow *""'");
+ }
+ arg1 = (CvSVMKernelRow *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSVMKernelRow, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMKernelRow_next_set" "', argument " "2"" of type '" "CvSVMKernelRow *""'");
+ }
+ arg2 = (CvSVMKernelRow *)(argp2);
+ if (arg1) (arg1)->next = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernelRow_next_get (const octave_value_list& args, int nargout) {
+ CvSVMKernelRow *arg1 = (CvSVMKernelRow *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMKernelRow *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMKernelRow_next_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernelRow, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernelRow_next_get" "', argument " "1"" of type '" "CvSVMKernelRow *""'");
+ }
+ arg1 = (CvSVMKernelRow *)(argp1);
+ result = (CvSVMKernelRow *) ((arg1)->next);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMKernelRow, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernelRow_data_set (const octave_value_list& args, int nargout) {
+ CvSVMKernelRow *arg1 = (CvSVMKernelRow *) 0 ;
+ float *arg2 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMKernelRow_data_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernelRow, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernelRow_data_set" "', argument " "1"" of type '" "CvSVMKernelRow *""'");
+ }
+ arg1 = (CvSVMKernelRow *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMKernelRow_data_set" "', argument " "2"" of type '" "float *""'");
+ }
+ arg2 = (float *)(argp2);
+ if (arg1) (arg1)->data = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMKernelRow_data_get (const octave_value_list& args, int nargout) {
+ CvSVMKernelRow *arg1 = (CvSVMKernelRow *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMKernelRow_data_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernelRow, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMKernelRow_data_get" "', argument " "1"" of type '" "CvSVMKernelRow *""'");
+ }
+ arg1 = (CvSVMKernelRow *)(argp1);
+ result = (float *) ((arg1)->data);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVMKernelRow (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMKernelRow *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVMKernelRow",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvSVMKernelRow *)new CvSVMKernelRow();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMKernelRow, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvSVMKernelRow (const octave_value_list& args, int nargout) {
+ CvSVMKernelRow *arg1 = (CvSVMKernelRow *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvSVMKernelRow",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMKernelRow, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSVMKernelRow" "', argument " "1"" of type '" "CvSVMKernelRow *""'");
+ }
+ arg1 = (CvSVMKernelRow *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvSVMKernelRow_members[] = {
+{"prev",0,_wrap_CvSVMKernelRow_prev_get,_wrap_CvSVMKernelRow_prev_set,0,0},
+{"next",0,_wrap_CvSVMKernelRow_next_get,_wrap_CvSVMKernelRow_next_set,0,0},
+{"data",0,_wrap_CvSVMKernelRow_data_get,_wrap_CvSVMKernelRow_data_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvSVMKernelRow_base_names[] = {0};
+static const swig_type_info *swig_CvSVMKernelRow_base[] = {0};
+static swig_octave_class _wrap_class_CvSVMKernelRow = {"CvSVMKernelRow", &SWIGTYPE_p_CvSVMKernelRow,0,_wrap_new_CvSVMKernelRow,0,_wrap_delete_CvSVMKernelRow,swig_CvSVMKernelRow_members,swig_CvSVMKernelRow_base_names,swig_CvSVMKernelRow_base };
+
+static octave_value_list _wrap_CvSVMSolutionInfo_obj_set (const octave_value_list& args, int nargout) {
+ CvSVMSolutionInfo *arg1 = (CvSVMSolutionInfo *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolutionInfo_obj_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolutionInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolutionInfo_obj_set" "', argument " "1"" of type '" "CvSVMSolutionInfo *""'");
+ }
+ arg1 = (CvSVMSolutionInfo *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolutionInfo_obj_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->obj = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolutionInfo_obj_get (const octave_value_list& args, int nargout) {
+ CvSVMSolutionInfo *arg1 = (CvSVMSolutionInfo *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvSVMSolutionInfo_obj_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolutionInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolutionInfo_obj_get" "', argument " "1"" of type '" "CvSVMSolutionInfo *""'");
+ }
+ arg1 = (CvSVMSolutionInfo *)(argp1);
+ result = (double) ((arg1)->obj);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolutionInfo_rho_set (const octave_value_list& args, int nargout) {
+ CvSVMSolutionInfo *arg1 = (CvSVMSolutionInfo *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolutionInfo_rho_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolutionInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolutionInfo_rho_set" "', argument " "1"" of type '" "CvSVMSolutionInfo *""'");
+ }
+ arg1 = (CvSVMSolutionInfo *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolutionInfo_rho_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->rho = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolutionInfo_rho_get (const octave_value_list& args, int nargout) {
+ CvSVMSolutionInfo *arg1 = (CvSVMSolutionInfo *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvSVMSolutionInfo_rho_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolutionInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolutionInfo_rho_get" "', argument " "1"" of type '" "CvSVMSolutionInfo *""'");
+ }
+ arg1 = (CvSVMSolutionInfo *)(argp1);
+ result = (double) ((arg1)->rho);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolutionInfo_upper_bound_p_set (const octave_value_list& args, int nargout) {
+ CvSVMSolutionInfo *arg1 = (CvSVMSolutionInfo *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolutionInfo_upper_bound_p_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolutionInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolutionInfo_upper_bound_p_set" "', argument " "1"" of type '" "CvSVMSolutionInfo *""'");
+ }
+ arg1 = (CvSVMSolutionInfo *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolutionInfo_upper_bound_p_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->upper_bound_p = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolutionInfo_upper_bound_p_get (const octave_value_list& args, int nargout) {
+ CvSVMSolutionInfo *arg1 = (CvSVMSolutionInfo *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvSVMSolutionInfo_upper_bound_p_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolutionInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolutionInfo_upper_bound_p_get" "', argument " "1"" of type '" "CvSVMSolutionInfo *""'");
+ }
+ arg1 = (CvSVMSolutionInfo *)(argp1);
+ result = (double) ((arg1)->upper_bound_p);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolutionInfo_upper_bound_n_set (const octave_value_list& args, int nargout) {
+ CvSVMSolutionInfo *arg1 = (CvSVMSolutionInfo *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolutionInfo_upper_bound_n_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolutionInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolutionInfo_upper_bound_n_set" "', argument " "1"" of type '" "CvSVMSolutionInfo *""'");
+ }
+ arg1 = (CvSVMSolutionInfo *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolutionInfo_upper_bound_n_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->upper_bound_n = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolutionInfo_upper_bound_n_get (const octave_value_list& args, int nargout) {
+ CvSVMSolutionInfo *arg1 = (CvSVMSolutionInfo *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvSVMSolutionInfo_upper_bound_n_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolutionInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolutionInfo_upper_bound_n_get" "', argument " "1"" of type '" "CvSVMSolutionInfo *""'");
+ }
+ arg1 = (CvSVMSolutionInfo *)(argp1);
+ result = (double) ((arg1)->upper_bound_n);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolutionInfo_r_set (const octave_value_list& args, int nargout) {
+ CvSVMSolutionInfo *arg1 = (CvSVMSolutionInfo *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolutionInfo_r_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolutionInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolutionInfo_r_set" "', argument " "1"" of type '" "CvSVMSolutionInfo *""'");
+ }
+ arg1 = (CvSVMSolutionInfo *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolutionInfo_r_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->r = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolutionInfo_r_get (const octave_value_list& args, int nargout) {
+ CvSVMSolutionInfo *arg1 = (CvSVMSolutionInfo *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvSVMSolutionInfo_r_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolutionInfo, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolutionInfo_r_get" "', argument " "1"" of type '" "CvSVMSolutionInfo *""'");
+ }
+ arg1 = (CvSVMSolutionInfo *)(argp1);
+ result = (double) ((arg1)->r);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVMSolutionInfo (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMSolutionInfo *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVMSolutionInfo",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvSVMSolutionInfo *)new CvSVMSolutionInfo();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMSolutionInfo, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvSVMSolutionInfo (const octave_value_list& args, int nargout) {
+ CvSVMSolutionInfo *arg1 = (CvSVMSolutionInfo *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvSVMSolutionInfo",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolutionInfo, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSVMSolutionInfo" "', argument " "1"" of type '" "CvSVMSolutionInfo *""'");
+ }
+ arg1 = (CvSVMSolutionInfo *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvSVMSolutionInfo_members[] = {
+{"obj",0,_wrap_CvSVMSolutionInfo_obj_get,_wrap_CvSVMSolutionInfo_obj_set,0,0},
+{"rho",0,_wrap_CvSVMSolutionInfo_rho_get,_wrap_CvSVMSolutionInfo_rho_set,0,0},
+{"upper_bound_p",0,_wrap_CvSVMSolutionInfo_upper_bound_p_get,_wrap_CvSVMSolutionInfo_upper_bound_p_set,0,0},
+{"upper_bound_n",0,_wrap_CvSVMSolutionInfo_upper_bound_n_get,_wrap_CvSVMSolutionInfo_upper_bound_n_set,0,0},
+{"r",0,_wrap_CvSVMSolutionInfo_r_get,_wrap_CvSVMSolutionInfo_r_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvSVMSolutionInfo_base_names[] = {0};
+static const swig_type_info *swig_CvSVMSolutionInfo_base[] = {0};
+static swig_octave_class _wrap_class_CvSVMSolutionInfo = {"CvSVMSolutionInfo", &SWIGTYPE_p_CvSVMSolutionInfo,0,_wrap_new_CvSVMSolutionInfo,0,_wrap_delete_CvSVMSolutionInfo,swig_CvSVMSolutionInfo_members,swig_CvSVMSolutionInfo_base_names,swig_CvSVMSolutionInfo_base };
+
+static octave_value_list _wrap_new_CvSVMSolver__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMSolver *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVMSolver",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvSVMSolver *)new CvSVMSolver();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMSolver, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVMSolver__SWIG_1 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int arg2 ;
+ float **arg3 = (float **) 0 ;
+ schar *arg4 = (schar *) 0 ;
+ int arg5 ;
+ double *arg6 = (double *) 0 ;
+ double arg7 ;
+ double arg8 ;
+ CvMemStorage *arg9 = (CvMemStorage *) 0 ;
+ CvSVMKernel *arg10 = (CvSVMKernel *) 0 ;
+ CvSVMSolver::GetRow arg11 ;
+ CvSVMSolver::SelectWorkingSet arg12 ;
+ CvSVMSolver::CalcRho arg13 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *vptr3 ;
+ float *buffer3 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ double val7 ;
+ int ecode7 = 0 ;
+ double val8 ;
+ int ecode8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ void *argp10 = 0 ;
+ int res10 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMSolver *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVMSolver",args.length(),13,13,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvSVMSolver" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvSVMSolver" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ {
+ if ((SWIG_ConvertPtr(args(2), &vptr3, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer3 = (float *) vptr3;
+ arg3=&buffer3;
+ }
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_signed_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvSVMSolver" "', argument " "4"" of type '" "schar *""'");
+ }
+ arg4 = (schar *)(argp4);
+ ecode5 = SWIG_AsVal_int(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CvSVMSolver" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvSVMSolver" "', argument " "6"" of type '" "double *""'");
+ }
+ arg6 = (double *)(argp6);
+ ecode7 = SWIG_AsVal_double(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CvSVMSolver" "', argument " "7"" of type '" "double""'");
+ }
+ arg7 = (double)(val7);
+ ecode8 = SWIG_AsVal_double(args(7), &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CvSVMSolver" "', argument " "8"" of type '" "double""'");
+ }
+ arg8 = (double)(val8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9,SWIGTYPE_p_CvMemStorage, 0 | 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CvSVMSolver" "', argument " "9"" of type '" "CvMemStorage *""'");
+ }
+ arg9 = (CvMemStorage *)(argp9);
+ res10 = SWIG_ConvertPtr(args(9), &argp10,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_CvSVMSolver" "', argument " "10"" of type '" "CvSVMKernel *""'");
+ }
+ arg10 = (CvSVMKernel *)(argp10);
+ {
+ int res = SWIG_ConvertMember(args(10), SWIG_as_voidptr(&arg11), sizeof(CvSVMSolver::GetRow),SWIGTYPE_m_CvSVMSolver__f_int_p_float_p_float_bool__p_float);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvSVMSolver" "', argument " "11"" of type '" "CvSVMSolver::GetRow""'");
+ }
+ }
+ {
+ int res = SWIG_ConvertMember(args(11), SWIG_as_voidptr(&arg12), sizeof(CvSVMSolver::SelectWorkingSet),SWIGTYPE_m_CvSVMSolver__f_r_int_r_int__bool);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvSVMSolver" "', argument " "12"" of type '" "CvSVMSolver::SelectWorkingSet""'");
+ }
+ }
+ {
+ int res = SWIG_ConvertMember(args(12), SWIG_as_voidptr(&arg13), sizeof(CvSVMSolver::CalcRho),SWIGTYPE_m_CvSVMSolver__f_r_double_r_double__void);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvSVMSolver" "', argument " "13"" of type '" "CvSVMSolver::CalcRho""'");
+ }
+ }
+ {
+ try {
+ result = (CvSVMSolver *)new CvSVMSolver(arg1,arg2,(float const **)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMSolver, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVMSolver (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[13]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8),octave_value_ref(args,9),octave_value_ref(args,10),octave_value_ref(args,11),octave_value_ref(args,12)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvSVMSolver__SWIG_0(args, nargout);
+ }
+ if (argc == 13) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_signed_char, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[4], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[6], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[7], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvMemStorage, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_CvSVMKernel, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_m_CvSVMSolver__f_int_p_float_p_float_bool__p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_m_CvSVMSolver__f_r_int_r_int__bool, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_m_CvSVMSolver__f_r_double_r_double__void, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvSVMSolver__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_create (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ float **arg4 = (float **) 0 ;
+ schar *arg5 = (schar *) 0 ;
+ int arg6 ;
+ double *arg7 = (double *) 0 ;
+ double arg8 ;
+ double arg9 ;
+ CvMemStorage *arg10 = (CvMemStorage *) 0 ;
+ CvSVMKernel *arg11 = (CvSVMKernel *) 0 ;
+ CvSVMSolver::GetRow arg12 ;
+ CvSVMSolver::SelectWorkingSet arg13 ;
+ CvSVMSolver::CalcRho arg14 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *vptr4 ;
+ float *buffer4 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ int val6 ;
+ int ecode6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ double val8 ;
+ int ecode8 = 0 ;
+ double val9 ;
+ int ecode9 = 0 ;
+ void *argp10 = 0 ;
+ int res10 = 0 ;
+ void *argp11 = 0 ;
+ int res11 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_create",args.length(),14,14,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_create" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_create" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSVMSolver_create" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ if ((SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer4 = (float *) vptr4;
+ arg4=&buffer4;
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_signed_char, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVMSolver_create" "', argument " "5"" of type '" "schar *""'");
+ }
+ arg5 = (schar *)(argp5);
+ ecode6 = SWIG_AsVal_int(args(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvSVMSolver_create" "', argument " "6"" of type '" "int""'");
+ }
+ arg6 = (int)(val6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvSVMSolver_create" "', argument " "7"" of type '" "double *""'");
+ }
+ arg7 = (double *)(argp7);
+ ecode8 = SWIG_AsVal_double(args(7), &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "CvSVMSolver_create" "', argument " "8"" of type '" "double""'");
+ }
+ arg8 = (double)(val8);
+ ecode9 = SWIG_AsVal_double(args(8), &val9);
+ if (!SWIG_IsOK(ecode9)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "CvSVMSolver_create" "', argument " "9"" of type '" "double""'");
+ }
+ arg9 = (double)(val9);
+ res10 = SWIG_ConvertPtr(args(9), &argp10,SWIGTYPE_p_CvMemStorage, 0 | 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CvSVMSolver_create" "', argument " "10"" of type '" "CvMemStorage *""'");
+ }
+ arg10 = (CvMemStorage *)(argp10);
+ res11 = SWIG_ConvertPtr(args(10), &argp11,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res11)) {
+ SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "CvSVMSolver_create" "', argument " "11"" of type '" "CvSVMKernel *""'");
+ }
+ arg11 = (CvSVMKernel *)(argp11);
+ {
+ int res = SWIG_ConvertMember(args(11), SWIG_as_voidptr(&arg12), sizeof(CvSVMSolver::GetRow),SWIGTYPE_m_CvSVMSolver__f_int_p_float_p_float_bool__p_float);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvSVMSolver_create" "', argument " "12"" of type '" "CvSVMSolver::GetRow""'");
+ }
+ }
+ {
+ int res = SWIG_ConvertMember(args(12), SWIG_as_voidptr(&arg13), sizeof(CvSVMSolver::SelectWorkingSet),SWIGTYPE_m_CvSVMSolver__f_r_int_r_int__bool);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvSVMSolver_create" "', argument " "13"" of type '" "CvSVMSolver::SelectWorkingSet""'");
+ }
+ }
+ {
+ int res = SWIG_ConvertMember(args(13), SWIG_as_voidptr(&arg14), sizeof(CvSVMSolver::CalcRho),SWIGTYPE_m_CvSVMSolver__f_r_double_r_double__void);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvSVMSolver_create" "', argument " "14"" of type '" "CvSVMSolver::CalcRho""'");
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->create(arg2,arg3,(float const **)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvSVMSolver (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvSVMSolver",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSVMSolver" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_clear (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_clear",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_clear" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ {
+ try {
+ (arg1)->clear();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_solve_generic (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ CvSVMSolutionInfo *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_solve_generic",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_solve_generic" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSVMSolutionInfo, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_solve_generic" "', argument " "2"" of type '" "CvSVMSolutionInfo &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_solve_generic" "', argument " "2"" of type '" "CvSVMSolutionInfo &""'");
+ }
+ arg2 = (CvSVMSolutionInfo *)(argp2);
+ {
+ try {
+ result = (bool)(arg1)->solve_generic(*arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_solve_c_svc (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ float **arg4 = (float **) 0 ;
+ schar *arg5 = (schar *) 0 ;
+ double arg6 ;
+ double arg7 ;
+ CvMemStorage *arg8 = (CvMemStorage *) 0 ;
+ CvSVMKernel *arg9 = (CvSVMKernel *) 0 ;
+ double *arg10 = (double *) 0 ;
+ CvSVMSolutionInfo *arg11 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *vptr4 ;
+ float *buffer4 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ double val6 ;
+ int ecode6 = 0 ;
+ double val7 ;
+ int ecode7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ void *argp10 = 0 ;
+ int res10 = 0 ;
+ void *argp11 = 0 ;
+ int res11 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_solve_c_svc",args.length(),11,11,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_solve_c_svc" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_solve_c_svc" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSVMSolver_solve_c_svc" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ if ((SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer4 = (float *) vptr4;
+ arg4=&buffer4;
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_signed_char, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVMSolver_solve_c_svc" "', argument " "5"" of type '" "schar *""'");
+ }
+ arg5 = (schar *)(argp5);
+ ecode6 = SWIG_AsVal_double(args(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvSVMSolver_solve_c_svc" "', argument " "6"" of type '" "double""'");
+ }
+ arg6 = (double)(val6);
+ ecode7 = SWIG_AsVal_double(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvSVMSolver_solve_c_svc" "', argument " "7"" of type '" "double""'");
+ }
+ arg7 = (double)(val7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMemStorage, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvSVMSolver_solve_c_svc" "', argument " "8"" of type '" "CvMemStorage *""'");
+ }
+ arg8 = (CvMemStorage *)(argp8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvSVMSolver_solve_c_svc" "', argument " "9"" of type '" "CvSVMKernel *""'");
+ }
+ arg9 = (CvSVMKernel *)(argp9);
+ res10 = SWIG_ConvertPtr(args(9), &argp10,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CvSVMSolver_solve_c_svc" "', argument " "10"" of type '" "double *""'");
+ }
+ arg10 = (double *)(argp10);
+ res11 = SWIG_ConvertPtr(args(10), &argp11, SWIGTYPE_p_CvSVMSolutionInfo, 0 );
+ if (!SWIG_IsOK(res11)) {
+ SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "CvSVMSolver_solve_c_svc" "', argument " "11"" of type '" "CvSVMSolutionInfo &""'");
+ }
+ if (!argp11) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_solve_c_svc" "', argument " "11"" of type '" "CvSVMSolutionInfo &""'");
+ }
+ arg11 = (CvSVMSolutionInfo *)(argp11);
+ {
+ try {
+ result = (bool)(arg1)->solve_c_svc(arg2,arg3,(float const **)arg4,arg5,arg6,arg7,arg8,arg9,arg10,*arg11);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_solve_nu_svc (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ float **arg4 = (float **) 0 ;
+ schar *arg5 = (schar *) 0 ;
+ CvMemStorage *arg6 = (CvMemStorage *) 0 ;
+ CvSVMKernel *arg7 = (CvSVMKernel *) 0 ;
+ double *arg8 = (double *) 0 ;
+ CvSVMSolutionInfo *arg9 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *vptr4 ;
+ float *buffer4 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_solve_nu_svc",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_solve_nu_svc" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_solve_nu_svc" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSVMSolver_solve_nu_svc" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ if ((SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer4 = (float *) vptr4;
+ arg4=&buffer4;
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_signed_char, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVMSolver_solve_nu_svc" "', argument " "5"" of type '" "schar *""'");
+ }
+ arg5 = (schar *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMemStorage, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVMSolver_solve_nu_svc" "', argument " "6"" of type '" "CvMemStorage *""'");
+ }
+ arg6 = (CvMemStorage *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvSVMSolver_solve_nu_svc" "', argument " "7"" of type '" "CvSVMKernel *""'");
+ }
+ arg7 = (CvSVMKernel *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvSVMSolver_solve_nu_svc" "', argument " "8"" of type '" "double *""'");
+ }
+ arg8 = (double *)(argp8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvSVMSolutionInfo, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvSVMSolver_solve_nu_svc" "', argument " "9"" of type '" "CvSVMSolutionInfo &""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_solve_nu_svc" "', argument " "9"" of type '" "CvSVMSolutionInfo &""'");
+ }
+ arg9 = (CvSVMSolutionInfo *)(argp9);
+ {
+ try {
+ result = (bool)(arg1)->solve_nu_svc(arg2,arg3,(float const **)arg4,arg5,arg6,arg7,arg8,*arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_solve_one_class (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ float **arg4 = (float **) 0 ;
+ CvMemStorage *arg5 = (CvMemStorage *) 0 ;
+ CvSVMKernel *arg6 = (CvSVMKernel *) 0 ;
+ double *arg7 = (double *) 0 ;
+ CvSVMSolutionInfo *arg8 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *vptr4 ;
+ float *buffer4 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_solve_one_class",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_solve_one_class" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_solve_one_class" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSVMSolver_solve_one_class" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ if ((SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer4 = (float *) vptr4;
+ arg4=&buffer4;
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMemStorage, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVMSolver_solve_one_class" "', argument " "5"" of type '" "CvMemStorage *""'");
+ }
+ arg5 = (CvMemStorage *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVMSolver_solve_one_class" "', argument " "6"" of type '" "CvSVMKernel *""'");
+ }
+ arg6 = (CvSVMKernel *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvSVMSolver_solve_one_class" "', argument " "7"" of type '" "double *""'");
+ }
+ arg7 = (double *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8, SWIGTYPE_p_CvSVMSolutionInfo, 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvSVMSolver_solve_one_class" "', argument " "8"" of type '" "CvSVMSolutionInfo &""'");
+ }
+ if (!argp8) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_solve_one_class" "', argument " "8"" of type '" "CvSVMSolutionInfo &""'");
+ }
+ arg8 = (CvSVMSolutionInfo *)(argp8);
+ {
+ try {
+ result = (bool)(arg1)->solve_one_class(arg2,arg3,(float const **)arg4,arg5,arg6,arg7,*arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_solve_eps_svr (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ float **arg4 = (float **) 0 ;
+ float *arg5 = (float *) 0 ;
+ CvMemStorage *arg6 = (CvMemStorage *) 0 ;
+ CvSVMKernel *arg7 = (CvSVMKernel *) 0 ;
+ double *arg8 = (double *) 0 ;
+ CvSVMSolutionInfo *arg9 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *vptr4 ;
+ float *buffer4 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_solve_eps_svr",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_solve_eps_svr" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_solve_eps_svr" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSVMSolver_solve_eps_svr" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ if ((SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer4 = (float *) vptr4;
+ arg4=&buffer4;
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVMSolver_solve_eps_svr" "', argument " "5"" of type '" "float const *""'");
+ }
+ arg5 = (float *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMemStorage, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVMSolver_solve_eps_svr" "', argument " "6"" of type '" "CvMemStorage *""'");
+ }
+ arg6 = (CvMemStorage *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvSVMSolver_solve_eps_svr" "', argument " "7"" of type '" "CvSVMKernel *""'");
+ }
+ arg7 = (CvSVMKernel *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvSVMSolver_solve_eps_svr" "', argument " "8"" of type '" "double *""'");
+ }
+ arg8 = (double *)(argp8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvSVMSolutionInfo, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvSVMSolver_solve_eps_svr" "', argument " "9"" of type '" "CvSVMSolutionInfo &""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_solve_eps_svr" "', argument " "9"" of type '" "CvSVMSolutionInfo &""'");
+ }
+ arg9 = (CvSVMSolutionInfo *)(argp9);
+ {
+ try {
+ result = (bool)(arg1)->solve_eps_svr(arg2,arg3,(float const **)arg4,(float const *)arg5,arg6,arg7,arg8,*arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_solve_nu_svr (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ float **arg4 = (float **) 0 ;
+ float *arg5 = (float *) 0 ;
+ CvMemStorage *arg6 = (CvMemStorage *) 0 ;
+ CvSVMKernel *arg7 = (CvSVMKernel *) 0 ;
+ double *arg8 = (double *) 0 ;
+ CvSVMSolutionInfo *arg9 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *vptr4 ;
+ float *buffer4 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_solve_nu_svr",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_solve_nu_svr" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_solve_nu_svr" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSVMSolver_solve_nu_svr" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ if ((SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer4 = (float *) vptr4;
+ arg4=&buffer4;
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVMSolver_solve_nu_svr" "', argument " "5"" of type '" "float const *""'");
+ }
+ arg5 = (float *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMemStorage, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVMSolver_solve_nu_svr" "', argument " "6"" of type '" "CvMemStorage *""'");
+ }
+ arg6 = (CvMemStorage *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvSVMSolver_solve_nu_svr" "', argument " "7"" of type '" "CvSVMKernel *""'");
+ }
+ arg7 = (CvSVMKernel *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvSVMSolver_solve_nu_svr" "', argument " "8"" of type '" "double *""'");
+ }
+ arg8 = (double *)(argp8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvSVMSolutionInfo, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvSVMSolver_solve_nu_svr" "', argument " "9"" of type '" "CvSVMSolutionInfo &""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_solve_nu_svr" "', argument " "9"" of type '" "CvSVMSolutionInfo &""'");
+ }
+ arg9 = (CvSVMSolutionInfo *)(argp9);
+ {
+ try {
+ result = (bool)(arg1)->solve_nu_svr(arg2,arg3,(float const **)arg4,(float const *)arg5,arg6,arg7,arg8,*arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_get_row_base (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ bool *arg3 = (bool *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_get_row_base",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_get_row_base" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_get_row_base" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_bool, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVMSolver_get_row_base" "', argument " "3"" of type '" "bool *""'");
+ }
+ arg3 = (bool *)(argp3);
+ {
+ try {
+ result = (float *)(arg1)->get_row_base(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_get_row (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ float *arg3 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_get_row",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_get_row" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_get_row" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVMSolver_get_row" "', argument " "3"" of type '" "float *""'");
+ }
+ arg3 = (float *)(argp3);
+ {
+ try {
+ result = (float *)(arg1)->get_row(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_sample_count_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_sample_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_sample_count_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_sample_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->sample_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_sample_count_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_sample_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_sample_count_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (int) ((arg1)->sample_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_var_count_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_var_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_var_count_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_var_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->var_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_var_count_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_var_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_var_count_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (int) ((arg1)->var_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_cache_size_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_cache_size_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_cache_size_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_cache_size_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->cache_size = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_cache_size_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_cache_size_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_cache_size_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (int) ((arg1)->cache_size);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_cache_line_size_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_cache_line_size_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_cache_line_size_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_cache_line_size_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->cache_line_size = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_cache_line_size_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_cache_line_size_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_cache_line_size_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (int) ((arg1)->cache_line_size);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_samples_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ float **arg2 = (float **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *vptr2 ;
+ float *buffer2 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_samples_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_samples_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ {
+ if ((SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer2 = (float *) vptr2;
+ arg2=&buffer2;
+ }
+ if (arg1) (arg1)->samples = (float const **)arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_samples_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float **result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_samples_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_samples_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (float **) ((arg1)->samples);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_params_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ CvSVMParams *arg2 = (CvSVMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_params_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_params_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSVMParams, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_params_set" "', argument " "2"" of type '" "CvSVMParams const *""'");
+ }
+ arg2 = (CvSVMParams *)(argp2);
+ if (arg1) (arg1)->params = (CvSVMParams const *)arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_params_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMParams *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_params_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_params_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (CvSVMParams *) ((arg1)->params);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMParams, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_storage_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ CvMemStorage *arg2 = (CvMemStorage *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_storage_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_storage_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMemStorage, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_storage_set" "', argument " "2"" of type '" "CvMemStorage *""'");
+ }
+ arg2 = (CvMemStorage *)(argp2);
+ if (arg1) (arg1)->storage = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_storage_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMemStorage *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_storage_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_storage_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (CvMemStorage *) ((arg1)->storage);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStorage, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_lru_list_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ CvSVMKernelRow *arg2 = (CvSVMKernelRow *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_lru_list_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_lru_list_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSVMKernelRow, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_lru_list_set" "', argument " "2"" of type '" "CvSVMKernelRow *""'");
+ }
+ arg2 = (CvSVMKernelRow *)(argp2);
+ if (arg1) (arg1)->lru_list = *arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_lru_list_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMKernelRow *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_lru_list_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_lru_list_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (CvSVMKernelRow *)& ((arg1)->lru_list);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMKernelRow, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_rows_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ CvSVMKernelRow *arg2 = (CvSVMKernelRow *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_rows_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_rows_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSVMKernelRow, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_rows_set" "', argument " "2"" of type '" "CvSVMKernelRow *""'");
+ }
+ arg2 = (CvSVMKernelRow *)(argp2);
+ if (arg1) (arg1)->rows = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_rows_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMKernelRow *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_rows_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_rows_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (CvSVMKernelRow *) ((arg1)->rows);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMKernelRow, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_alpha_count_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_alpha_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_alpha_count_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_alpha_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->alpha_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_alpha_count_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_alpha_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_alpha_count_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (int) ((arg1)->alpha_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_G_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ double *arg2 = (double *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_G_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_G_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_G_set" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ if (arg1) (arg1)->G = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_G_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_G_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_G_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (double *) ((arg1)->G);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_alpha_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ double *arg2 = (double *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_alpha_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_alpha_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_alpha_set" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ if (arg1) (arg1)->alpha = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_alpha_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_alpha_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_alpha_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (double *) ((arg1)->alpha);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_alpha_status_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ schar *arg2 = (schar *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_alpha_status_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_alpha_status_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_alpha_status_set" "', argument " "2"" of type '" "schar *""'");
+ }
+ arg2 = (schar *)(argp2);
+ if (arg1) (arg1)->alpha_status = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_alpha_status_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ schar *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_alpha_status_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_alpha_status_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (schar *) ((arg1)->alpha_status);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_y_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ schar *arg2 = (schar *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_y_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_y_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_signed_char, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_y_set" "', argument " "2"" of type '" "schar *""'");
+ }
+ arg2 = (schar *)(argp2);
+ if (arg1) (arg1)->y = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_y_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ schar *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_y_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_y_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (schar *) ((arg1)->y);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_b_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ double *arg2 = (double *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_b_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_b_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_b_set" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ if (arg1) (arg1)->b = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_b_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_b_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_b_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (double *) ((arg1)->b);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_buf_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ float **arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_buf_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_buf_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_buf_set" "', argument " "2"" of type '" "float *[2]""'");
+ }
+ arg2 = (float **)(argp2);
+ {
+ if (arg2) {
+ size_t ii = 0;
+ for (; ii < (size_t)2; ++ii) arg1->buf[ii] = arg2[ii];
+ } else {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""buf""' of type '""float *[2]""'");
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_buf_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float **result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_buf_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_buf_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (float **)(float **) ((arg1)->buf);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_eps_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_eps_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_eps_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_eps_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->eps = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_eps_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_eps_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_eps_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (double) ((arg1)->eps);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_max_iter_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_max_iter_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_max_iter_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_max_iter_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->max_iter = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_max_iter_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_max_iter_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_max_iter_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (int) ((arg1)->max_iter);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_C_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ double *arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_C_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_C_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_C_set" "', argument " "2"" of type '" "double [2]""'");
+ }
+ arg2 = (double *)(argp2);
+ {
+ if (arg2) {
+ size_t ii = 0;
+ for (; ii < (size_t)2; ++ii) arg1->C[ii] = arg2[ii];
+ } else {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""C""' of type '""double [2]""'");
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_C_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_C_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_C_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (double *)(double *) ((arg1)->C);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_kernel_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ CvSVMKernel *arg2 = (CvSVMKernel *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_kernel_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_kernel_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSVMKernel, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_kernel_set" "', argument " "2"" of type '" "CvSVMKernel *""'");
+ }
+ arg2 = (CvSVMKernel *)(argp2);
+ if (arg1) (arg1)->kernel = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_kernel_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMKernel *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_kernel_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_kernel_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (CvSVMKernel *) ((arg1)->kernel);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMKernel, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_select_working_set_func_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ CvSVMSolver::SelectWorkingSet arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_select_working_set_func_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_select_working_set_func_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ {
+ int res = SWIG_ConvertMember(args(1), SWIG_as_voidptr(&arg2), sizeof(CvSVMSolver::SelectWorkingSet),SWIGTYPE_m_CvSVMSolver__f_r_int_r_int__bool);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvSVMSolver_select_working_set_func_set" "', argument " "2"" of type '" "CvSVMSolver::SelectWorkingSet""'");
+ }
+ }
+ if (arg1) (arg1)->select_working_set_func = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_select_working_set_func_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMSolver::SelectWorkingSet result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_select_working_set_func_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_select_working_set_func_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (CvSVMSolver::SelectWorkingSet) ((arg1)->select_working_set_func);
+ _outv = SWIG_NewMemberObj(SWIG_as_voidptr(&result), sizeof(CvSVMSolver::SelectWorkingSet), SWIGTYPE_m_CvSVMSolver__f_r_int_r_int__bool);
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_calc_rho_func_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ CvSVMSolver::CalcRho arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_calc_rho_func_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_calc_rho_func_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ {
+ int res = SWIG_ConvertMember(args(1), SWIG_as_voidptr(&arg2), sizeof(CvSVMSolver::CalcRho),SWIGTYPE_m_CvSVMSolver__f_r_double_r_double__void);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvSVMSolver_calc_rho_func_set" "', argument " "2"" of type '" "CvSVMSolver::CalcRho""'");
+ }
+ }
+ if (arg1) (arg1)->calc_rho_func = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_calc_rho_func_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMSolver::CalcRho result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_calc_rho_func_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_calc_rho_func_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (CvSVMSolver::CalcRho) ((arg1)->calc_rho_func);
+ _outv = SWIG_NewMemberObj(SWIG_as_voidptr(&result), sizeof(CvSVMSolver::CalcRho), SWIGTYPE_m_CvSVMSolver__f_r_double_r_double__void);
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_get_row_func_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ CvSVMSolver::GetRow arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_get_row_func_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_get_row_func_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ {
+ int res = SWIG_ConvertMember(args(1), SWIG_as_voidptr(&arg2), sizeof(CvSVMSolver::GetRow),SWIGTYPE_m_CvSVMSolver__f_int_p_float_p_float_bool__p_float);
+ if (!SWIG_IsOK(res)) {
+ SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvSVMSolver_get_row_func_set" "', argument " "2"" of type '" "CvSVMSolver::GetRow""'");
+ }
+ }
+ if (arg1) (arg1)->get_row_func = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_get_row_func_get (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMSolver::GetRow result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_get_row_func_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_get_row_func_get" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ result = (CvSVMSolver::GetRow) ((arg1)->get_row_func);
+ _outv = SWIG_NewMemberObj(SWIG_as_voidptr(&result), sizeof(CvSVMSolver::GetRow), SWIGTYPE_m_CvSVMSolver__f_int_p_float_p_float_bool__p_float);
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_select_working_set (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int *arg2 = 0 ;
+ int *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_select_working_set",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_select_working_set" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_int, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_select_working_set" "', argument " "2"" of type '" "int &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_select_working_set" "', argument " "2"" of type '" "int &""'");
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_int, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVMSolver_select_working_set" "', argument " "3"" of type '" "int &""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_select_working_set" "', argument " "3"" of type '" "int &""'");
+ }
+ arg3 = (int *)(argp3);
+ {
+ try {
+ result = (bool)(arg1)->select_working_set(*arg2,*arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_select_working_set_nu_svm (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int *arg2 = 0 ;
+ int *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVMSolver_select_working_set_nu_svm",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_select_working_set_nu_svm" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_int, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_select_working_set_nu_svm" "', argument " "2"" of type '" "int &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_select_working_set_nu_svm" "', argument " "2"" of type '" "int &""'");
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_int, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVMSolver_select_working_set_nu_svm" "', argument " "3"" of type '" "int &""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_select_working_set_nu_svm" "', argument " "3"" of type '" "int &""'");
+ }
+ arg3 = (int *)(argp3);
+ {
+ try {
+ result = (bool)(arg1)->select_working_set_nu_svm(*arg2,*arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_calc_rho (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ double *arg2 = 0 ;
+ double *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_calc_rho",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_calc_rho" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_double, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_calc_rho" "', argument " "2"" of type '" "double &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_calc_rho" "', argument " "2"" of type '" "double &""'");
+ }
+ arg2 = (double *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_double, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVMSolver_calc_rho" "', argument " "3"" of type '" "double &""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_calc_rho" "', argument " "3"" of type '" "double &""'");
+ }
+ arg3 = (double *)(argp3);
+ {
+ try {
+ (arg1)->calc_rho(*arg2,*arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_calc_rho_nu_svm (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ double *arg2 = 0 ;
+ double *arg3 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMSolver_calc_rho_nu_svm",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_calc_rho_nu_svm" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_double, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMSolver_calc_rho_nu_svm" "', argument " "2"" of type '" "double &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_calc_rho_nu_svm" "', argument " "2"" of type '" "double &""'");
+ }
+ arg2 = (double *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_double, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVMSolver_calc_rho_nu_svm" "', argument " "3"" of type '" "double &""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVMSolver_calc_rho_nu_svm" "', argument " "3"" of type '" "double &""'");
+ }
+ arg3 = (double *)(argp3);
+ {
+ try {
+ (arg1)->calc_rho_nu_svm(*arg2,*arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_get_row_svc (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ float *arg3 = (float *) 0 ;
+ float *arg4 = (float *) 0 ;
+ bool arg5 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ bool val5 ;
+ int ecode5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_get_row_svc",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_get_row_svc" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_get_row_svc" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVMSolver_get_row_svc" "', argument " "3"" of type '" "float *""'");
+ }
+ arg3 = (float *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVMSolver_get_row_svc" "', argument " "4"" of type '" "float *""'");
+ }
+ arg4 = (float *)(argp4);
+ ecode5 = SWIG_AsVal_bool(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvSVMSolver_get_row_svc" "', argument " "5"" of type '" "bool""'");
+ }
+ arg5 = (bool)(val5);
+ {
+ try {
+ result = (float *)(arg1)->get_row_svc(arg2,arg3,arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_get_row_one_class (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ float *arg3 = (float *) 0 ;
+ float *arg4 = (float *) 0 ;
+ bool arg5 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ bool val5 ;
+ int ecode5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_get_row_one_class",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_get_row_one_class" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_get_row_one_class" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVMSolver_get_row_one_class" "', argument " "3"" of type '" "float *""'");
+ }
+ arg3 = (float *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVMSolver_get_row_one_class" "', argument " "4"" of type '" "float *""'");
+ }
+ arg4 = (float *)(argp4);
+ ecode5 = SWIG_AsVal_bool(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvSVMSolver_get_row_one_class" "', argument " "5"" of type '" "bool""'");
+ }
+ arg5 = (bool)(val5);
+ {
+ try {
+ result = (float *)(arg1)->get_row_one_class(arg2,arg3,arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMSolver_get_row_svr (const octave_value_list& args, int nargout) {
+ CvSVMSolver *arg1 = (CvSVMSolver *) 0 ;
+ int arg2 ;
+ float *arg3 = (float *) 0 ;
+ float *arg4 = (float *) 0 ;
+ bool arg5 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ bool val5 ;
+ int ecode5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMSolver_get_row_svr",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMSolver, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMSolver_get_row_svr" "', argument " "1"" of type '" "CvSVMSolver *""'");
+ }
+ arg1 = (CvSVMSolver *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMSolver_get_row_svr" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVMSolver_get_row_svr" "', argument " "3"" of type '" "float *""'");
+ }
+ arg3 = (float *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVMSolver_get_row_svr" "', argument " "4"" of type '" "float *""'");
+ }
+ arg4 = (float *)(argp4);
+ ecode5 = SWIG_AsVal_bool(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvSVMSolver_get_row_svr" "', argument " "5"" of type '" "bool""'");
+ }
+ arg5 = (bool)(val5);
+ {
+ try {
+ result = (float *)(arg1)->get_row_svr(arg2,arg3,arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvSVMSolver_members[] = {
+{"create",_wrap_CvSVMSolver_create,0,0,0,0},
+{"clear",_wrap_CvSVMSolver_clear,0,0,0,0},
+{"solve_generic",_wrap_CvSVMSolver_solve_generic,0,0,0,0},
+{"solve_c_svc",_wrap_CvSVMSolver_solve_c_svc,0,0,0,0},
+{"solve_nu_svc",_wrap_CvSVMSolver_solve_nu_svc,0,0,0,0},
+{"solve_one_class",_wrap_CvSVMSolver_solve_one_class,0,0,0,0},
+{"solve_eps_svr",_wrap_CvSVMSolver_solve_eps_svr,0,0,0,0},
+{"solve_nu_svr",_wrap_CvSVMSolver_solve_nu_svr,0,0,0,0},
+{"get_row_base",_wrap_CvSVMSolver_get_row_base,0,0,0,0},
+{"get_row",_wrap_CvSVMSolver_get_row,0,0,0,0},
+{"sample_count",0,_wrap_CvSVMSolver_sample_count_get,_wrap_CvSVMSolver_sample_count_set,0,0},
+{"var_count",0,_wrap_CvSVMSolver_var_count_get,_wrap_CvSVMSolver_var_count_set,0,0},
+{"cache_size",0,_wrap_CvSVMSolver_cache_size_get,_wrap_CvSVMSolver_cache_size_set,0,0},
+{"cache_line_size",0,_wrap_CvSVMSolver_cache_line_size_get,_wrap_CvSVMSolver_cache_line_size_set,0,0},
+{"samples",0,_wrap_CvSVMSolver_samples_get,_wrap_CvSVMSolver_samples_set,0,0},
+{"params",0,_wrap_CvSVMSolver_params_get,_wrap_CvSVMSolver_params_set,0,0},
+{"storage",0,_wrap_CvSVMSolver_storage_get,_wrap_CvSVMSolver_storage_set,0,0},
+{"lru_list",0,_wrap_CvSVMSolver_lru_list_get,_wrap_CvSVMSolver_lru_list_set,0,0},
+{"rows",0,_wrap_CvSVMSolver_rows_get,_wrap_CvSVMSolver_rows_set,0,0},
+{"alpha_count",0,_wrap_CvSVMSolver_alpha_count_get,_wrap_CvSVMSolver_alpha_count_set,0,0},
+{"G",0,_wrap_CvSVMSolver_G_get,_wrap_CvSVMSolver_G_set,0,0},
+{"alpha",0,_wrap_CvSVMSolver_alpha_get,_wrap_CvSVMSolver_alpha_set,0,0},
+{"alpha_status",0,_wrap_CvSVMSolver_alpha_status_get,_wrap_CvSVMSolver_alpha_status_set,0,0},
+{"y",0,_wrap_CvSVMSolver_y_get,_wrap_CvSVMSolver_y_set,0,0},
+{"b",0,_wrap_CvSVMSolver_b_get,_wrap_CvSVMSolver_b_set,0,0},
+{"buf",0,_wrap_CvSVMSolver_buf_get,_wrap_CvSVMSolver_buf_set,0,0},
+{"eps",0,_wrap_CvSVMSolver_eps_get,_wrap_CvSVMSolver_eps_set,0,0},
+{"max_iter",0,_wrap_CvSVMSolver_max_iter_get,_wrap_CvSVMSolver_max_iter_set,0,0},
+{"C",0,_wrap_CvSVMSolver_C_get,_wrap_CvSVMSolver_C_set,0,0},
+{"kernel",0,_wrap_CvSVMSolver_kernel_get,_wrap_CvSVMSolver_kernel_set,0,0},
+{"select_working_set_func",0,_wrap_CvSVMSolver_select_working_set_func_get,_wrap_CvSVMSolver_select_working_set_func_set,0,0},
+{"calc_rho_func",0,_wrap_CvSVMSolver_calc_rho_func_get,_wrap_CvSVMSolver_calc_rho_func_set,0,0},
+{"get_row_func",0,_wrap_CvSVMSolver_get_row_func_get,_wrap_CvSVMSolver_get_row_func_set,0,0},
+{"select_working_set",_wrap_CvSVMSolver_select_working_set,0,0,0,0},
+{"select_working_set_nu_svm",_wrap_CvSVMSolver_select_working_set_nu_svm,0,0,0,0},
+{"calc_rho",_wrap_CvSVMSolver_calc_rho,0,0,0,0},
+{"calc_rho_nu_svm",_wrap_CvSVMSolver_calc_rho_nu_svm,0,0,0,0},
+{"get_row_svc",_wrap_CvSVMSolver_get_row_svc,0,0,0,0},
+{"get_row_one_class",_wrap_CvSVMSolver_get_row_one_class,0,0,0,0},
+{"get_row_svr",_wrap_CvSVMSolver_get_row_svr,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvSVMSolver_base_names[] = {0};
+static const swig_type_info *swig_CvSVMSolver_base[] = {0};
+static swig_octave_class _wrap_class_CvSVMSolver = {"CvSVMSolver", &SWIGTYPE_p_CvSVMSolver,0,_wrap_new_CvSVMSolver,0,_wrap_delete_CvSVMSolver,swig_CvSVMSolver_members,swig_CvSVMSolver_base_names,swig_CvSVMSolver_base };
+
+static octave_value_list _wrap_CvSVMDecisionFunc_rho_set (const octave_value_list& args, int nargout) {
+ CvSVMDecisionFunc *arg1 = (CvSVMDecisionFunc *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMDecisionFunc_rho_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMDecisionFunc, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMDecisionFunc_rho_set" "', argument " "1"" of type '" "CvSVMDecisionFunc *""'");
+ }
+ arg1 = (CvSVMDecisionFunc *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMDecisionFunc_rho_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->rho = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMDecisionFunc_rho_get (const octave_value_list& args, int nargout) {
+ CvSVMDecisionFunc *arg1 = (CvSVMDecisionFunc *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvSVMDecisionFunc_rho_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMDecisionFunc, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMDecisionFunc_rho_get" "', argument " "1"" of type '" "CvSVMDecisionFunc *""'");
+ }
+ arg1 = (CvSVMDecisionFunc *)(argp1);
+ result = (double) ((arg1)->rho);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMDecisionFunc_sv_count_set (const octave_value_list& args, int nargout) {
+ CvSVMDecisionFunc *arg1 = (CvSVMDecisionFunc *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMDecisionFunc_sv_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMDecisionFunc, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMDecisionFunc_sv_count_set" "', argument " "1"" of type '" "CvSVMDecisionFunc *""'");
+ }
+ arg1 = (CvSVMDecisionFunc *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVMDecisionFunc_sv_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->sv_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMDecisionFunc_sv_count_get (const octave_value_list& args, int nargout) {
+ CvSVMDecisionFunc *arg1 = (CvSVMDecisionFunc *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvSVMDecisionFunc_sv_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMDecisionFunc, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMDecisionFunc_sv_count_get" "', argument " "1"" of type '" "CvSVMDecisionFunc *""'");
+ }
+ arg1 = (CvSVMDecisionFunc *)(argp1);
+ result = (int) ((arg1)->sv_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMDecisionFunc_alpha_set (const octave_value_list& args, int nargout) {
+ CvSVMDecisionFunc *arg1 = (CvSVMDecisionFunc *) 0 ;
+ double *arg2 = (double *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMDecisionFunc_alpha_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMDecisionFunc, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMDecisionFunc_alpha_set" "', argument " "1"" of type '" "CvSVMDecisionFunc *""'");
+ }
+ arg1 = (CvSVMDecisionFunc *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMDecisionFunc_alpha_set" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ if (arg1) (arg1)->alpha = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMDecisionFunc_alpha_get (const octave_value_list& args, int nargout) {
+ CvSVMDecisionFunc *arg1 = (CvSVMDecisionFunc *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMDecisionFunc_alpha_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMDecisionFunc, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMDecisionFunc_alpha_get" "', argument " "1"" of type '" "CvSVMDecisionFunc *""'");
+ }
+ arg1 = (CvSVMDecisionFunc *)(argp1);
+ result = (double *) ((arg1)->alpha);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMDecisionFunc_sv_index_set (const octave_value_list& args, int nargout) {
+ CvSVMDecisionFunc *arg1 = (CvSVMDecisionFunc *) 0 ;
+ int *arg2 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVMDecisionFunc_sv_index_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMDecisionFunc, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMDecisionFunc_sv_index_set" "', argument " "1"" of type '" "CvSVMDecisionFunc *""'");
+ }
+ arg1 = (CvSVMDecisionFunc *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVMDecisionFunc_sv_index_set" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ if (arg1) (arg1)->sv_index = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVMDecisionFunc_sv_index_get (const octave_value_list& args, int nargout) {
+ CvSVMDecisionFunc *arg1 = (CvSVMDecisionFunc *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVMDecisionFunc_sv_index_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMDecisionFunc, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVMDecisionFunc_sv_index_get" "', argument " "1"" of type '" "CvSVMDecisionFunc *""'");
+ }
+ arg1 = (CvSVMDecisionFunc *)(argp1);
+ result = (int *) ((arg1)->sv_index);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVMDecisionFunc (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMDecisionFunc *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVMDecisionFunc",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvSVMDecisionFunc *)new CvSVMDecisionFunc();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVMDecisionFunc, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvSVMDecisionFunc (const octave_value_list& args, int nargout) {
+ CvSVMDecisionFunc *arg1 = (CvSVMDecisionFunc *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvSVMDecisionFunc",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVMDecisionFunc, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSVMDecisionFunc" "', argument " "1"" of type '" "CvSVMDecisionFunc *""'");
+ }
+ arg1 = (CvSVMDecisionFunc *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvSVMDecisionFunc_members[] = {
+{"rho",0,_wrap_CvSVMDecisionFunc_rho_get,_wrap_CvSVMDecisionFunc_rho_set,0,0},
+{"sv_count",0,_wrap_CvSVMDecisionFunc_sv_count_get,_wrap_CvSVMDecisionFunc_sv_count_set,0,0},
+{"alpha",0,_wrap_CvSVMDecisionFunc_alpha_get,_wrap_CvSVMDecisionFunc_alpha_set,0,0},
+{"sv_index",0,_wrap_CvSVMDecisionFunc_sv_index_get,_wrap_CvSVMDecisionFunc_sv_index_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvSVMDecisionFunc_base_names[] = {0};
+static const swig_type_info *swig_CvSVMDecisionFunc_base[] = {0};
+static swig_octave_class _wrap_class_CvSVMDecisionFunc = {"CvSVMDecisionFunc", &SWIGTYPE_p_CvSVMDecisionFunc,0,_wrap_new_CvSVMDecisionFunc,0,_wrap_delete_CvSVMDecisionFunc,swig_CvSVMDecisionFunc_members,swig_CvSVMDecisionFunc_base_names,swig_CvSVMDecisionFunc_base };
+
+static octave_value_list _wrap_new_CvSVM__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVM *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVM",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvSVM *)new CvSVM();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVM, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvSVM (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvSVM",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSVM" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVM__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvSVMParams arg5 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVM *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVM",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvSVM" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvSVM" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvSVM" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvSVM" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ res5 = SWIG_ConvertPtr(args(4), &argp5, SWIGTYPE_p_CvSVMParams, 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvSVM" "', argument " "5"" of type '" "CvSVMParams""'");
+ }
+ if (!argp5) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvSVM" "', argument " "5"" of type '" "CvSVMParams""'");
+ } else {
+ arg5 = *((CvSVMParams *)(argp5));
+ }
+ }
+ {
+ try {
+ result = (CvSVM *)new CvSVM((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVM, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVM__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVM *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVM",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvSVM" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvSVM" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvSVM" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvSVM" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (CvSVM *)new CvSVM((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVM, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVM__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVM *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVM",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvSVM" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvSVM" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvSVM" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (CvSVM *)new CvSVM((CvMat const *)arg1,(CvMat const *)arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVM, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVM__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVM *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvSVM",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvSVM" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvSVM" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ result = (CvSVM *)new CvSVM((CvMat const *)arg1,(CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSVM, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvSVM (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[5]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvSVM__SWIG_0(args, nargout);
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvSVM__SWIG_4(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvSVM__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvSVM__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvSVMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvSVM__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvSVM_train__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvSVMParams arg6 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVM_train",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_train" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVM_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVM_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ res6 = SWIG_ConvertPtr(args(5), &argp6, SWIGTYPE_p_CvSVMParams, 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVM_train" "', argument " "6"" of type '" "CvSVMParams""'");
+ }
+ if (!argp6) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train" "', argument " "6"" of type '" "CvSVMParams""'");
+ } else {
+ arg6 = *((CvSVMParams *)(argp6));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_train__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVM_train",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_train" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVM_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVM_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_train__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVM_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_train" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVM_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_train__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVM_train",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_train" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_train (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[6]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5)
+ };
+
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvSVM_train__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvSVM_train__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvSVM_train__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvSVMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvSVM_train__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvSVM_train_auto__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvSVMParams arg6 ;
+ int arg7 ;
+ CvParamGrid arg8 ;
+ CvParamGrid arg9 ;
+ CvParamGrid arg10 ;
+ CvParamGrid arg11 ;
+ CvParamGrid arg12 ;
+ CvParamGrid arg13 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 ;
+ int res6 = 0 ;
+ int val7 ;
+ int ecode7 = 0 ;
+ void *argp8 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ void *argp10 ;
+ int res10 = 0 ;
+ void *argp11 ;
+ int res11 = 0 ;
+ void *argp12 ;
+ int res12 = 0 ;
+ void *argp13 ;
+ int res13 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVM_train_auto",args.length(),13,13,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_train_auto" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_train_auto" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_train_auto" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVM_train_auto" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVM_train_auto" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ res6 = SWIG_ConvertPtr(args(5), &argp6, SWIGTYPE_p_CvSVMParams, 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ }
+ if (!argp6) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ } else {
+ arg6 = *((CvSVMParams *)(argp6));
+ }
+ }
+ ecode7 = SWIG_AsVal_int(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvSVM_train_auto" "', argument " "7"" of type '" "int""'");
+ }
+ arg7 = (int)(val7);
+ {
+ res8 = SWIG_ConvertPtr(args(7), &argp8, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvSVM_train_auto" "', argument " "8"" of type '" "CvParamGrid""'");
+ }
+ if (!argp8) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "8"" of type '" "CvParamGrid""'");
+ } else {
+ arg8 = *((CvParamGrid *)(argp8));
+ }
+ }
+ {
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvSVM_train_auto" "', argument " "9"" of type '" "CvParamGrid""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "9"" of type '" "CvParamGrid""'");
+ } else {
+ arg9 = *((CvParamGrid *)(argp9));
+ }
+ }
+ {
+ res10 = SWIG_ConvertPtr(args(9), &argp10, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CvSVM_train_auto" "', argument " "10"" of type '" "CvParamGrid""'");
+ }
+ if (!argp10) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "10"" of type '" "CvParamGrid""'");
+ } else {
+ arg10 = *((CvParamGrid *)(argp10));
+ }
+ }
+ {
+ res11 = SWIG_ConvertPtr(args(10), &argp11, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res11)) {
+ SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "CvSVM_train_auto" "', argument " "11"" of type '" "CvParamGrid""'");
+ }
+ if (!argp11) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "11"" of type '" "CvParamGrid""'");
+ } else {
+ arg11 = *((CvParamGrid *)(argp11));
+ }
+ }
+ {
+ res12 = SWIG_ConvertPtr(args(11), &argp12, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res12)) {
+ SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "CvSVM_train_auto" "', argument " "12"" of type '" "CvParamGrid""'");
+ }
+ if (!argp12) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "12"" of type '" "CvParamGrid""'");
+ } else {
+ arg12 = *((CvParamGrid *)(argp12));
+ }
+ }
+ {
+ res13 = SWIG_ConvertPtr(args(12), &argp13, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res13)) {
+ SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "CvSVM_train_auto" "', argument " "13"" of type '" "CvParamGrid""'");
+ }
+ if (!argp13) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "13"" of type '" "CvParamGrid""'");
+ } else {
+ arg13 = *((CvParamGrid *)(argp13));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train_auto((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_train_auto__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvSVMParams arg6 ;
+ int arg7 ;
+ CvParamGrid arg8 ;
+ CvParamGrid arg9 ;
+ CvParamGrid arg10 ;
+ CvParamGrid arg11 ;
+ CvParamGrid arg12 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 ;
+ int res6 = 0 ;
+ int val7 ;
+ int ecode7 = 0 ;
+ void *argp8 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ void *argp10 ;
+ int res10 = 0 ;
+ void *argp11 ;
+ int res11 = 0 ;
+ void *argp12 ;
+ int res12 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVM_train_auto",args.length(),12,12,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_train_auto" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_train_auto" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_train_auto" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVM_train_auto" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVM_train_auto" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ res6 = SWIG_ConvertPtr(args(5), &argp6, SWIGTYPE_p_CvSVMParams, 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ }
+ if (!argp6) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ } else {
+ arg6 = *((CvSVMParams *)(argp6));
+ }
+ }
+ ecode7 = SWIG_AsVal_int(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvSVM_train_auto" "', argument " "7"" of type '" "int""'");
+ }
+ arg7 = (int)(val7);
+ {
+ res8 = SWIG_ConvertPtr(args(7), &argp8, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvSVM_train_auto" "', argument " "8"" of type '" "CvParamGrid""'");
+ }
+ if (!argp8) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "8"" of type '" "CvParamGrid""'");
+ } else {
+ arg8 = *((CvParamGrid *)(argp8));
+ }
+ }
+ {
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvSVM_train_auto" "', argument " "9"" of type '" "CvParamGrid""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "9"" of type '" "CvParamGrid""'");
+ } else {
+ arg9 = *((CvParamGrid *)(argp9));
+ }
+ }
+ {
+ res10 = SWIG_ConvertPtr(args(9), &argp10, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CvSVM_train_auto" "', argument " "10"" of type '" "CvParamGrid""'");
+ }
+ if (!argp10) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "10"" of type '" "CvParamGrid""'");
+ } else {
+ arg10 = *((CvParamGrid *)(argp10));
+ }
+ }
+ {
+ res11 = SWIG_ConvertPtr(args(10), &argp11, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res11)) {
+ SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "CvSVM_train_auto" "', argument " "11"" of type '" "CvParamGrid""'");
+ }
+ if (!argp11) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "11"" of type '" "CvParamGrid""'");
+ } else {
+ arg11 = *((CvParamGrid *)(argp11));
+ }
+ }
+ {
+ res12 = SWIG_ConvertPtr(args(11), &argp12, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res12)) {
+ SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "CvSVM_train_auto" "', argument " "12"" of type '" "CvParamGrid""'");
+ }
+ if (!argp12) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "12"" of type '" "CvParamGrid""'");
+ } else {
+ arg12 = *((CvParamGrid *)(argp12));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train_auto((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_train_auto__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvSVMParams arg6 ;
+ int arg7 ;
+ CvParamGrid arg8 ;
+ CvParamGrid arg9 ;
+ CvParamGrid arg10 ;
+ CvParamGrid arg11 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 ;
+ int res6 = 0 ;
+ int val7 ;
+ int ecode7 = 0 ;
+ void *argp8 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ void *argp10 ;
+ int res10 = 0 ;
+ void *argp11 ;
+ int res11 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVM_train_auto",args.length(),11,11,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_train_auto" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_train_auto" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_train_auto" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVM_train_auto" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVM_train_auto" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ res6 = SWIG_ConvertPtr(args(5), &argp6, SWIGTYPE_p_CvSVMParams, 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ }
+ if (!argp6) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ } else {
+ arg6 = *((CvSVMParams *)(argp6));
+ }
+ }
+ ecode7 = SWIG_AsVal_int(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvSVM_train_auto" "', argument " "7"" of type '" "int""'");
+ }
+ arg7 = (int)(val7);
+ {
+ res8 = SWIG_ConvertPtr(args(7), &argp8, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvSVM_train_auto" "', argument " "8"" of type '" "CvParamGrid""'");
+ }
+ if (!argp8) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "8"" of type '" "CvParamGrid""'");
+ } else {
+ arg8 = *((CvParamGrid *)(argp8));
+ }
+ }
+ {
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvSVM_train_auto" "', argument " "9"" of type '" "CvParamGrid""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "9"" of type '" "CvParamGrid""'");
+ } else {
+ arg9 = *((CvParamGrid *)(argp9));
+ }
+ }
+ {
+ res10 = SWIG_ConvertPtr(args(9), &argp10, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CvSVM_train_auto" "', argument " "10"" of type '" "CvParamGrid""'");
+ }
+ if (!argp10) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "10"" of type '" "CvParamGrid""'");
+ } else {
+ arg10 = *((CvParamGrid *)(argp10));
+ }
+ }
+ {
+ res11 = SWIG_ConvertPtr(args(10), &argp11, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res11)) {
+ SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "CvSVM_train_auto" "', argument " "11"" of type '" "CvParamGrid""'");
+ }
+ if (!argp11) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "11"" of type '" "CvParamGrid""'");
+ } else {
+ arg11 = *((CvParamGrid *)(argp11));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train_auto((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6,arg7,arg8,arg9,arg10,arg11);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_train_auto__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvSVMParams arg6 ;
+ int arg7 ;
+ CvParamGrid arg8 ;
+ CvParamGrid arg9 ;
+ CvParamGrid arg10 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 ;
+ int res6 = 0 ;
+ int val7 ;
+ int ecode7 = 0 ;
+ void *argp8 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ void *argp10 ;
+ int res10 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVM_train_auto",args.length(),10,10,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_train_auto" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_train_auto" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_train_auto" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVM_train_auto" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVM_train_auto" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ res6 = SWIG_ConvertPtr(args(5), &argp6, SWIGTYPE_p_CvSVMParams, 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ }
+ if (!argp6) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ } else {
+ arg6 = *((CvSVMParams *)(argp6));
+ }
+ }
+ ecode7 = SWIG_AsVal_int(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvSVM_train_auto" "', argument " "7"" of type '" "int""'");
+ }
+ arg7 = (int)(val7);
+ {
+ res8 = SWIG_ConvertPtr(args(7), &argp8, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvSVM_train_auto" "', argument " "8"" of type '" "CvParamGrid""'");
+ }
+ if (!argp8) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "8"" of type '" "CvParamGrid""'");
+ } else {
+ arg8 = *((CvParamGrid *)(argp8));
+ }
+ }
+ {
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvSVM_train_auto" "', argument " "9"" of type '" "CvParamGrid""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "9"" of type '" "CvParamGrid""'");
+ } else {
+ arg9 = *((CvParamGrid *)(argp9));
+ }
+ }
+ {
+ res10 = SWIG_ConvertPtr(args(9), &argp10, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "CvSVM_train_auto" "', argument " "10"" of type '" "CvParamGrid""'");
+ }
+ if (!argp10) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "10"" of type '" "CvParamGrid""'");
+ } else {
+ arg10 = *((CvParamGrid *)(argp10));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train_auto((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6,arg7,arg8,arg9,arg10);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_train_auto__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvSVMParams arg6 ;
+ int arg7 ;
+ CvParamGrid arg8 ;
+ CvParamGrid arg9 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 ;
+ int res6 = 0 ;
+ int val7 ;
+ int ecode7 = 0 ;
+ void *argp8 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVM_train_auto",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_train_auto" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_train_auto" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_train_auto" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVM_train_auto" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVM_train_auto" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ res6 = SWIG_ConvertPtr(args(5), &argp6, SWIGTYPE_p_CvSVMParams, 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ }
+ if (!argp6) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ } else {
+ arg6 = *((CvSVMParams *)(argp6));
+ }
+ }
+ ecode7 = SWIG_AsVal_int(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvSVM_train_auto" "', argument " "7"" of type '" "int""'");
+ }
+ arg7 = (int)(val7);
+ {
+ res8 = SWIG_ConvertPtr(args(7), &argp8, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvSVM_train_auto" "', argument " "8"" of type '" "CvParamGrid""'");
+ }
+ if (!argp8) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "8"" of type '" "CvParamGrid""'");
+ } else {
+ arg8 = *((CvParamGrid *)(argp8));
+ }
+ }
+ {
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvSVM_train_auto" "', argument " "9"" of type '" "CvParamGrid""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "9"" of type '" "CvParamGrid""'");
+ } else {
+ arg9 = *((CvParamGrid *)(argp9));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train_auto((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6,arg7,arg8,arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_train_auto__SWIG_5 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvSVMParams arg6 ;
+ int arg7 ;
+ CvParamGrid arg8 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 ;
+ int res6 = 0 ;
+ int val7 ;
+ int ecode7 = 0 ;
+ void *argp8 ;
+ int res8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVM_train_auto",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_train_auto" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_train_auto" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_train_auto" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVM_train_auto" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVM_train_auto" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ res6 = SWIG_ConvertPtr(args(5), &argp6, SWIGTYPE_p_CvSVMParams, 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ }
+ if (!argp6) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ } else {
+ arg6 = *((CvSVMParams *)(argp6));
+ }
+ }
+ ecode7 = SWIG_AsVal_int(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvSVM_train_auto" "', argument " "7"" of type '" "int""'");
+ }
+ arg7 = (int)(val7);
+ {
+ res8 = SWIG_ConvertPtr(args(7), &argp8, SWIGTYPE_p_CvParamGrid, 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvSVM_train_auto" "', argument " "8"" of type '" "CvParamGrid""'");
+ }
+ if (!argp8) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "8"" of type '" "CvParamGrid""'");
+ } else {
+ arg8 = *((CvParamGrid *)(argp8));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train_auto((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6,arg7,arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_train_auto__SWIG_6 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvSVMParams arg6 ;
+ int arg7 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 ;
+ int res6 = 0 ;
+ int val7 ;
+ int ecode7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVM_train_auto",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_train_auto" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_train_auto" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_train_auto" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVM_train_auto" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVM_train_auto" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ res6 = SWIG_ConvertPtr(args(5), &argp6, SWIGTYPE_p_CvSVMParams, 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ }
+ if (!argp6) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ } else {
+ arg6 = *((CvSVMParams *)(argp6));
+ }
+ }
+ ecode7 = SWIG_AsVal_int(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvSVM_train_auto" "', argument " "7"" of type '" "int""'");
+ }
+ arg7 = (int)(val7);
+ {
+ try {
+ result = (bool)(arg1)->train_auto((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6,arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_train_auto__SWIG_7 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvSVMParams arg6 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvSVM_train_auto",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_train_auto" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_train_auto" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_train_auto" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvSVM_train_auto" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvSVM_train_auto" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ res6 = SWIG_ConvertPtr(args(5), &argp6, SWIGTYPE_p_CvSVMParams, 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ }
+ if (!argp6) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvSVM_train_auto" "', argument " "6"" of type '" "CvSVMParams""'");
+ } else {
+ arg6 = *((CvSVMParams *)(argp6));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train_auto((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_train_auto (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[13]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8),octave_value_ref(args,9),octave_value_ref(args,10),octave_value_ref(args,11),octave_value_ref(args,12)
+ };
+
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvSVMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvSVM_train_auto__SWIG_7(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvSVMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[6], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvSVM_train_auto__SWIG_6(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 8) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvSVMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[6], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvSVM_train_auto__SWIG_5(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 9) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvSVMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[6], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvSVM_train_auto__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 10) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvSVMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[6], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvSVM_train_auto__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 11) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvSVMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[6], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvSVM_train_auto__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 12) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvSVMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[6], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvSVM_train_auto__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 13) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvSVMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[6], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_CvParamGrid, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvSVM_train_auto__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvSVM_predict__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ bool arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ bool val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvSVM_predict",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_predict" "', argument " "1"" of type '" "CvSVM const *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_bool(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvSVM_predict" "', argument " "3"" of type '" "bool""'");
+ }
+ arg3 = (bool)(val3);
+ {
+ try {
+ result = (float)((CvSVM const *)arg1)->predict((CvMat const *)arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_predict__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvSVM_predict",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_predict" "', argument " "1"" of type '" "CvSVM const *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ result = (float)((CvSVM const *)arg1)->predict((CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_predict (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[3]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvSVM_predict__SWIG_1(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSVM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvSVM_predict__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvSVM_get_support_vector_count (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvSVM_get_support_vector_count",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_get_support_vector_count" "', argument " "1"" of type '" "CvSVM const *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ {
+ try {
+ result = (int)((CvSVM const *)arg1)->get_support_vector_count();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_get_support_vector (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float *result = 0 ;
+
+ if (!SWIG_check_num_args("CvSVM_get_support_vector",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_get_support_vector" "', argument " "1"" of type '" "CvSVM const *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSVM_get_support_vector" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ {
+ try {
+ result = (float *)((CvSVM const *)arg1)->get_support_vector(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_get_params (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSVMParams result;
+
+ if (!SWIG_check_num_args("CvSVM_get_params",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_get_params" "', argument " "1"" of type '" "CvSVM const *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ {
+ try {
+ result = ((CvSVM const *)arg1)->get_params();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj((new CvSVMParams((const CvSVMParams&)(result))), SWIGTYPE_p_CvSVMParams, SWIG_POINTER_OWN | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_clear (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVM_clear",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_clear" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ {
+ try {
+ (arg1)->clear();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_get_default_grid (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvParamGrid result;
+
+ if (!SWIG_check_num_args("CvSVM_get_default_grid",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "CvSVM_get_default_grid" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ {
+ try {
+ result = CvSVM::get_default_grid(arg1);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj((new CvParamGrid((const CvParamGrid&)(result))), SWIGTYPE_p_CvParamGrid, SWIG_POINTER_OWN | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_write (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ char *arg3 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVM_write",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_write" "', argument " "1"" of type '" "CvSVM const *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_write" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_write" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ {
+ try {
+ ((CvSVM const *)arg1)->write(arg2,(char const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_read (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvSVM_read",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_read" "', argument " "1"" of type '" "CvSVM *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSVM_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSVM_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ {
+ try {
+ (arg1)->read(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvSVM_get_var_count (const octave_value_list& args, int nargout) {
+ CvSVM *arg1 = (CvSVM *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvSVM_get_var_count",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSVM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSVM_get_var_count" "', argument " "1"" of type '" "CvSVM const *""'");
+ }
+ arg1 = (CvSVM *)(argp1);
+ {
+ try {
+ result = (int)((CvSVM const *)arg1)->get_var_count();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvSVM_members[] = {
+{"train",_wrap_CvSVM_train,0,0,0,0},
+{"train_auto",_wrap_CvSVM_train_auto,0,0,0,0},
+{"predict",_wrap_CvSVM_predict,0,0,0,0},
+{"get_support_vector_count",_wrap_CvSVM_get_support_vector_count,0,0,0,0},
+{"get_support_vector",_wrap_CvSVM_get_support_vector,0,0,0,0},
+{"get_params",_wrap_CvSVM_get_params,0,0,0,0},
+{"clear",_wrap_CvSVM_clear,0,0,0,0},
+{"get_default_grid",_wrap_CvSVM_get_default_grid,0,0,1,0},
+{"write",_wrap_CvSVM_write,0,0,0,0},
+{"read",_wrap_CvSVM_read,0,0,0,0},
+{"get_var_count",_wrap_CvSVM_get_var_count,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvSVM_base_names[] = {"_p_CvStatModel",0};
+static const swig_type_info *swig_CvSVM_base[] = {0,0};
+static swig_octave_class _wrap_class_CvSVM = {"CvSVM", &SWIGTYPE_p_CvSVM,0,_wrap_new_CvSVM,0,_wrap_delete_CvSVM,swig_CvSVM_members,swig_CvSVM_base_names,swig_CvSVM_base };
+
+static octave_value_list _wrap_new_CvEMParams__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEMParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEMParams",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvEMParams *)new CvEMParams();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEMParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEMParams__SWIG_1 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ CvTermCriteria arg4 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat **arg8 = (CvMat **) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEMParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEMParams",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvEMParams" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvEMParams" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvEMParams" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ res4 = SWIG_ConvertPtr(args(3), &argp4, SWIGTYPE_p_CvTermCriteria, 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvEMParams" "', argument " "4"" of type '" "CvTermCriteria""'");
+ }
+ if (!argp4) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvEMParams" "', argument " "4"" of type '" "CvTermCriteria""'");
+ } else {
+ arg4 = *((CvTermCriteria *)(argp4));
+ }
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvEMParams" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvEMParams" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CvEMParams" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CvEMParams" "', argument " "8"" of type '" "CvMat const **""'");
+ }
+ arg8 = (CvMat **)(argp8);
+ {
+ try {
+ result = (CvEMParams *)new CvEMParams(arg1,arg2,arg3,arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const **)arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEMParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEMParams__SWIG_2 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ CvTermCriteria arg4 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEMParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEMParams",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvEMParams" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvEMParams" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvEMParams" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ res4 = SWIG_ConvertPtr(args(3), &argp4, SWIGTYPE_p_CvTermCriteria, 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvEMParams" "', argument " "4"" of type '" "CvTermCriteria""'");
+ }
+ if (!argp4) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvEMParams" "', argument " "4"" of type '" "CvTermCriteria""'");
+ } else {
+ arg4 = *((CvTermCriteria *)(argp4));
+ }
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvEMParams" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvEMParams" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CvEMParams" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ {
+ try {
+ result = (CvEMParams *)new CvEMParams(arg1,arg2,arg3,arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEMParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEMParams__SWIG_3 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ CvTermCriteria arg4 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEMParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEMParams",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvEMParams" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvEMParams" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvEMParams" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ res4 = SWIG_ConvertPtr(args(3), &argp4, SWIGTYPE_p_CvTermCriteria, 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvEMParams" "', argument " "4"" of type '" "CvTermCriteria""'");
+ }
+ if (!argp4) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvEMParams" "', argument " "4"" of type '" "CvTermCriteria""'");
+ } else {
+ arg4 = *((CvTermCriteria *)(argp4));
+ }
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvEMParams" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvEMParams" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ {
+ try {
+ result = (CvEMParams *)new CvEMParams(arg1,arg2,arg3,arg4,(CvMat const *)arg5,(CvMat const *)arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEMParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEMParams__SWIG_4 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ CvTermCriteria arg4 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEMParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEMParams",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvEMParams" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvEMParams" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvEMParams" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ res4 = SWIG_ConvertPtr(args(3), &argp4, SWIGTYPE_p_CvTermCriteria, 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvEMParams" "', argument " "4"" of type '" "CvTermCriteria""'");
+ }
+ if (!argp4) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvEMParams" "', argument " "4"" of type '" "CvTermCriteria""'");
+ } else {
+ arg4 = *((CvTermCriteria *)(argp4));
+ }
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvEMParams" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (CvEMParams *)new CvEMParams(arg1,arg2,arg3,arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEMParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEMParams__SWIG_5 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ CvTermCriteria arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEMParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEMParams",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvEMParams" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvEMParams" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvEMParams" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ res4 = SWIG_ConvertPtr(args(3), &argp4, SWIGTYPE_p_CvTermCriteria, 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvEMParams" "', argument " "4"" of type '" "CvTermCriteria""'");
+ }
+ if (!argp4) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvEMParams" "', argument " "4"" of type '" "CvTermCriteria""'");
+ } else {
+ arg4 = *((CvTermCriteria *)(argp4));
+ }
+ }
+ {
+ try {
+ result = (CvEMParams *)new CvEMParams(arg1,arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEMParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEMParams__SWIG_6 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEMParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEMParams",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvEMParams" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvEMParams" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvEMParams" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ try {
+ result = (CvEMParams *)new CvEMParams(arg1,arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEMParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEMParams__SWIG_7 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEMParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEMParams",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvEMParams" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvEMParams" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ {
+ try {
+ result = (CvEMParams *)new CvEMParams(arg1,arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEMParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEMParams__SWIG_8 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEMParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEMParams",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvEMParams" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ {
+ try {
+ result = (CvEMParams *)new CvEMParams(arg1);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEMParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEMParams (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[8]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvEMParams__SWIG_0(args, nargout);
+ }
+ if (argc == 1) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvEMParams__SWIG_8(args, nargout);
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(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_CvEMParams__SWIG_7(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _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_new_CvEMParams__SWIG_6(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _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) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvTermCriteria, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvEMParams__SWIG_5(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _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) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvTermCriteria, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvEMParams__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _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) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvTermCriteria, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvEMParams__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _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) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvTermCriteria, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvEMParams__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 8) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _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) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvTermCriteria, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvEMParams__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvEMParams_nclusters_set (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvEMParams_nclusters_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_nclusters_set" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvEMParams_nclusters_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->nclusters = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_nclusters_get (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvEMParams_nclusters_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_nclusters_get" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ result = (int) ((arg1)->nclusters);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_cov_mat_type_set (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvEMParams_cov_mat_type_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_cov_mat_type_set" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvEMParams_cov_mat_type_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->cov_mat_type = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_cov_mat_type_get (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvEMParams_cov_mat_type_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_cov_mat_type_get" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ result = (int) ((arg1)->cov_mat_type);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_start_step_set (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvEMParams_start_step_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_start_step_set" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvEMParams_start_step_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->start_step = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_start_step_get (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvEMParams_start_step_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_start_step_get" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ result = (int) ((arg1)->start_step);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_probs_set (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvEMParams_probs_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_probs_set" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvEMParams_probs_set" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->probs = (CvMat const *)arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_probs_get (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvEMParams_probs_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_probs_get" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ result = (CvMat *) ((arg1)->probs);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_weights_set (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvEMParams_weights_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_weights_set" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvEMParams_weights_set" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->weights = (CvMat const *)arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_weights_get (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvEMParams_weights_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_weights_get" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ result = (CvMat *) ((arg1)->weights);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_means_set (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvEMParams_means_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_means_set" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvEMParams_means_set" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->means = (CvMat const *)arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_means_get (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvEMParams_means_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_means_get" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ result = (CvMat *) ((arg1)->means);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_covs_set (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ CvMat **arg2 = (CvMat **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvEMParams_covs_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_covs_set" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvEMParams_covs_set" "', argument " "2"" of type '" "CvMat const **""'");
+ }
+ arg2 = (CvMat **)(argp2);
+ if (arg1) (arg1)->covs = (CvMat const **)arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_covs_get (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat **result = 0 ;
+
+ if (!SWIG_check_num_args("CvEMParams_covs_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_covs_get" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ result = (CvMat **) ((arg1)->covs);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_term_crit_set (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ CvTermCriteria *arg2 = (CvTermCriteria *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvEMParams_term_crit_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_term_crit_set" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTermCriteria, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvEMParams_term_crit_set" "', argument " "2"" of type '" "CvTermCriteria *""'");
+ }
+ arg2 = (CvTermCriteria *)(argp2);
+ if (arg1) (arg1)->term_crit = *arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEMParams_term_crit_get (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvTermCriteria *result = 0 ;
+
+ if (!SWIG_check_num_args("CvEMParams_term_crit_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEMParams_term_crit_get" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ result = (CvTermCriteria *)& ((arg1)->term_crit);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTermCriteria, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvEMParams (const octave_value_list& args, int nargout) {
+ CvEMParams *arg1 = (CvEMParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvEMParams",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEMParams, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvEMParams" "', argument " "1"" of type '" "CvEMParams *""'");
+ }
+ arg1 = (CvEMParams *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvEMParams_members[] = {
+{"nclusters",0,_wrap_CvEMParams_nclusters_get,_wrap_CvEMParams_nclusters_set,0,0},
+{"cov_mat_type",0,_wrap_CvEMParams_cov_mat_type_get,_wrap_CvEMParams_cov_mat_type_set,0,0},
+{"start_step",0,_wrap_CvEMParams_start_step_get,_wrap_CvEMParams_start_step_set,0,0},
+{"probs",0,_wrap_CvEMParams_probs_get,_wrap_CvEMParams_probs_set,0,0},
+{"weights",0,_wrap_CvEMParams_weights_get,_wrap_CvEMParams_weights_set,0,0},
+{"means",0,_wrap_CvEMParams_means_get,_wrap_CvEMParams_means_set,0,0},
+{"covs",0,_wrap_CvEMParams_covs_get,_wrap_CvEMParams_covs_set,0,0},
+{"term_crit",0,_wrap_CvEMParams_term_crit_get,_wrap_CvEMParams_term_crit_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvEMParams_base_names[] = {0};
+static const swig_type_info *swig_CvEMParams_base[] = {0};
+static swig_octave_class _wrap_class_CvEMParams = {"CvEMParams", &SWIGTYPE_p_CvEMParams,0,_wrap_new_CvEMParams,0,_wrap_delete_CvEMParams,swig_CvEMParams_members,swig_CvEMParams_base_names,swig_CvEMParams_base };
+
+static octave_value_list _wrap_new_CvEM__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEM *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEM",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvEM *)new CvEM();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEM, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEM__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvEMParams arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEM *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEM",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvEM" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvEM" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_CvEMParams, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvEM" "', argument " "3"" of type '" "CvEMParams""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvEM" "', argument " "3"" of type '" "CvEMParams""'");
+ } else {
+ arg3 = *((CvEMParams *)(argp3));
+ }
+ }
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvEM" "', argument " "4"" of type '" "CvMat *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (CvEM *)new CvEM((CvMat const *)arg1,(CvMat const *)arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEM, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEM__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvEMParams arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEM *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEM",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvEM" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvEM" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_CvEMParams, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvEM" "', argument " "3"" of type '" "CvEMParams""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvEM" "', argument " "3"" of type '" "CvEMParams""'");
+ } else {
+ arg3 = *((CvEMParams *)(argp3));
+ }
+ }
+ {
+ try {
+ result = (CvEM *)new CvEM((CvMat const *)arg1,(CvMat const *)arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEM, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEM__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEM *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEM",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvEM" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvEM" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ result = (CvEM *)new CvEM((CvMat const *)arg1,(CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEM, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEM__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvEM *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvEM",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvEM" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ {
+ try {
+ result = (CvEM *)new CvEM((CvMat const *)arg1);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvEM, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvEM (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[4]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvEM__SWIG_0(args, nargout);
+ }
+ if (argc == 1) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvEM__SWIG_4(args, nargout);
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvEM__SWIG_3(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvEMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvEM__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvEMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvEM__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_delete_CvEM (const octave_value_list& args, int nargout) {
+ CvEM *arg1 = (CvEM *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvEM",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEM, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvEM" "', argument " "1"" of type '" "CvEM *""'");
+ }
+ arg1 = (CvEM *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEM_train__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvEM *arg1 = (CvEM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvEMParams arg4 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvEM_train",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEM_train" "', argument " "1"" of type '" "CvEM *""'");
+ }
+ arg1 = (CvEM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvEM_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvEM_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ res4 = SWIG_ConvertPtr(args(3), &argp4, SWIGTYPE_p_CvEMParams, 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvEM_train" "', argument " "4"" of type '" "CvEMParams""'");
+ }
+ if (!argp4) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvEM_train" "', argument " "4"" of type '" "CvEMParams""'");
+ } else {
+ arg4 = *((CvEMParams *)(argp4));
+ }
+ }
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvEM_train" "', argument " "5"" of type '" "CvMat *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEM_train__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvEM *arg1 = (CvEM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvEMParams arg4 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvEM_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEM_train" "', argument " "1"" of type '" "CvEM *""'");
+ }
+ arg1 = (CvEM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvEM_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvEM_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ res4 = SWIG_ConvertPtr(args(3), &argp4, SWIGTYPE_p_CvEMParams, 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvEM_train" "', argument " "4"" of type '" "CvEMParams""'");
+ }
+ if (!argp4) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvEM_train" "', argument " "4"" of type '" "CvEMParams""'");
+ } else {
+ arg4 = *((CvEMParams *)(argp4));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEM_train__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvEM *arg1 = (CvEM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvEM_train",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEM_train" "', argument " "1"" of type '" "CvEM *""'");
+ }
+ arg1 = (CvEM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvEM_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvEM_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEM_train__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvEM *arg1 = (CvEM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvEM_train",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEM_train" "', argument " "1"" of type '" "CvEM *""'");
+ }
+ arg1 = (CvEM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvEM_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEM_train (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[5]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvEM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvEM_train__SWIG_3(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvEM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvEM_train__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvEM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvEMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvEM_train__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvEM, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvEMParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvEM_train__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvEM_predict (const octave_value_list& args, int nargout) {
+ CvEM *arg1 = (CvEM *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvEM_predict",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEM_predict" "', argument " "1"" of type '" "CvEM const *""'");
+ }
+ arg1 = (CvEM *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvEM_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvEM_predict" "', argument " "3"" of type '" "CvMat *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (float)((CvEM const *)arg1)->predict((CvMat const *)arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEM_clear (const octave_value_list& args, int nargout) {
+ CvEM *arg1 = (CvEM *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvEM_clear",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEM_clear" "', argument " "1"" of type '" "CvEM *""'");
+ }
+ arg1 = (CvEM *)(argp1);
+ {
+ try {
+ (arg1)->clear();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEM_get_nclusters (const octave_value_list& args, int nargout) {
+ CvEM *arg1 = (CvEM *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvEM_get_nclusters",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEM_get_nclusters" "', argument " "1"" of type '" "CvEM const *""'");
+ }
+ arg1 = (CvEM *)(argp1);
+ {
+ try {
+ result = (int)((CvEM const *)arg1)->get_nclusters();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEM_get_means (const octave_value_list& args, int nargout) {
+ CvEM *arg1 = (CvEM *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvEM_get_means",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEM_get_means" "', argument " "1"" of type '" "CvEM const *""'");
+ }
+ arg1 = (CvEM *)(argp1);
+ {
+ try {
+ result = (CvMat *)((CvEM const *)arg1)->get_means();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEM_get_weights (const octave_value_list& args, int nargout) {
+ CvEM *arg1 = (CvEM *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvEM_get_weights",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEM_get_weights" "', argument " "1"" of type '" "CvEM const *""'");
+ }
+ arg1 = (CvEM *)(argp1);
+ {
+ try {
+ result = (CvMat *)((CvEM const *)arg1)->get_weights();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEM_get_probs (const octave_value_list& args, int nargout) {
+ CvEM *arg1 = (CvEM *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvEM_get_probs",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEM_get_probs" "', argument " "1"" of type '" "CvEM const *""'");
+ }
+ arg1 = (CvEM *)(argp1);
+ {
+ try {
+ result = (CvMat *)((CvEM const *)arg1)->get_probs();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEM_get_log_likelihood (const octave_value_list& args, int nargout) {
+ CvEM *arg1 = (CvEM *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvEM_get_log_likelihood",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEM_get_log_likelihood" "', argument " "1"" of type '" "CvEM const *""'");
+ }
+ arg1 = (CvEM *)(argp1);
+ {
+ try {
+ result = (double)((CvEM const *)arg1)->get_log_likelihood();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvEM_get_covs (const octave_value_list& args, int nargout) {
+ CvEM *arg1 = (CvEM *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ octave_value result;
+
+ if (!SWIG_check_num_args("CvEM_get_covs",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvEM, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvEM_get_covs" "', argument " "1"" of type '" "CvEM *""'");
+ }
+ arg1 = (CvEM *)(argp1);
+ {
+ try {
+ result = CvEM_get_covs(arg1);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = result;
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvEM_members[] = {
+{"train",_wrap_CvEM_train,0,0,0,0},
+{"predict",_wrap_CvEM_predict,0,0,0,0},
+{"clear",_wrap_CvEM_clear,0,0,0,0},
+{"get_nclusters",_wrap_CvEM_get_nclusters,0,0,0,0},
+{"get_means",_wrap_CvEM_get_means,0,0,0,0},
+{"get_weights",_wrap_CvEM_get_weights,0,0,0,0},
+{"get_probs",_wrap_CvEM_get_probs,0,0,0,0},
+{"get_log_likelihood",_wrap_CvEM_get_log_likelihood,0,0,0,0},
+{"get_covs",_wrap_CvEM_get_covs,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvEM_base_names[] = {"_p_CvStatModel",0};
+static const swig_type_info *swig_CvEM_base[] = {0,0};
+static swig_octave_class _wrap_class_CvEM = {"CvEM", &SWIGTYPE_p_CvEM,0,_wrap_new_CvEM,0,_wrap_delete_CvEM,swig_CvEM_members,swig_CvEM_base_names,swig_CvEM_base };
+
+static octave_value_list _wrap_CvPair16u32s_u_set (const octave_value_list& args, int nargout) {
+ CvPair16u32s *arg1 = (CvPair16u32s *) 0 ;
+ unsigned short *arg2 = (unsigned short *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvPair16u32s_u_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPair16u32s, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPair16u32s_u_set" "', argument " "1"" of type '" "CvPair16u32s *""'");
+ }
+ arg1 = (CvPair16u32s *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_unsigned_short, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvPair16u32s_u_set" "', argument " "2"" of type '" "unsigned short *""'");
+ }
+ arg2 = (unsigned short *)(argp2);
+ if (arg1) (arg1)->u = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvPair16u32s_u_get (const octave_value_list& args, int nargout) {
+ CvPair16u32s *arg1 = (CvPair16u32s *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ unsigned short *result = 0 ;
+
+ if (!SWIG_check_num_args("CvPair16u32s_u_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPair16u32s, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPair16u32s_u_get" "', argument " "1"" of type '" "CvPair16u32s *""'");
+ }
+ arg1 = (CvPair16u32s *)(argp1);
+ result = (unsigned short *) ((arg1)->u);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvPair16u32s_i_set (const octave_value_list& args, int nargout) {
+ CvPair16u32s *arg1 = (CvPair16u32s *) 0 ;
+ int *arg2 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvPair16u32s_i_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPair16u32s, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPair16u32s_i_set" "', argument " "1"" of type '" "CvPair16u32s *""'");
+ }
+ arg1 = (CvPair16u32s *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvPair16u32s_i_set" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ if (arg1) (arg1)->i = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvPair16u32s_i_get (const octave_value_list& args, int nargout) {
+ CvPair16u32s *arg1 = (CvPair16u32s *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int *result = 0 ;
+
+ if (!SWIG_check_num_args("CvPair16u32s_i_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPair16u32s, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPair16u32s_i_get" "', argument " "1"" of type '" "CvPair16u32s *""'");
+ }
+ arg1 = (CvPair16u32s *)(argp1);
+ result = (int *) ((arg1)->i);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvPair16u32s (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvPair16u32s *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvPair16u32s",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvPair16u32s *)new CvPair16u32s();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPair16u32s, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvPair16u32s (const octave_value_list& args, int nargout) {
+ CvPair16u32s *arg1 = (CvPair16u32s *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvPair16u32s",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPair16u32s, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPair16u32s" "', argument " "1"" of type '" "CvPair16u32s *""'");
+ }
+ arg1 = (CvPair16u32s *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvPair16u32s_members[] = {
+{"u",0,_wrap_CvPair16u32s_u_get,_wrap_CvPair16u32s_u_set,0,0},
+{"i",0,_wrap_CvPair16u32s_i_get,_wrap_CvPair16u32s_i_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvPair16u32s_base_names[] = {0};
+static const swig_type_info *swig_CvPair16u32s_base[] = {0};
+static swig_octave_class _wrap_class_CvPair16u32s = {"CvPair16u32s", &SWIGTYPE_p_CvPair16u32s,0,_wrap_new_CvPair16u32s,0,_wrap_delete_CvPair16u32s,swig_CvPair16u32s_members,swig_CvPair16u32s_base_names,swig_CvPair16u32s_base };
+
+static octave_value_list _wrap_CvDTreeSplit_var_idx_set (const octave_value_list& args, int nargout) {
+ CvDTreeSplit *arg1 = (CvDTreeSplit *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeSplit_var_idx_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeSplit_var_idx_set" "', argument " "1"" of type '" "CvDTreeSplit *""'");
+ }
+ arg1 = (CvDTreeSplit *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeSplit_var_idx_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->var_idx = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeSplit_var_idx_get (const octave_value_list& args, int nargout) {
+ CvDTreeSplit *arg1 = (CvDTreeSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeSplit_var_idx_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeSplit_var_idx_get" "', argument " "1"" of type '" "CvDTreeSplit *""'");
+ }
+ arg1 = (CvDTreeSplit *)(argp1);
+ result = (int) ((arg1)->var_idx);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeSplit_condensed_idx_set (const octave_value_list& args, int nargout) {
+ CvDTreeSplit *arg1 = (CvDTreeSplit *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeSplit_condensed_idx_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeSplit_condensed_idx_set" "', argument " "1"" of type '" "CvDTreeSplit *""'");
+ }
+ arg1 = (CvDTreeSplit *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeSplit_condensed_idx_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->condensed_idx = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeSplit_condensed_idx_get (const octave_value_list& args, int nargout) {
+ CvDTreeSplit *arg1 = (CvDTreeSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeSplit_condensed_idx_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeSplit_condensed_idx_get" "', argument " "1"" of type '" "CvDTreeSplit *""'");
+ }
+ arg1 = (CvDTreeSplit *)(argp1);
+ result = (int) ((arg1)->condensed_idx);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeSplit_inversed_set (const octave_value_list& args, int nargout) {
+ CvDTreeSplit *arg1 = (CvDTreeSplit *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeSplit_inversed_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeSplit_inversed_set" "', argument " "1"" of type '" "CvDTreeSplit *""'");
+ }
+ arg1 = (CvDTreeSplit *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeSplit_inversed_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->inversed = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeSplit_inversed_get (const octave_value_list& args, int nargout) {
+ CvDTreeSplit *arg1 = (CvDTreeSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeSplit_inversed_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeSplit_inversed_get" "', argument " "1"" of type '" "CvDTreeSplit *""'");
+ }
+ arg1 = (CvDTreeSplit *)(argp1);
+ result = (int) ((arg1)->inversed);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeSplit_quality_set (const octave_value_list& args, int nargout) {
+ CvDTreeSplit *arg1 = (CvDTreeSplit *) 0 ;
+ float arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ float val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeSplit_quality_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeSplit_quality_set" "', argument " "1"" of type '" "CvDTreeSplit *""'");
+ }
+ arg1 = (CvDTreeSplit *)(argp1);
+ ecode2 = SWIG_AsVal_float(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeSplit_quality_set" "', argument " "2"" of type '" "float""'");
+ }
+ arg2 = (float)(val2);
+ if (arg1) (arg1)->quality = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeSplit_quality_get (const octave_value_list& args, int nargout) {
+ CvDTreeSplit *arg1 = (CvDTreeSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvDTreeSplit_quality_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeSplit_quality_get" "', argument " "1"" of type '" "CvDTreeSplit *""'");
+ }
+ arg1 = (CvDTreeSplit *)(argp1);
+ result = (float) ((arg1)->quality);
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeSplit_next_set (const octave_value_list& args, int nargout) {
+ CvDTreeSplit *arg1 = (CvDTreeSplit *) 0 ;
+ CvDTreeSplit *arg2 = (CvDTreeSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeSplit_next_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeSplit_next_set" "', argument " "1"" of type '" "CvDTreeSplit *""'");
+ }
+ arg1 = (CvDTreeSplit *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeSplit, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeSplit_next_set" "', argument " "2"" of type '" "CvDTreeSplit *""'");
+ }
+ arg2 = (CvDTreeSplit *)(argp2);
+ if (arg1) (arg1)->next = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeSplit_next_get (const octave_value_list& args, int nargout) {
+ CvDTreeSplit *arg1 = (CvDTreeSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeSplit *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeSplit_next_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeSplit_next_get" "', argument " "1"" of type '" "CvDTreeSplit *""'");
+ }
+ arg1 = (CvDTreeSplit *)(argp1);
+ result = (CvDTreeSplit *) ((arg1)->next);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeSplit (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeSplit *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTreeSplit",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvDTreeSplit *)new CvDTreeSplit();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeSplit, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvDTreeSplit (const octave_value_list& args, int nargout) {
+ CvDTreeSplit *arg1 = (CvDTreeSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvDTreeSplit",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeSplit, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvDTreeSplit" "', argument " "1"" of type '" "CvDTreeSplit *""'");
+ }
+ arg1 = (CvDTreeSplit *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvDTreeSplit_members[] = {
+{"var_idx",0,_wrap_CvDTreeSplit_var_idx_get,_wrap_CvDTreeSplit_var_idx_set,0,0},
+{"condensed_idx",0,_wrap_CvDTreeSplit_condensed_idx_get,_wrap_CvDTreeSplit_condensed_idx_set,0,0},
+{"inversed",0,_wrap_CvDTreeSplit_inversed_get,_wrap_CvDTreeSplit_inversed_set,0,0},
+{"quality",0,_wrap_CvDTreeSplit_quality_get,_wrap_CvDTreeSplit_quality_set,0,0},
+{"next",0,_wrap_CvDTreeSplit_next_get,_wrap_CvDTreeSplit_next_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvDTreeSplit_base_names[] = {0};
+static const swig_type_info *swig_CvDTreeSplit_base[] = {0};
+static swig_octave_class _wrap_class_CvDTreeSplit = {"CvDTreeSplit", &SWIGTYPE_p_CvDTreeSplit,0,_wrap_new_CvDTreeSplit,0,_wrap_delete_CvDTreeSplit,swig_CvDTreeSplit_members,swig_CvDTreeSplit_base_names,swig_CvDTreeSplit_base };
+
+static octave_value_list _wrap_CvDTreeNode_class_idx_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_class_idx_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_class_idx_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_class_idx_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->class_idx = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_class_idx_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_class_idx_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_class_idx_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (int) ((arg1)->class_idx);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_Tn_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_Tn_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_Tn_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_Tn_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->Tn = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_Tn_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_Tn_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_Tn_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (int) ((arg1)->Tn);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_value_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_value_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_value_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_value_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->value = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_value_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_value_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_value_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (double) ((arg1)->value);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_parent_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_parent_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_parent_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeNode_parent_set" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ if (arg1) (arg1)->parent = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_parent_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeNode *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeNode_parent_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_parent_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (CvDTreeNode *) ((arg1)->parent);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_left_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_left_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_left_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeNode_left_set" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ if (arg1) (arg1)->left = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_left_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeNode *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeNode_left_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_left_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (CvDTreeNode *) ((arg1)->left);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_right_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_right_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_right_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeNode_right_set" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ if (arg1) (arg1)->right = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_right_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeNode *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeNode_right_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_right_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (CvDTreeNode *) ((arg1)->right);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_split_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ CvDTreeSplit *arg2 = (CvDTreeSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_split_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_split_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeSplit, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeNode_split_set" "', argument " "2"" of type '" "CvDTreeSplit *""'");
+ }
+ arg2 = (CvDTreeSplit *)(argp2);
+ if (arg1) (arg1)->split = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_split_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeSplit *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeNode_split_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_split_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (CvDTreeSplit *) ((arg1)->split);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_sample_count_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_sample_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_sample_count_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_sample_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->sample_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_sample_count_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_sample_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_sample_count_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (int) ((arg1)->sample_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_depth_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_depth_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_depth_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_depth_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->depth = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_depth_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_depth_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_depth_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (int) ((arg1)->depth);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_num_valid_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ int *arg2 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_num_valid_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_num_valid_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeNode_num_valid_set" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ if (arg1) (arg1)->num_valid = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_num_valid_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeNode_num_valid_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_num_valid_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (int *) ((arg1)->num_valid);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_offset_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_offset_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_offset_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_offset_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->offset = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_offset_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_offset_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_offset_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (int) ((arg1)->offset);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_buf_idx_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_buf_idx_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_buf_idx_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_buf_idx_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->buf_idx = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_buf_idx_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_buf_idx_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_buf_idx_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (int) ((arg1)->buf_idx);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_maxlr_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_maxlr_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_maxlr_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_maxlr_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->maxlr = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_maxlr_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_maxlr_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_maxlr_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (double) ((arg1)->maxlr);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_complexity_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_complexity_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_complexity_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_complexity_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->complexity = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_complexity_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_complexity_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_complexity_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (int) ((arg1)->complexity);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_alpha_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_alpha_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_alpha_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_alpha_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->alpha = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_alpha_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_alpha_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_alpha_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (double) ((arg1)->alpha);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_node_risk_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_node_risk_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_node_risk_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_node_risk_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->node_risk = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_node_risk_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_node_risk_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_node_risk_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (double) ((arg1)->node_risk);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_tree_risk_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_tree_risk_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_tree_risk_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_tree_risk_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->tree_risk = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_tree_risk_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_tree_risk_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_tree_risk_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (double) ((arg1)->tree_risk);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_tree_error_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_tree_error_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_tree_error_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_tree_error_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->tree_error = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_tree_error_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_tree_error_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_tree_error_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (double) ((arg1)->tree_error);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_cv_Tn_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ int *arg2 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_cv_Tn_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_cv_Tn_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeNode_cv_Tn_set" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ if (arg1) (arg1)->cv_Tn = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_cv_Tn_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeNode_cv_Tn_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_cv_Tn_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (int *) ((arg1)->cv_Tn);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_cv_node_risk_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ double *arg2 = (double *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_cv_node_risk_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_cv_node_risk_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeNode_cv_node_risk_set" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ if (arg1) (arg1)->cv_node_risk = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_cv_node_risk_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeNode_cv_node_risk_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_cv_node_risk_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (double *) ((arg1)->cv_node_risk);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_cv_node_error_set (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ double *arg2 = (double *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_cv_node_error_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_cv_node_error_set" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeNode_cv_node_error_set" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ if (arg1) (arg1)->cv_node_error = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_cv_node_error_get (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeNode_cv_node_error_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_cv_node_error_get" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ result = (double *) ((arg1)->cv_node_error);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_get_num_valid (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeNode_get_num_valid",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_get_num_valid" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_get_num_valid" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ {
+ try {
+ result = (int)(arg1)->get_num_valid(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeNode_set_num_valid (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeNode_set_num_valid",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeNode_set_num_valid" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeNode_set_num_valid" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeNode_set_num_valid" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ try {
+ (arg1)->set_num_valid(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeNode (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeNode *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTreeNode",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvDTreeNode *)new CvDTreeNode();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeNode, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvDTreeNode (const octave_value_list& args, int nargout) {
+ CvDTreeNode *arg1 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvDTreeNode",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeNode, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvDTreeNode" "', argument " "1"" of type '" "CvDTreeNode *""'");
+ }
+ arg1 = (CvDTreeNode *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvDTreeNode_members[] = {
+{"class_idx",0,_wrap_CvDTreeNode_class_idx_get,_wrap_CvDTreeNode_class_idx_set,0,0},
+{"Tn",0,_wrap_CvDTreeNode_Tn_get,_wrap_CvDTreeNode_Tn_set,0,0},
+{"value",0,_wrap_CvDTreeNode_value_get,_wrap_CvDTreeNode_value_set,0,0},
+{"parent",0,_wrap_CvDTreeNode_parent_get,_wrap_CvDTreeNode_parent_set,0,0},
+{"left",0,_wrap_CvDTreeNode_left_get,_wrap_CvDTreeNode_left_set,0,0},
+{"right",0,_wrap_CvDTreeNode_right_get,_wrap_CvDTreeNode_right_set,0,0},
+{"split",0,_wrap_CvDTreeNode_split_get,_wrap_CvDTreeNode_split_set,0,0},
+{"sample_count",0,_wrap_CvDTreeNode_sample_count_get,_wrap_CvDTreeNode_sample_count_set,0,0},
+{"depth",0,_wrap_CvDTreeNode_depth_get,_wrap_CvDTreeNode_depth_set,0,0},
+{"num_valid",0,_wrap_CvDTreeNode_num_valid_get,_wrap_CvDTreeNode_num_valid_set,0,0},
+{"offset",0,_wrap_CvDTreeNode_offset_get,_wrap_CvDTreeNode_offset_set,0,0},
+{"buf_idx",0,_wrap_CvDTreeNode_buf_idx_get,_wrap_CvDTreeNode_buf_idx_set,0,0},
+{"maxlr",0,_wrap_CvDTreeNode_maxlr_get,_wrap_CvDTreeNode_maxlr_set,0,0},
+{"complexity",0,_wrap_CvDTreeNode_complexity_get,_wrap_CvDTreeNode_complexity_set,0,0},
+{"alpha",0,_wrap_CvDTreeNode_alpha_get,_wrap_CvDTreeNode_alpha_set,0,0},
+{"node_risk",0,_wrap_CvDTreeNode_node_risk_get,_wrap_CvDTreeNode_node_risk_set,0,0},
+{"tree_risk",0,_wrap_CvDTreeNode_tree_risk_get,_wrap_CvDTreeNode_tree_risk_set,0,0},
+{"tree_error",0,_wrap_CvDTreeNode_tree_error_get,_wrap_CvDTreeNode_tree_error_set,0,0},
+{"cv_Tn",0,_wrap_CvDTreeNode_cv_Tn_get,_wrap_CvDTreeNode_cv_Tn_set,0,0},
+{"cv_node_risk",0,_wrap_CvDTreeNode_cv_node_risk_get,_wrap_CvDTreeNode_cv_node_risk_set,0,0},
+{"cv_node_error",0,_wrap_CvDTreeNode_cv_node_error_get,_wrap_CvDTreeNode_cv_node_error_set,0,0},
+{"get_num_valid",_wrap_CvDTreeNode_get_num_valid,0,0,0,0},
+{"set_num_valid",_wrap_CvDTreeNode_set_num_valid,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvDTreeNode_base_names[] = {0};
+static const swig_type_info *swig_CvDTreeNode_base[] = {0};
+static swig_octave_class _wrap_class_CvDTreeNode = {"CvDTreeNode", &SWIGTYPE_p_CvDTreeNode,0,_wrap_new_CvDTreeNode,0,_wrap_delete_CvDTreeNode,swig_CvDTreeNode_members,swig_CvDTreeNode_base_names,swig_CvDTreeNode_base };
+
+static octave_value_list _wrap_CvDTreeParams_max_categories_set (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeParams_max_categories_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_max_categories_set" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeParams_max_categories_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->max_categories = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_max_categories_get (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeParams_max_categories_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_max_categories_get" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ result = (int) ((arg1)->max_categories);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_max_depth_set (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeParams_max_depth_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_max_depth_set" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeParams_max_depth_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->max_depth = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_max_depth_get (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeParams_max_depth_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_max_depth_get" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ result = (int) ((arg1)->max_depth);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_min_sample_count_set (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeParams_min_sample_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_min_sample_count_set" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeParams_min_sample_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->min_sample_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_min_sample_count_get (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeParams_min_sample_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_min_sample_count_get" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ result = (int) ((arg1)->min_sample_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_cv_folds_set (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeParams_cv_folds_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_cv_folds_set" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeParams_cv_folds_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->cv_folds = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_cv_folds_get (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeParams_cv_folds_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_cv_folds_get" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ result = (int) ((arg1)->cv_folds);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_use_surrogates_set (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeParams_use_surrogates_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_use_surrogates_set" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ ecode2 = SWIG_AsVal_bool(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeParams_use_surrogates_set" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = (bool)(val2);
+ if (arg1) (arg1)->use_surrogates = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_use_surrogates_get (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTreeParams_use_surrogates_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_use_surrogates_get" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ result = (bool) ((arg1)->use_surrogates);
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_use_1se_rule_set (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeParams_use_1se_rule_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_use_1se_rule_set" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ ecode2 = SWIG_AsVal_bool(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeParams_use_1se_rule_set" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = (bool)(val2);
+ if (arg1) (arg1)->use_1se_rule = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_use_1se_rule_get (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTreeParams_use_1se_rule_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_use_1se_rule_get" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ result = (bool) ((arg1)->use_1se_rule);
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_truncate_pruned_tree_set (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeParams_truncate_pruned_tree_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_truncate_pruned_tree_set" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ ecode2 = SWIG_AsVal_bool(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeParams_truncate_pruned_tree_set" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = (bool)(val2);
+ if (arg1) (arg1)->truncate_pruned_tree = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_truncate_pruned_tree_get (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTreeParams_truncate_pruned_tree_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_truncate_pruned_tree_get" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ result = (bool) ((arg1)->truncate_pruned_tree);
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_regression_accuracy_set (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ float arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ float val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeParams_regression_accuracy_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_regression_accuracy_set" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ ecode2 = SWIG_AsVal_float(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeParams_regression_accuracy_set" "', argument " "2"" of type '" "float""'");
+ }
+ arg2 = (float)(val2);
+ if (arg1) (arg1)->regression_accuracy = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_regression_accuracy_get (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvDTreeParams_regression_accuracy_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_regression_accuracy_get" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ result = (float) ((arg1)->regression_accuracy);
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_priors_set (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ float *arg2 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeParams_priors_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_priors_set" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeParams_priors_set" "', argument " "2"" of type '" "float const *""'");
+ }
+ arg2 = (float *)(argp2);
+ if (arg1) (arg1)->priors = (float const *)arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeParams_priors_get (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeParams_priors_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeParams_priors_get" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ result = (float *) ((arg1)->priors);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeParams__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTreeParams",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvDTreeParams *)new CvDTreeParams();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeParams__SWIG_1 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int arg2 ;
+ float arg3 ;
+ bool arg4 ;
+ int arg5 ;
+ int arg6 ;
+ bool arg7 ;
+ bool arg8 ;
+ float *arg9 = (float *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ float val3 ;
+ int ecode3 = 0 ;
+ bool val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ int val6 ;
+ int ecode6 = 0 ;
+ bool val7 ;
+ int ecode7 = 0 ;
+ bool val8 ;
+ int ecode8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTreeParams",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvDTreeParams" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvDTreeParams" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_float(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvDTreeParams" "', argument " "3"" of type '" "float""'");
+ }
+ arg3 = (float)(val3);
+ ecode4 = SWIG_AsVal_bool(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvDTreeParams" "', argument " "4"" of type '" "bool""'");
+ }
+ arg4 = (bool)(val4);
+ ecode5 = SWIG_AsVal_int(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CvDTreeParams" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ ecode6 = SWIG_AsVal_int(args(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CvDTreeParams" "', argument " "6"" of type '" "int""'");
+ }
+ arg6 = (int)(val6);
+ ecode7 = SWIG_AsVal_bool(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CvDTreeParams" "', argument " "7"" of type '" "bool""'");
+ }
+ arg7 = (bool)(val7);
+ ecode8 = SWIG_AsVal_bool(args(7), &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CvDTreeParams" "', argument " "8"" of type '" "bool""'");
+ }
+ arg8 = (bool)(val8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CvDTreeParams" "', argument " "9"" of type '" "float const *""'");
+ }
+ arg9 = (float *)(argp9);
+ {
+ try {
+ result = (CvDTreeParams *)new CvDTreeParams(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(float const *)arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeParams (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[9]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvDTreeParams__SWIG_0(args, nargout);
+ }
+ if (argc == 9) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _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) {
+ {
+ 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) {
+ {
+ int res = SWIG_AsVal_int(argv[5], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[6], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[7], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvDTreeParams__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_delete_CvDTreeParams (const octave_value_list& args, int nargout) {
+ CvDTreeParams *arg1 = (CvDTreeParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvDTreeParams",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeParams, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvDTreeParams" "', argument " "1"" of type '" "CvDTreeParams *""'");
+ }
+ arg1 = (CvDTreeParams *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvDTreeParams_members[] = {
+{"max_categories",0,_wrap_CvDTreeParams_max_categories_get,_wrap_CvDTreeParams_max_categories_set,0,0},
+{"max_depth",0,_wrap_CvDTreeParams_max_depth_get,_wrap_CvDTreeParams_max_depth_set,0,0},
+{"min_sample_count",0,_wrap_CvDTreeParams_min_sample_count_get,_wrap_CvDTreeParams_min_sample_count_set,0,0},
+{"cv_folds",0,_wrap_CvDTreeParams_cv_folds_get,_wrap_CvDTreeParams_cv_folds_set,0,0},
+{"use_surrogates",0,_wrap_CvDTreeParams_use_surrogates_get,_wrap_CvDTreeParams_use_surrogates_set,0,0},
+{"use_1se_rule",0,_wrap_CvDTreeParams_use_1se_rule_get,_wrap_CvDTreeParams_use_1se_rule_set,0,0},
+{"truncate_pruned_tree",0,_wrap_CvDTreeParams_truncate_pruned_tree_get,_wrap_CvDTreeParams_truncate_pruned_tree_set,0,0},
+{"regression_accuracy",0,_wrap_CvDTreeParams_regression_accuracy_get,_wrap_CvDTreeParams_regression_accuracy_set,0,0},
+{"priors",0,_wrap_CvDTreeParams_priors_get,_wrap_CvDTreeParams_priors_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvDTreeParams_base_names[] = {0};
+static const swig_type_info *swig_CvDTreeParams_base[] = {0};
+static swig_octave_class _wrap_class_CvDTreeParams = {"CvDTreeParams", &SWIGTYPE_p_CvDTreeParams,0,_wrap_new_CvDTreeParams,0,_wrap_delete_CvDTreeParams,swig_CvDTreeParams_members,swig_CvDTreeParams_base_names,swig_CvDTreeParams_base };
+
+static octave_value_list _wrap_new_CvDTreeTrainData__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeTrainData *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTreeTrainData",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvDTreeTrainData *)new CvDTreeTrainData();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeTrainData, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeTrainData__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvDTreeParams *arg8 = 0 ;
+ bool arg9 ;
+ bool arg10 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 ;
+ int res8 = 0 ;
+ bool val9 ;
+ int ecode9 = 0 ;
+ bool val10 ;
+ int ecode10 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeTrainData *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTreeTrainData",args.length(),10,10,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvDTreeTrainData" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvDTreeTrainData" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvDTreeTrainData" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvDTreeTrainData" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvDTreeTrainData" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvDTreeTrainData" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CvDTreeTrainData" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CvDTreeTrainData" "', argument " "8"" of type '" "CvDTreeParams const &""'");
+ }
+ if (!argp8) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvDTreeTrainData" "', argument " "8"" of type '" "CvDTreeParams const &""'");
+ }
+ arg8 = (CvDTreeParams *)(argp8);
+ ecode9 = SWIG_AsVal_bool(args(8), &val9);
+ if (!SWIG_IsOK(ecode9)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CvDTreeTrainData" "', argument " "9"" of type '" "bool""'");
+ }
+ arg9 = (bool)(val9);
+ ecode10 = SWIG_AsVal_bool(args(9), &val10);
+ if (!SWIG_IsOK(ecode10)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CvDTreeTrainData" "', argument " "10"" of type '" "bool""'");
+ }
+ arg10 = (bool)(val10);
+ {
+ try {
+ result = (CvDTreeTrainData *)new CvDTreeTrainData((CvMat const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvDTreeParams const &)*arg8,arg9,arg10);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeTrainData, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeTrainData__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvDTreeParams *arg8 = 0 ;
+ bool arg9 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 ;
+ int res8 = 0 ;
+ bool val9 ;
+ int ecode9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeTrainData *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTreeTrainData",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvDTreeTrainData" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvDTreeTrainData" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvDTreeTrainData" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvDTreeTrainData" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvDTreeTrainData" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvDTreeTrainData" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CvDTreeTrainData" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CvDTreeTrainData" "', argument " "8"" of type '" "CvDTreeParams const &""'");
+ }
+ if (!argp8) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvDTreeTrainData" "', argument " "8"" of type '" "CvDTreeParams const &""'");
+ }
+ arg8 = (CvDTreeParams *)(argp8);
+ ecode9 = SWIG_AsVal_bool(args(8), &val9);
+ if (!SWIG_IsOK(ecode9)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CvDTreeTrainData" "', argument " "9"" of type '" "bool""'");
+ }
+ arg9 = (bool)(val9);
+ {
+ try {
+ result = (CvDTreeTrainData *)new CvDTreeTrainData((CvMat const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvDTreeParams const &)*arg8,arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeTrainData, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeTrainData__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvDTreeParams *arg8 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 ;
+ int res8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeTrainData *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTreeTrainData",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvDTreeTrainData" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvDTreeTrainData" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvDTreeTrainData" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvDTreeTrainData" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvDTreeTrainData" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvDTreeTrainData" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CvDTreeTrainData" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CvDTreeTrainData" "', argument " "8"" of type '" "CvDTreeParams const &""'");
+ }
+ if (!argp8) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvDTreeTrainData" "', argument " "8"" of type '" "CvDTreeParams const &""'");
+ }
+ arg8 = (CvDTreeParams *)(argp8);
+ {
+ try {
+ result = (CvDTreeTrainData *)new CvDTreeTrainData((CvMat const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvDTreeParams const &)*arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeTrainData, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeTrainData__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeTrainData *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTreeTrainData",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvDTreeTrainData" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvDTreeTrainData" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvDTreeTrainData" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvDTreeTrainData" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvDTreeTrainData" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvDTreeTrainData" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CvDTreeTrainData" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ {
+ try {
+ result = (CvDTreeTrainData *)new CvDTreeTrainData((CvMat const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeTrainData, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeTrainData__SWIG_5 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeTrainData *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTreeTrainData",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvDTreeTrainData" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvDTreeTrainData" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvDTreeTrainData" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvDTreeTrainData" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvDTreeTrainData" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvDTreeTrainData" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ {
+ try {
+ result = (CvDTreeTrainData *)new CvDTreeTrainData((CvMat const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeTrainData, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeTrainData__SWIG_6 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeTrainData *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTreeTrainData",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvDTreeTrainData" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvDTreeTrainData" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvDTreeTrainData" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvDTreeTrainData" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvDTreeTrainData" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (CvDTreeTrainData *)new CvDTreeTrainData((CvMat const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeTrainData, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeTrainData__SWIG_7 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeTrainData *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTreeTrainData",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvDTreeTrainData" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvDTreeTrainData" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvDTreeTrainData" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvDTreeTrainData" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (CvDTreeTrainData *)new CvDTreeTrainData((CvMat const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeTrainData, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeTrainData__SWIG_8 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeTrainData *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTreeTrainData",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvDTreeTrainData" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvDTreeTrainData" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvDTreeTrainData" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (CvDTreeTrainData *)new CvDTreeTrainData((CvMat const *)arg1,arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeTrainData, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvDTreeTrainData (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[10]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8),octave_value_ref(args,9)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvDTreeTrainData__SWIG_0(args, nargout);
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvDTreeTrainData__SWIG_8(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvDTreeTrainData__SWIG_7(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvDTreeTrainData__SWIG_6(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvDTreeTrainData__SWIG_5(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvDTreeTrainData__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 8) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvDTreeTrainData__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 9) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[8], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvDTreeTrainData__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 10) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[8], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[9], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvDTreeTrainData__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_delete_CvDTreeTrainData (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvDTreeTrainData",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvDTreeTrainData" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_set_data__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvDTreeParams *arg9 = 0 ;
+ bool arg10 ;
+ bool arg11 ;
+ bool arg12 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ bool val10 ;
+ int ecode10 = 0 ;
+ bool val11 ;
+ int ecode11 = 0 ;
+ bool val12 ;
+ int ecode12 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_set_data",args.length(),12,12,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_set_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvDTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvDTreeTrainData_set_data" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvDTreeTrainData_set_data" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvDTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ arg9 = (CvDTreeParams *)(argp9);
+ ecode10 = SWIG_AsVal_bool(args(9), &val10);
+ if (!SWIG_IsOK(ecode10)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CvDTreeTrainData_set_data" "', argument " "10"" of type '" "bool""'");
+ }
+ arg10 = (bool)(val10);
+ ecode11 = SWIG_AsVal_bool(args(10), &val11);
+ if (!SWIG_IsOK(ecode11)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "CvDTreeTrainData_set_data" "', argument " "11"" of type '" "bool""'");
+ }
+ arg11 = (bool)(val11);
+ ecode12 = SWIG_AsVal_bool(args(11), &val12);
+ if (!SWIG_IsOK(ecode12)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "CvDTreeTrainData_set_data" "', argument " "12"" of type '" "bool""'");
+ }
+ arg12 = (bool)(val12);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,(CvDTreeParams const &)*arg9,arg10,arg11,arg12);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_set_data__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvDTreeParams *arg9 = 0 ;
+ bool arg10 ;
+ bool arg11 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ bool val10 ;
+ int ecode10 = 0 ;
+ bool val11 ;
+ int ecode11 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_set_data",args.length(),11,11,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_set_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvDTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvDTreeTrainData_set_data" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvDTreeTrainData_set_data" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvDTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ arg9 = (CvDTreeParams *)(argp9);
+ ecode10 = SWIG_AsVal_bool(args(9), &val10);
+ if (!SWIG_IsOK(ecode10)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CvDTreeTrainData_set_data" "', argument " "10"" of type '" "bool""'");
+ }
+ arg10 = (bool)(val10);
+ ecode11 = SWIG_AsVal_bool(args(10), &val11);
+ if (!SWIG_IsOK(ecode11)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "CvDTreeTrainData_set_data" "', argument " "11"" of type '" "bool""'");
+ }
+ arg11 = (bool)(val11);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,(CvDTreeParams const &)*arg9,arg10,arg11);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_set_data__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvDTreeParams *arg9 = 0 ;
+ bool arg10 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ bool val10 ;
+ int ecode10 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_set_data",args.length(),10,10,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_set_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvDTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvDTreeTrainData_set_data" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvDTreeTrainData_set_data" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvDTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ arg9 = (CvDTreeParams *)(argp9);
+ ecode10 = SWIG_AsVal_bool(args(9), &val10);
+ if (!SWIG_IsOK(ecode10)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CvDTreeTrainData_set_data" "', argument " "10"" of type '" "bool""'");
+ }
+ arg10 = (bool)(val10);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,(CvDTreeParams const &)*arg9,arg10);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_set_data__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvDTreeParams *arg9 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_set_data",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_set_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvDTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvDTreeTrainData_set_data" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvDTreeTrainData_set_data" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvDTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ arg9 = (CvDTreeParams *)(argp9);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,(CvDTreeParams const &)*arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_set_data__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_set_data",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_set_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvDTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvDTreeTrainData_set_data" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvDTreeTrainData_set_data" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_set_data__SWIG_5 (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_set_data",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_set_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvDTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvDTreeTrainData_set_data" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_set_data__SWIG_6 (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_set_data",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_set_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvDTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_set_data__SWIG_7 (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_set_data",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_set_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_set_data__SWIG_8 (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_set_data",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_set_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_set_data (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[12]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8),octave_value_ref(args,9),octave_value_ref(args,10),octave_value_ref(args,11)
+ };
+
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTreeTrainData_set_data__SWIG_8(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTreeTrainData_set_data__SWIG_7(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTreeTrainData_set_data__SWIG_6(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTreeTrainData_set_data__SWIG_5(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 8) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTreeTrainData_set_data__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 9) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTreeTrainData_set_data__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 10) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[9], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvDTreeTrainData_set_data__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 11) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[9], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[10], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvDTreeTrainData_set_data__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 12) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[9], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[10], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[11], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvDTreeTrainData_set_data__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_do_responses_copy (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_do_responses_copy",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_do_responses_copy" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ try {
+ (arg1)->do_responses_copy();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_vectors__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ float *arg3 = (float *) 0 ;
+ uchar *arg4 = (uchar *) 0 ;
+ float *arg5 = (float *) 0 ;
+ bool arg6 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ bool val6 ;
+ int ecode6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_vectors",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_vectors" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_get_vectors" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTreeTrainData_get_vectors" "', argument " "3"" of type '" "float *""'");
+ }
+ arg3 = (float *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_get_vectors" "', argument " "4"" of type '" "uchar *""'");
+ }
+ arg4 = (uchar *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTreeTrainData_get_vectors" "', argument " "5"" of type '" "float *""'");
+ }
+ arg5 = (float *)(argp5);
+ ecode6 = SWIG_AsVal_bool(args(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvDTreeTrainData_get_vectors" "', argument " "6"" of type '" "bool""'");
+ }
+ arg6 = (bool)(val6);
+ {
+ try {
+ (arg1)->get_vectors((CvMat const *)arg2,arg3,arg4,arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_vectors__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ float *arg3 = (float *) 0 ;
+ uchar *arg4 = (uchar *) 0 ;
+ float *arg5 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_vectors",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_vectors" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_get_vectors" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTreeTrainData_get_vectors" "', argument " "3"" of type '" "float *""'");
+ }
+ arg3 = (float *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_get_vectors" "', argument " "4"" of type '" "uchar *""'");
+ }
+ arg4 = (uchar *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTreeTrainData_get_vectors" "', argument " "5"" of type '" "float *""'");
+ }
+ arg5 = (float *)(argp5);
+ {
+ try {
+ (arg1)->get_vectors((CvMat const *)arg2,arg3,arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_vectors (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[6]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5)
+ };
+
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTreeTrainData_get_vectors__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[5], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvDTreeTrainData_get_vectors__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_subsample_data (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeNode *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_subsample_data",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_subsample_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_subsample_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ result = (CvDTreeNode *)(arg1)->subsample_data((CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_write_params (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_write_params",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_write_params" "', argument " "1"" of type '" "CvDTreeTrainData const *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_write_params" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ {
+ try {
+ ((CvDTreeTrainData const *)arg1)->write_params(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_read_params (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_read_params",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_read_params" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_read_params" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTreeTrainData_read_params" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ {
+ try {
+ (arg1)->read_params(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_clear (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_clear",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_clear" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ try {
+ (arg1)->clear();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_num_classes (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_num_classes",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_num_classes" "', argument " "1"" of type '" "CvDTreeTrainData const *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ try {
+ result = (int)((CvDTreeTrainData const *)arg1)->get_num_classes();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_var_type (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_var_type",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_var_type" "', argument " "1"" of type '" "CvDTreeTrainData const *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_get_var_type" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ {
+ try {
+ result = (int)((CvDTreeTrainData const *)arg1)->get_var_type(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_work_var_count (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_work_var_count",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_work_var_count" "', argument " "1"" of type '" "CvDTreeTrainData const *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ try {
+ result = (int)((CvDTreeTrainData const *)arg1)->get_work_var_count();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_ord_responses (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ float *arg3 = (float *) 0 ;
+ float **arg4 = (float **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *vptr4 ;
+ float *buffer4 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_ord_responses",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_ord_responses" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_get_ord_responses" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTreeTrainData_get_ord_responses" "', argument " "3"" of type '" "float *""'");
+ }
+ arg3 = (float *)(argp3);
+ {
+ if ((SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer4 = (float *) vptr4;
+ arg4=&buffer4;
+ }
+ {
+ try {
+ (arg1)->get_ord_responses(arg2,arg3,(float const **)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_class_labels (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int **arg4 = (int **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_class_labels",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_class_labels" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_get_class_labels" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTreeTrainData_get_class_labels" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_get_class_labels" "', argument " "4"" of type '" "int const **""'");
+ }
+ arg4 = (int **)(argp4);
+ {
+ try {
+ (arg1)->get_class_labels(arg2,arg3,(int const **)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_cv_labels (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int **arg4 = (int **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_cv_labels",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_cv_labels" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_get_cv_labels" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTreeTrainData_get_cv_labels" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_get_cv_labels" "', argument " "4"" of type '" "int const **""'");
+ }
+ arg4 = (int **)(argp4);
+ {
+ try {
+ (arg1)->get_cv_labels(arg2,arg3,(int const **)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_sample_indices (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int **arg4 = (int **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_sample_indices",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_sample_indices" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_get_sample_indices" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTreeTrainData_get_sample_indices" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_get_sample_indices" "', argument " "4"" of type '" "int const **""'");
+ }
+ arg4 = (int **)(argp4);
+ {
+ try {
+ (arg1)->get_sample_indices(arg2,arg3,(int const **)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_cat_var_data (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ int arg3 ;
+ int *arg4 = (int *) 0 ;
+ int **arg5 = (int **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_cat_var_data",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_cat_var_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_get_cat_var_data" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_get_cat_var_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_get_cat_var_data" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTreeTrainData_get_cat_var_data" "', argument " "5"" of type '" "int const **""'");
+ }
+ arg5 = (int **)(argp5);
+ {
+ try {
+ result = (int)(arg1)->get_cat_var_data(arg2,arg3,arg4,(int const **)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_ord_var_data (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ int arg3 ;
+ float *arg4 = (float *) 0 ;
+ int *arg5 = (int *) 0 ;
+ float **arg6 = (float **) 0 ;
+ int **arg7 = (int **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *vptr6 ;
+ float *buffer6 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_ord_var_data",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_ord_var_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_get_ord_var_data" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_get_ord_var_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTreeTrainData_get_ord_var_data" "', argument " "4"" of type '" "float *""'");
+ }
+ arg4 = (float *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTreeTrainData_get_ord_var_data" "', argument " "5"" of type '" "int *""'");
+ }
+ arg5 = (int *)(argp5);
+ {
+ if ((SWIG_ConvertPtr(args(5), &vptr6, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer6 = (float *) vptr6;
+ arg6=&buffer6;
+ }
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvDTreeTrainData_get_ord_var_data" "', argument " "7"" of type '" "int const **""'");
+ }
+ arg7 = (int **)(argp7);
+ {
+ try {
+ result = (int)(arg1)->get_ord_var_data(arg2,arg3,arg4,arg5,(float const **)arg6,(int const **)arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_child_buf_idx (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_child_buf_idx",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_child_buf_idx" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_get_child_buf_idx" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ {
+ try {
+ result = (int)(arg1)->get_child_buf_idx(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_set_params (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvDTreeParams *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_set_params",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_set_params" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_set_params" "', argument " "2"" of type '" "CvDTreeParams const &""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDTreeTrainData_set_params" "', argument " "2"" of type '" "CvDTreeParams const &""'");
+ }
+ arg2 = (CvDTreeParams *)(argp2);
+ {
+ try {
+ result = (bool)(arg1)->set_params((CvDTreeParams const &)*arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_new_node (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ int arg3 ;
+ int arg4 ;
+ int arg5 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeNode *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_new_node",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_new_node" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_new_node" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_new_node" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvDTreeTrainData_new_node" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvDTreeTrainData_new_node" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ {
+ try {
+ result = (CvDTreeNode *)(arg1)->new_node(arg2,arg3,arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_new_split_ord (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ float arg3 ;
+ int arg4 ;
+ int arg5 ;
+ float arg6 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ float val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ float val6 ;
+ int ecode6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeSplit *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_new_split_ord",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_new_split_ord" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_new_split_ord" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_float(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_new_split_ord" "', argument " "3"" of type '" "float""'");
+ }
+ arg3 = (float)(val3);
+ ecode4 = SWIG_AsVal_int(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvDTreeTrainData_new_split_ord" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvDTreeTrainData_new_split_ord" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ ecode6 = SWIG_AsVal_float(args(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvDTreeTrainData_new_split_ord" "', argument " "6"" of type '" "float""'");
+ }
+ arg6 = (float)(val6);
+ {
+ try {
+ result = (CvDTreeSplit *)(arg1)->new_split_ord(arg2,arg3,arg4,arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_new_split_cat (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ float arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ float val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeSplit *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_new_split_cat",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_new_split_cat" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_new_split_cat" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_float(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTreeTrainData_new_split_cat" "', argument " "3"" of type '" "float""'");
+ }
+ arg3 = (float)(val3);
+ {
+ try {
+ result = (CvDTreeSplit *)(arg1)->new_split_cat(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeSplit, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_free_node_data (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_free_node_data",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_free_node_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_free_node_data" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ {
+ try {
+ (arg1)->free_node_data(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_free_train_data (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_free_train_data",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_free_train_data" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ try {
+ (arg1)->free_train_data();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_free_node (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_free_node",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_free_node" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_free_node" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ {
+ try {
+ (arg1)->free_node(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_pred_float_buf (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_pred_float_buf",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_pred_float_buf" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ try {
+ result = (float *)(arg1)->get_pred_float_buf();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_pred_int_buf (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_pred_int_buf",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_pred_int_buf" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ try {
+ result = (int *)(arg1)->get_pred_int_buf();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_resp_float_buf (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_resp_float_buf",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_resp_float_buf" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ try {
+ result = (float *)(arg1)->get_resp_float_buf();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_resp_int_buf (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_resp_int_buf",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_resp_int_buf" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ try {
+ result = (int *)(arg1)->get_resp_int_buf();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_cv_lables_buf (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_cv_lables_buf",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_cv_lables_buf" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ try {
+ result = (int *)(arg1)->get_cv_lables_buf();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_get_sample_idx_buf (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_get_sample_idx_buf",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_get_sample_idx_buf" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ try {
+ result = (int *)(arg1)->get_sample_idx_buf();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_pred_float_buf_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ vector< vector< float > > arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_pred_float_buf_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_pred_float_buf_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_vectorT_vectorT_float_t_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_pred_float_buf_set" "', argument " "2"" of type '" "vector< vector< float > >""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDTreeTrainData_pred_float_buf_set" "', argument " "2"" of type '" "vector< vector< float > >""'");
+ } else {
+ arg2 = *((vector< vector< float > > *)(argp2));
+ }
+ }
+ if (arg1) (arg1)->pred_float_buf = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_pred_float_buf_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ vector< vector< float > > result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_pred_float_buf_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_pred_float_buf_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = ((arg1)->pred_float_buf);
+ _outv = SWIG_NewPointerObj((new vector< vector< float > >((const vector< vector< float > >&)(result))), SWIGTYPE_p_vectorT_vectorT_float_t_t, SWIG_POINTER_OWN | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_pred_int_buf_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ vector< vector< int > > arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_pred_int_buf_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_pred_int_buf_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_vectorT_vectorT_int_t_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_pred_int_buf_set" "', argument " "2"" of type '" "vector< vector< int > >""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDTreeTrainData_pred_int_buf_set" "', argument " "2"" of type '" "vector< vector< int > >""'");
+ } else {
+ arg2 = *((vector< vector< int > > *)(argp2));
+ }
+ }
+ if (arg1) (arg1)->pred_int_buf = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_pred_int_buf_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ vector< vector< int > > result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_pred_int_buf_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_pred_int_buf_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = ((arg1)->pred_int_buf);
+ _outv = SWIG_NewPointerObj((new vector< vector< int > >((const vector< vector< int > >&)(result))), SWIGTYPE_p_vectorT_vectorT_int_t_t, SWIG_POINTER_OWN | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_resp_float_buf_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ vector< vector< float > > arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_resp_float_buf_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_resp_float_buf_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_vectorT_vectorT_float_t_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_resp_float_buf_set" "', argument " "2"" of type '" "vector< vector< float > >""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDTreeTrainData_resp_float_buf_set" "', argument " "2"" of type '" "vector< vector< float > >""'");
+ } else {
+ arg2 = *((vector< vector< float > > *)(argp2));
+ }
+ }
+ if (arg1) (arg1)->resp_float_buf = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_resp_float_buf_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ vector< vector< float > > result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_resp_float_buf_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_resp_float_buf_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = ((arg1)->resp_float_buf);
+ _outv = SWIG_NewPointerObj((new vector< vector< float > >((const vector< vector< float > >&)(result))), SWIGTYPE_p_vectorT_vectorT_float_t_t, SWIG_POINTER_OWN | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_resp_int_buf_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ vector< vector< int > > arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_resp_int_buf_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_resp_int_buf_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_vectorT_vectorT_int_t_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_resp_int_buf_set" "', argument " "2"" of type '" "vector< vector< int > >""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDTreeTrainData_resp_int_buf_set" "', argument " "2"" of type '" "vector< vector< int > >""'");
+ } else {
+ arg2 = *((vector< vector< int > > *)(argp2));
+ }
+ }
+ if (arg1) (arg1)->resp_int_buf = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_resp_int_buf_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ vector< vector< int > > result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_resp_int_buf_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_resp_int_buf_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = ((arg1)->resp_int_buf);
+ _outv = SWIG_NewPointerObj((new vector< vector< int > >((const vector< vector< int > >&)(result))), SWIGTYPE_p_vectorT_vectorT_int_t_t, SWIG_POINTER_OWN | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_cv_lables_buf_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ vector< vector< int > > arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_cv_lables_buf_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_cv_lables_buf_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_vectorT_vectorT_int_t_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_cv_lables_buf_set" "', argument " "2"" of type '" "vector< vector< int > >""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDTreeTrainData_cv_lables_buf_set" "', argument " "2"" of type '" "vector< vector< int > >""'");
+ } else {
+ arg2 = *((vector< vector< int > > *)(argp2));
+ }
+ }
+ if (arg1) (arg1)->cv_lables_buf = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_cv_lables_buf_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ vector< vector< int > > result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_cv_lables_buf_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_cv_lables_buf_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = ((arg1)->cv_lables_buf);
+ _outv = SWIG_NewPointerObj((new vector< vector< int > >((const vector< vector< int > >&)(result))), SWIGTYPE_p_vectorT_vectorT_int_t_t, SWIG_POINTER_OWN | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_sample_idx_buf_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ vector< vector< int > > arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_sample_idx_buf_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_sample_idx_buf_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_vectorT_vectorT_int_t_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_sample_idx_buf_set" "', argument " "2"" of type '" "vector< vector< int > >""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDTreeTrainData_sample_idx_buf_set" "', argument " "2"" of type '" "vector< vector< int > >""'");
+ } else {
+ arg2 = *((vector< vector< int > > *)(argp2));
+ }
+ }
+ if (arg1) (arg1)->sample_idx_buf = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_sample_idx_buf_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ vector< vector< int > > result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_sample_idx_buf_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_sample_idx_buf_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = ((arg1)->sample_idx_buf);
+ _outv = SWIG_NewPointerObj((new vector< vector< int > >((const vector< vector< int > >&)(result))), SWIGTYPE_p_vectorT_vectorT_int_t_t, SWIG_POINTER_OWN | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_sample_count_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_sample_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_sample_count_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_sample_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->sample_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_sample_count_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_sample_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_sample_count_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (int) ((arg1)->sample_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_var_all_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_var_all_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_var_all_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_var_all_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->var_all = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_var_all_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_var_all_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_var_all_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (int) ((arg1)->var_all);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_var_count_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_var_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_var_count_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_var_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->var_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_var_count_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_var_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_var_count_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (int) ((arg1)->var_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_max_c_count_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_max_c_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_max_c_count_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_max_c_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->max_c_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_max_c_count_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_max_c_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_max_c_count_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (int) ((arg1)->max_c_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_ord_var_count_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_ord_var_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_ord_var_count_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_ord_var_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->ord_var_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_ord_var_count_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_ord_var_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_ord_var_count_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (int) ((arg1)->ord_var_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_cat_var_count_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_cat_var_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_cat_var_count_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_cat_var_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->cat_var_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_cat_var_count_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_cat_var_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_cat_var_count_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (int) ((arg1)->cat_var_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_work_var_count_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_work_var_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_work_var_count_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_work_var_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->work_var_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_work_var_count_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_work_var_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_work_var_count_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (int) ((arg1)->work_var_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_have_labels_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_have_labels_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_have_labels_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_bool(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_have_labels_set" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = (bool)(val2);
+ if (arg1) (arg1)->have_labels = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_have_labels_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_have_labels_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_have_labels_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (bool) ((arg1)->have_labels);
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_have_priors_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_have_priors_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_have_priors_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_bool(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_have_priors_set" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = (bool)(val2);
+ if (arg1) (arg1)->have_priors = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_have_priors_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_have_priors_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_have_priors_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (bool) ((arg1)->have_priors);
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_is_classifier_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_is_classifier_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_is_classifier_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_bool(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_is_classifier_set" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = (bool)(val2);
+ if (arg1) (arg1)->is_classifier = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_is_classifier_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_is_classifier_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_is_classifier_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (bool) ((arg1)->is_classifier);
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_tflag_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_tflag_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_tflag_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_tflag_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->tflag = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_tflag_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_tflag_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_tflag_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (int) ((arg1)->tflag);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_train_data_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_train_data_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_train_data_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_train_data_set" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->train_data = (CvMat const *)arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_train_data_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_train_data_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_train_data_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->train_data);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_responses_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_responses_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_responses_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_responses_set" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->responses = (CvMat const *)arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_responses_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_responses_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_responses_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->responses);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_responses_copy_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_responses_copy_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_responses_copy_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_responses_copy_set" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->responses_copy = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_responses_copy_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_responses_copy_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_responses_copy_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->responses_copy);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_buf_count_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_buf_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_buf_count_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_buf_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->buf_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_buf_count_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_buf_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_buf_count_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (int) ((arg1)->buf_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_buf_size_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_buf_size_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_buf_size_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_buf_size_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->buf_size = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_buf_size_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_buf_size_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_buf_size_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (int) ((arg1)->buf_size);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_shared_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_shared_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_shared_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_bool(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_shared_set" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = (bool)(val2);
+ if (arg1) (arg1)->shared = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_shared_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_shared_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_shared_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (bool) ((arg1)->shared);
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_is_buf_16u_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_is_buf_16u_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_is_buf_16u_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTreeTrainData_is_buf_16u_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->is_buf_16u = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_is_buf_16u_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_is_buf_16u_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_is_buf_16u_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (int) ((arg1)->is_buf_16u);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_cat_count_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_cat_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_cat_count_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_cat_count_set" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->cat_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_cat_count_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_cat_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_cat_count_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->cat_count);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_cat_ofs_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_cat_ofs_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_cat_ofs_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_cat_ofs_set" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->cat_ofs = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_cat_ofs_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_cat_ofs_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_cat_ofs_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->cat_ofs);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_cat_map_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_cat_map_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_cat_map_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_cat_map_set" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->cat_map = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_cat_map_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_cat_map_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_cat_map_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->cat_map);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_counts_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_counts_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_counts_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_counts_set" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->counts = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_counts_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_counts_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_counts_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->counts);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_buf_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_buf_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_buf_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_buf_set" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->buf = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_buf_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_buf_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_buf_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->buf);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_direction_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_direction_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_direction_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_direction_set" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->direction = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_direction_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_direction_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_direction_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->direction);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_split_buf_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_split_buf_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_split_buf_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_split_buf_set" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->split_buf = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_split_buf_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_split_buf_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_split_buf_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->split_buf);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_var_idx_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_var_idx_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_var_idx_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_var_idx_set" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->var_idx = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_var_idx_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_var_idx_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_var_idx_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->var_idx);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_var_type_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_var_type_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_var_type_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_var_type_set" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->var_type = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_var_type_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_var_type_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_var_type_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->var_type);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_priors_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_priors_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_priors_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_priors_set" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->priors = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_priors_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_priors_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_priors_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->priors);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_priors_mult_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_priors_mult_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_priors_mult_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_priors_mult_set" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->priors_mult = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_priors_mult_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_priors_mult_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_priors_mult_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->priors_mult);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_params_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvDTreeParams *arg2 = (CvDTreeParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_params_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_params_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_params_set" "', argument " "2"" of type '" "CvDTreeParams *""'");
+ }
+ arg2 = (CvDTreeParams *)(argp2);
+ if (arg1) (arg1)->params = *arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_params_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeParams *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_params_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_params_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvDTreeParams *)& ((arg1)->params);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeParams, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_tree_storage_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMemStorage *arg2 = (CvMemStorage *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_tree_storage_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_tree_storage_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMemStorage, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_tree_storage_set" "', argument " "2"" of type '" "CvMemStorage *""'");
+ }
+ arg2 = (CvMemStorage *)(argp2);
+ if (arg1) (arg1)->tree_storage = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_tree_storage_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMemStorage *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_tree_storage_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_tree_storage_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMemStorage *) ((arg1)->tree_storage);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStorage, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_temp_storage_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvMemStorage *arg2 = (CvMemStorage *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_temp_storage_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_temp_storage_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMemStorage, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_temp_storage_set" "', argument " "2"" of type '" "CvMemStorage *""'");
+ }
+ arg2 = (CvMemStorage *)(argp2);
+ if (arg1) (arg1)->temp_storage = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_temp_storage_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMemStorage *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_temp_storage_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_temp_storage_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvMemStorage *) ((arg1)->temp_storage);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStorage, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_data_root_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_data_root_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_data_root_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTreeTrainData_data_root_set" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ if (arg1) (arg1)->data_root = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_data_root_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeNode *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_data_root_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_data_root_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvDTreeNode *) ((arg1)->data_root);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_node_heap_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvSet *arg2 = (CvSet *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *ptr2 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_node_heap_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_node_heap_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
+ SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
+ SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
+ {
+ SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
+ SWIG_fail;
+ }
+ arg2 = (CvSet *)ptr2;
+ }
+ if (arg1) (arg1)->node_heap = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_node_heap_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSet *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_node_heap_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_node_heap_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvSet *) ((arg1)->node_heap);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSet, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_split_heap_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvSet *arg2 = (CvSet *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *ptr2 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_split_heap_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_split_heap_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
+ SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
+ SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
+ {
+ SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
+ SWIG_fail;
+ }
+ arg2 = (CvSet *)ptr2;
+ }
+ if (arg1) (arg1)->split_heap = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_split_heap_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSet *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_split_heap_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_split_heap_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvSet *) ((arg1)->split_heap);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSet, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_cv_heap_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvSet *arg2 = (CvSet *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *ptr2 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_cv_heap_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_cv_heap_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
+ SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
+ SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
+ {
+ SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
+ SWIG_fail;
+ }
+ arg2 = (CvSet *)ptr2;
+ }
+ if (arg1) (arg1)->cv_heap = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_cv_heap_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSet *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_cv_heap_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_cv_heap_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvSet *) ((arg1)->cv_heap);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSet, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_nv_heap_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvSet *arg2 = (CvSet *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *ptr2 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_nv_heap_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_nv_heap_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSet, 0) == -1 &&
+ SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvGraph, 0) == -1 &&
+ SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSubdiv2D, 0) == -1)
+ {
+ SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
+ SWIG_fail;
+ }
+ arg2 = (CvSet *)ptr2;
+ }
+ if (arg1) (arg1)->nv_heap = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_nv_heap_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSet *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_nv_heap_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_nv_heap_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = (CvSet *) ((arg1)->nv_heap);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSet, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_rng_set (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ CvRNG arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *vptr2 ;
+ CvRNG_Wrapper *wrapper2 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_rng_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_rng_set" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ {
+ if(SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_CvRNG_Wrapper, 0)==-1){
+ SWIG_exception( SWIG_TypeError, "could not convert Octave object to C value");
+ SWIG_fail;
+ }
+ wrapper2 = (CvRNG_Wrapper *) vptr2;
+ arg2 = wrapper2->ref();
+ }
+ if (arg1) (arg1)->rng = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTreeTrainData_rng_get (const octave_value_list& args, int nargout) {
+ CvDTreeTrainData *arg1 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvRNG result;
+
+ if (!SWIG_check_num_args("CvDTreeTrainData_rng_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTreeTrainData_rng_get" "', argument " "1"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg1 = (CvDTreeTrainData *)(argp1);
+ result = ((arg1)->rng);
+ {
+ CvRNG_Wrapper * wrapper = new CvRNG_Wrapper( result );
+ _outv = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvRNG_Wrapper, 1 );
+ }
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvDTreeTrainData_members[] = {
+{"set_data",_wrap_CvDTreeTrainData_set_data,0,0,0,0},
+{"do_responses_copy",_wrap_CvDTreeTrainData_do_responses_copy,0,0,0,0},
+{"get_vectors",_wrap_CvDTreeTrainData_get_vectors,0,0,0,0},
+{"subsample_data",_wrap_CvDTreeTrainData_subsample_data,0,0,0,0},
+{"write_params",_wrap_CvDTreeTrainData_write_params,0,0,0,0},
+{"read_params",_wrap_CvDTreeTrainData_read_params,0,0,0,0},
+{"clear",_wrap_CvDTreeTrainData_clear,0,0,0,0},
+{"get_num_classes",_wrap_CvDTreeTrainData_get_num_classes,0,0,0,0},
+{"get_var_type",_wrap_CvDTreeTrainData_get_var_type,0,0,0,0},
+{"get_work_var_count",_wrap_CvDTreeTrainData_get_work_var_count,0,0,0,0},
+{"get_ord_responses",_wrap_CvDTreeTrainData_get_ord_responses,0,0,0,0},
+{"get_class_labels",_wrap_CvDTreeTrainData_get_class_labels,0,0,0,0},
+{"get_cv_labels",_wrap_CvDTreeTrainData_get_cv_labels,0,0,0,0},
+{"get_sample_indices",_wrap_CvDTreeTrainData_get_sample_indices,0,0,0,0},
+{"get_cat_var_data",_wrap_CvDTreeTrainData_get_cat_var_data,0,0,0,0},
+{"get_ord_var_data",_wrap_CvDTreeTrainData_get_ord_var_data,0,0,0,0},
+{"get_child_buf_idx",_wrap_CvDTreeTrainData_get_child_buf_idx,0,0,0,0},
+{"set_params",_wrap_CvDTreeTrainData_set_params,0,0,0,0},
+{"new_node",_wrap_CvDTreeTrainData_new_node,0,0,0,0},
+{"new_split_ord",_wrap_CvDTreeTrainData_new_split_ord,0,0,0,0},
+{"new_split_cat",_wrap_CvDTreeTrainData_new_split_cat,0,0,0,0},
+{"free_node_data",_wrap_CvDTreeTrainData_free_node_data,0,0,0,0},
+{"free_train_data",_wrap_CvDTreeTrainData_free_train_data,0,0,0,0},
+{"free_node",_wrap_CvDTreeTrainData_free_node,0,0,0,0},
+{"get_pred_float_buf",_wrap_CvDTreeTrainData_get_pred_float_buf,0,0,0,0},
+{"get_pred_int_buf",_wrap_CvDTreeTrainData_get_pred_int_buf,0,0,0,0},
+{"get_resp_float_buf",_wrap_CvDTreeTrainData_get_resp_float_buf,0,0,0,0},
+{"get_resp_int_buf",_wrap_CvDTreeTrainData_get_resp_int_buf,0,0,0,0},
+{"get_cv_lables_buf",_wrap_CvDTreeTrainData_get_cv_lables_buf,0,0,0,0},
+{"get_sample_idx_buf",_wrap_CvDTreeTrainData_get_sample_idx_buf,0,0,0,0},
+{"pred_float_buf",0,_wrap_CvDTreeTrainData_pred_float_buf_get,_wrap_CvDTreeTrainData_pred_float_buf_set,0,0},
+{"pred_int_buf",0,_wrap_CvDTreeTrainData_pred_int_buf_get,_wrap_CvDTreeTrainData_pred_int_buf_set,0,0},
+{"resp_float_buf",0,_wrap_CvDTreeTrainData_resp_float_buf_get,_wrap_CvDTreeTrainData_resp_float_buf_set,0,0},
+{"resp_int_buf",0,_wrap_CvDTreeTrainData_resp_int_buf_get,_wrap_CvDTreeTrainData_resp_int_buf_set,0,0},
+{"cv_lables_buf",0,_wrap_CvDTreeTrainData_cv_lables_buf_get,_wrap_CvDTreeTrainData_cv_lables_buf_set,0,0},
+{"sample_idx_buf",0,_wrap_CvDTreeTrainData_sample_idx_buf_get,_wrap_CvDTreeTrainData_sample_idx_buf_set,0,0},
+{"sample_count",0,_wrap_CvDTreeTrainData_sample_count_get,_wrap_CvDTreeTrainData_sample_count_set,0,0},
+{"var_all",0,_wrap_CvDTreeTrainData_var_all_get,_wrap_CvDTreeTrainData_var_all_set,0,0},
+{"var_count",0,_wrap_CvDTreeTrainData_var_count_get,_wrap_CvDTreeTrainData_var_count_set,0,0},
+{"max_c_count",0,_wrap_CvDTreeTrainData_max_c_count_get,_wrap_CvDTreeTrainData_max_c_count_set,0,0},
+{"ord_var_count",0,_wrap_CvDTreeTrainData_ord_var_count_get,_wrap_CvDTreeTrainData_ord_var_count_set,0,0},
+{"cat_var_count",0,_wrap_CvDTreeTrainData_cat_var_count_get,_wrap_CvDTreeTrainData_cat_var_count_set,0,0},
+{"work_var_count",0,_wrap_CvDTreeTrainData_work_var_count_get,_wrap_CvDTreeTrainData_work_var_count_set,0,0},
+{"have_labels",0,_wrap_CvDTreeTrainData_have_labels_get,_wrap_CvDTreeTrainData_have_labels_set,0,0},
+{"have_priors",0,_wrap_CvDTreeTrainData_have_priors_get,_wrap_CvDTreeTrainData_have_priors_set,0,0},
+{"is_classifier",0,_wrap_CvDTreeTrainData_is_classifier_get,_wrap_CvDTreeTrainData_is_classifier_set,0,0},
+{"tflag",0,_wrap_CvDTreeTrainData_tflag_get,_wrap_CvDTreeTrainData_tflag_set,0,0},
+{"train_data",0,_wrap_CvDTreeTrainData_train_data_get,_wrap_CvDTreeTrainData_train_data_set,0,0},
+{"responses",0,_wrap_CvDTreeTrainData_responses_get,_wrap_CvDTreeTrainData_responses_set,0,0},
+{"responses_copy",0,_wrap_CvDTreeTrainData_responses_copy_get,_wrap_CvDTreeTrainData_responses_copy_set,0,0},
+{"buf_count",0,_wrap_CvDTreeTrainData_buf_count_get,_wrap_CvDTreeTrainData_buf_count_set,0,0},
+{"buf_size",0,_wrap_CvDTreeTrainData_buf_size_get,_wrap_CvDTreeTrainData_buf_size_set,0,0},
+{"shared",0,_wrap_CvDTreeTrainData_shared_get,_wrap_CvDTreeTrainData_shared_set,0,0},
+{"is_buf_16u",0,_wrap_CvDTreeTrainData_is_buf_16u_get,_wrap_CvDTreeTrainData_is_buf_16u_set,0,0},
+{"cat_count",0,_wrap_CvDTreeTrainData_cat_count_get,_wrap_CvDTreeTrainData_cat_count_set,0,0},
+{"cat_ofs",0,_wrap_CvDTreeTrainData_cat_ofs_get,_wrap_CvDTreeTrainData_cat_ofs_set,0,0},
+{"cat_map",0,_wrap_CvDTreeTrainData_cat_map_get,_wrap_CvDTreeTrainData_cat_map_set,0,0},
+{"counts",0,_wrap_CvDTreeTrainData_counts_get,_wrap_CvDTreeTrainData_counts_set,0,0},
+{"buf",0,_wrap_CvDTreeTrainData_buf_get,_wrap_CvDTreeTrainData_buf_set,0,0},
+{"direction",0,_wrap_CvDTreeTrainData_direction_get,_wrap_CvDTreeTrainData_direction_set,0,0},
+{"split_buf",0,_wrap_CvDTreeTrainData_split_buf_get,_wrap_CvDTreeTrainData_split_buf_set,0,0},
+{"var_idx",0,_wrap_CvDTreeTrainData_var_idx_get,_wrap_CvDTreeTrainData_var_idx_set,0,0},
+{"var_type",0,_wrap_CvDTreeTrainData_var_type_get,_wrap_CvDTreeTrainData_var_type_set,0,0},
+{"priors",0,_wrap_CvDTreeTrainData_priors_get,_wrap_CvDTreeTrainData_priors_set,0,0},
+{"priors_mult",0,_wrap_CvDTreeTrainData_priors_mult_get,_wrap_CvDTreeTrainData_priors_mult_set,0,0},
+{"params",0,_wrap_CvDTreeTrainData_params_get,_wrap_CvDTreeTrainData_params_set,0,0},
+{"tree_storage",0,_wrap_CvDTreeTrainData_tree_storage_get,_wrap_CvDTreeTrainData_tree_storage_set,0,0},
+{"temp_storage",0,_wrap_CvDTreeTrainData_temp_storage_get,_wrap_CvDTreeTrainData_temp_storage_set,0,0},
+{"data_root",0,_wrap_CvDTreeTrainData_data_root_get,_wrap_CvDTreeTrainData_data_root_set,0,0},
+{"node_heap",0,_wrap_CvDTreeTrainData_node_heap_get,_wrap_CvDTreeTrainData_node_heap_set,0,0},
+{"split_heap",0,_wrap_CvDTreeTrainData_split_heap_get,_wrap_CvDTreeTrainData_split_heap_set,0,0},
+{"cv_heap",0,_wrap_CvDTreeTrainData_cv_heap_get,_wrap_CvDTreeTrainData_cv_heap_set,0,0},
+{"nv_heap",0,_wrap_CvDTreeTrainData_nv_heap_get,_wrap_CvDTreeTrainData_nv_heap_set,0,0},
+{"rng",0,_wrap_CvDTreeTrainData_rng_get,_wrap_CvDTreeTrainData_rng_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvDTreeTrainData_base_names[] = {0};
+static const swig_type_info *swig_CvDTreeTrainData_base[] = {0};
+static swig_octave_class _wrap_class_CvDTreeTrainData = {"CvDTreeTrainData", &SWIGTYPE_p_CvDTreeTrainData,0,_wrap_new_CvDTreeTrainData,0,_wrap_delete_CvDTreeTrainData,swig_CvDTreeTrainData_members,swig_CvDTreeTrainData_base_names,swig_CvDTreeTrainData_base };
+
+static octave_value_list _wrap_new_CvDTree (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTree *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvDTree",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvDTree *)new CvDTree();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTree, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvDTree (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvDTree",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvDTree" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_train__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvDTreeParams arg9 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTree_train",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_train" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvDTree_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvDTree_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvDTree_train" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvDTree_train" "', argument " "9"" of type '" "CvDTreeParams""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDTree_train" "', argument " "9"" of type '" "CvDTreeParams""'");
+ } else {
+ arg9 = *((CvDTreeParams *)(argp9));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_train__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTree_train",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_train" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvDTree_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvDTree_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvDTree_train" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_train__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTree_train",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_train" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvDTree_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvDTree_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_train__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTree_train",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_train" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvDTree_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_train__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTree_train",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_train" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvDTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_train__SWIG_5 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTree_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_train" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_train__SWIG_6 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ CvDTreeParams arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTree_train",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_train" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_train" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ {
+ res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTree_train" "', argument " "3"" of type '" "CvDTreeParams""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvDTree_train" "', argument " "3"" of type '" "CvDTreeParams""'");
+ } else {
+ arg3 = *((CvDTreeParams *)(argp3));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_train__SWIG_7 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTree_train",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_train" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_train" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ {
+ try {
+ result = (bool)(arg1)->train(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_calc_error__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ int arg3 ;
+ vector< float > *arg4 = (vector< float > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvDTree_calc_error",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_calc_error" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_calc_error" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTree_calc_error" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_vectorT_float_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTree_calc_error" "', argument " "4"" of type '" "vector< float > *""'");
+ }
+ arg4 = (vector< float > *)(argp4);
+ {
+ try {
+ result = (float)(arg1)->calc_error(arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_calc_error__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ int arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvDTree_calc_error",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_calc_error" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_calc_error" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvDTree_calc_error" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ try {
+ result = (float)(arg1)->calc_error(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_calc_error (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[4]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3)
+ };
+
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvDTree_calc_error__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_vectorT_float_t, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_calc_error__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvDTree_train__SWIG_8 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvDTreeTrainData *arg2 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvDTree_train",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_train" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_train" "', argument " "2"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg2 = (CvDTreeTrainData *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTree_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (bool)(arg1)->train(arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_train (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[9]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_train__SWIG_7(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_train__SWIG_6(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_train__SWIG_8(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_train__SWIG_5(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_train__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_train__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_train__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 8) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_train__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 9) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_train__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvDTree_predict__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ bool arg4 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ bool val4 ;
+ int ecode4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeNode *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTree_predict",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_predict" "', argument " "1"" of type '" "CvDTree const *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTree_predict" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ ecode4 = SWIG_AsVal_bool(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvDTree_predict" "', argument " "4"" of type '" "bool""'");
+ }
+ arg4 = (bool)(val4);
+ {
+ try {
+ result = (CvDTreeNode *)((CvDTree const *)arg1)->predict((CvMat const *)arg2,(CvMat const *)arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_predict__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeNode *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTree_predict",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_predict" "', argument " "1"" of type '" "CvDTree const *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTree_predict" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (CvDTreeNode *)((CvDTree const *)arg1)->predict((CvMat const *)arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_predict__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeNode *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTree_predict",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_predict" "', argument " "1"" of type '" "CvDTree const *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ result = (CvDTreeNode *)((CvDTree const *)arg1)->predict((CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_predict (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[4]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_predict__SWIG_2(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_predict__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[3], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvDTree_predict__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvDTree_get_var_importance (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTree_get_var_importance",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_get_var_importance" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_var_importance();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_clear (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTree_clear",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_clear" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ {
+ try {
+ (arg1)->clear();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_read__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTree_read",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_read" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTree_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ {
+ try {
+ (arg1)->read(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_write__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ char *arg3 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTree_write",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_write" "', argument " "1"" of type '" "CvDTree const *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_write" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTree_write" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ {
+ try {
+ ((CvDTree const *)arg1)->write(arg2,(char const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_read__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ CvDTreeTrainData *arg4 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTree_read",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_read" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvDTree_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvDTree_read" "', argument " "4"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg4 = (CvDTreeTrainData *)(argp4);
+ {
+ try {
+ (arg1)->read(arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_read (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[4]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3)
+ };
+
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvFileNode, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_read__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvFileNode, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_read__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvDTree_write__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTree_write",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_write" "', argument " "1"" of type '" "CvDTree const *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvDTree_write" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ {
+ try {
+ ((CvDTree const *)arg1)->write(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_write (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[3]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_write__SWIG_1(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvDTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvDTree_write__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvDTree_get_root (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeNode *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTree_get_root",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_get_root" "', argument " "1"" of type '" "CvDTree const *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ {
+ try {
+ result = (CvDTreeNode *)((CvDTree const *)arg1)->get_root();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_get_pruned_tree_idx (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTree_get_pruned_tree_idx",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_get_pruned_tree_idx" "', argument " "1"" of type '" "CvDTree const *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ {
+ try {
+ result = (int)((CvDTree const *)arg1)->get_pruned_tree_idx();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_get_data (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeTrainData *result = 0 ;
+
+ if (!SWIG_check_num_args("CvDTree_get_data",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_get_data" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ {
+ try {
+ result = (CvDTreeTrainData *)(arg1)->get_data();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_pruned_tree_idx_set (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvDTree_pruned_tree_idx_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_pruned_tree_idx_set" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvDTree_pruned_tree_idx_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->pruned_tree_idx = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvDTree_pruned_tree_idx_get (const octave_value_list& args, int nargout) {
+ CvDTree *arg1 = (CvDTree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvDTree_pruned_tree_idx_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvDTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvDTree_pruned_tree_idx_get" "', argument " "1"" of type '" "CvDTree *""'");
+ }
+ arg1 = (CvDTree *)(argp1);
+ result = (int) ((arg1)->pruned_tree_idx);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvDTree_members[] = {
+{"calc_error",_wrap_CvDTree_calc_error,0,0,0,0},
+{"train",_wrap_CvDTree_train,0,0,0,0},
+{"predict",_wrap_CvDTree_predict,0,0,0,0},
+{"get_var_importance",_wrap_CvDTree_get_var_importance,0,0,0,0},
+{"clear",_wrap_CvDTree_clear,0,0,0,0},
+{"read",_wrap_CvDTree_read,0,0,0,0},
+{"write",_wrap_CvDTree_write,0,0,0,0},
+{"get_root",_wrap_CvDTree_get_root,0,0,0,0},
+{"get_pruned_tree_idx",_wrap_CvDTree_get_pruned_tree_idx,0,0,0,0},
+{"get_data",_wrap_CvDTree_get_data,0,0,0,0},
+{"pruned_tree_idx",0,_wrap_CvDTree_pruned_tree_idx_get,_wrap_CvDTree_pruned_tree_idx_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvDTree_base_names[] = {"_p_CvStatModel",0};
+static const swig_type_info *swig_CvDTree_base[] = {0,0};
+static swig_octave_class _wrap_class_CvDTree = {"CvDTree", &SWIGTYPE_p_CvDTree,0,_wrap_new_CvDTree,0,_wrap_delete_CvDTree,swig_CvDTree_members,swig_CvDTree_base_names,swig_CvDTree_base };
+
+static octave_value_list _wrap_new_CvForestTree (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvForestTree *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvForestTree",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvForestTree *)new CvForestTree();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvForestTree, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvForestTree (const octave_value_list& args, int nargout) {
+ CvForestTree *arg1 = (CvForestTree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvForestTree",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestTree, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvForestTree" "', argument " "1"" of type '" "CvForestTree *""'");
+ }
+ arg1 = (CvForestTree *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvForestTree_train__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvForestTree *arg1 = (CvForestTree *) 0 ;
+ CvDTreeTrainData *arg2 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvRTrees *arg4 = (CvRTrees *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvForestTree_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvForestTree_train" "', argument " "1"" of type '" "CvForestTree *""'");
+ }
+ arg1 = (CvForestTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvForestTree_train" "', argument " "2"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg2 = (CvDTreeTrainData *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvForestTree_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvForestTree_train" "', argument " "4"" of type '" "CvRTrees *""'");
+ }
+ arg4 = (CvRTrees *)(argp4);
+ {
+ try {
+ result = (bool)(arg1)->train(arg2,(CvMat const *)arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvForestTree_get_var_count (const octave_value_list& args, int nargout) {
+ CvForestTree *arg1 = (CvForestTree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvForestTree_get_var_count",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvForestTree_get_var_count" "', argument " "1"" of type '" "CvForestTree const *""'");
+ }
+ arg1 = (CvForestTree *)(argp1);
+ {
+ try {
+ result = (int)((CvForestTree const *)arg1)->get_var_count();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvForestTree_read__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvForestTree *arg1 = (CvForestTree *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ CvRTrees *arg4 = (CvRTrees *) 0 ;
+ CvDTreeTrainData *arg5 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvForestTree_read",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvForestTree_read" "', argument " "1"" of type '" "CvForestTree *""'");
+ }
+ arg1 = (CvForestTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvForestTree_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvForestTree_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvForestTree_read" "', argument " "4"" of type '" "CvRTrees *""'");
+ }
+ arg4 = (CvRTrees *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvForestTree_read" "', argument " "5"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg5 = (CvDTreeTrainData *)(argp5);
+ {
+ try {
+ (arg1)->read(arg2,arg3,arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvForestTree_train__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvForestTree *arg1 = (CvForestTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvDTreeParams arg9 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvForestTree_train",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvForestTree_train" "', argument " "1"" of type '" "CvForestTree *""'");
+ }
+ arg1 = (CvForestTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvForestTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvForestTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvForestTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvForestTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvForestTree_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvForestTree_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvForestTree_train" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvForestTree_train" "', argument " "9"" of type '" "CvDTreeParams""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvForestTree_train" "', argument " "9"" of type '" "CvDTreeParams""'");
+ } else {
+ arg9 = *((CvDTreeParams *)(argp9));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvForestTree_train__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvForestTree *arg1 = (CvForestTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvForestTree_train",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvForestTree_train" "', argument " "1"" of type '" "CvForestTree *""'");
+ }
+ arg1 = (CvForestTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvForestTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvForestTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvForestTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvForestTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvForestTree_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvForestTree_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvForestTree_train" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvForestTree_train__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvForestTree *arg1 = (CvForestTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvForestTree_train",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvForestTree_train" "', argument " "1"" of type '" "CvForestTree *""'");
+ }
+ arg1 = (CvForestTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvForestTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvForestTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvForestTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvForestTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvForestTree_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvForestTree_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvForestTree_train__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvForestTree *arg1 = (CvForestTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvForestTree_train",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvForestTree_train" "', argument " "1"" of type '" "CvForestTree *""'");
+ }
+ arg1 = (CvForestTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvForestTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvForestTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvForestTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvForestTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvForestTree_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvForestTree_train__SWIG_5 (const octave_value_list& args, int nargout) {
+ CvForestTree *arg1 = (CvForestTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvForestTree_train",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvForestTree_train" "', argument " "1"" of type '" "CvForestTree *""'");
+ }
+ arg1 = (CvForestTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvForestTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvForestTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvForestTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvForestTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvForestTree_train__SWIG_6 (const octave_value_list& args, int nargout) {
+ CvForestTree *arg1 = (CvForestTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvForestTree_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvForestTree_train" "', argument " "1"" of type '" "CvForestTree *""'");
+ }
+ arg1 = (CvForestTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvForestTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvForestTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvForestTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvForestTree_train__SWIG_7 (const octave_value_list& args, int nargout) {
+ CvForestTree *arg1 = (CvForestTree *) 0 ;
+ CvDTreeTrainData *arg2 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvForestTree_train",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvForestTree_train" "', argument " "1"" of type '" "CvForestTree *""'");
+ }
+ arg1 = (CvForestTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvForestTree_train" "', argument " "2"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg2 = (CvDTreeTrainData *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvForestTree_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (bool)(arg1)->train(arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvForestTree_train (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[9]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8)
+ };
+
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvForestTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvForestTree_train__SWIG_7(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvForestTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvForestTree_train__SWIG_6(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvForestTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvForestTree_train__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvForestTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvForestTree_train__SWIG_5(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvForestTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvForestTree_train__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvForestTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvForestTree_train__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 8) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvForestTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvForestTree_train__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 9) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvForestTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvForestTree_train__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvForestTree_read__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvForestTree *arg1 = (CvForestTree *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvForestTree_read",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvForestTree_read" "', argument " "1"" of type '" "CvForestTree *""'");
+ }
+ arg1 = (CvForestTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvForestTree_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvForestTree_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ {
+ try {
+ (arg1)->read(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvForestTree_read__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvForestTree *arg1 = (CvForestTree *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ CvDTreeTrainData *arg4 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvForestTree_read",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvForestTree_read" "', argument " "1"" of type '" "CvForestTree *""'");
+ }
+ arg1 = (CvForestTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvForestTree_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvForestTree_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvForestTree_read" "', argument " "4"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg4 = (CvDTreeTrainData *)(argp4);
+ {
+ try {
+ (arg1)->read(arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvForestTree_read (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[5]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4)
+ };
+
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvForestTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvFileNode, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvForestTree_read__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvForestTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvFileNode, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvForestTree_read__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvForestTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvFileNode, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvForestTree_read__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static swig_octave_member swig_CvForestTree_members[] = {
+{"get_var_count",_wrap_CvForestTree_get_var_count,0,0,0,0},
+{"train",_wrap_CvForestTree_train,0,0,0,0},
+{"read",_wrap_CvForestTree_read,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvForestTree_base_names[] = {"_p_CvDTree",0};
+static const swig_type_info *swig_CvForestTree_base[] = {0,0};
+static swig_octave_class _wrap_class_CvForestTree = {"CvForestTree", &SWIGTYPE_p_CvForestTree,0,_wrap_new_CvForestTree,0,_wrap_delete_CvForestTree,swig_CvForestTree_members,swig_CvForestTree_base_names,swig_CvForestTree_base };
+
+static octave_value_list _wrap_CvRTParams_calc_var_importance_set (const octave_value_list& args, int nargout) {
+ CvRTParams *arg1 = (CvRTParams *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvRTParams_calc_var_importance_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTParams_calc_var_importance_set" "', argument " "1"" of type '" "CvRTParams *""'");
+ }
+ arg1 = (CvRTParams *)(argp1);
+ ecode2 = SWIG_AsVal_bool(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvRTParams_calc_var_importance_set" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = (bool)(val2);
+ if (arg1) (arg1)->calc_var_importance = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTParams_calc_var_importance_get (const octave_value_list& args, int nargout) {
+ CvRTParams *arg1 = (CvRTParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvRTParams_calc_var_importance_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTParams_calc_var_importance_get" "', argument " "1"" of type '" "CvRTParams *""'");
+ }
+ arg1 = (CvRTParams *)(argp1);
+ result = (bool) ((arg1)->calc_var_importance);
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTParams_nactive_vars_set (const octave_value_list& args, int nargout) {
+ CvRTParams *arg1 = (CvRTParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvRTParams_nactive_vars_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTParams_nactive_vars_set" "', argument " "1"" of type '" "CvRTParams *""'");
+ }
+ arg1 = (CvRTParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvRTParams_nactive_vars_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->nactive_vars = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTParams_nactive_vars_get (const octave_value_list& args, int nargout) {
+ CvRTParams *arg1 = (CvRTParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvRTParams_nactive_vars_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTParams_nactive_vars_get" "', argument " "1"" of type '" "CvRTParams *""'");
+ }
+ arg1 = (CvRTParams *)(argp1);
+ result = (int) ((arg1)->nactive_vars);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTParams_term_crit_set (const octave_value_list& args, int nargout) {
+ CvRTParams *arg1 = (CvRTParams *) 0 ;
+ CvTermCriteria *arg2 = (CvTermCriteria *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvRTParams_term_crit_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTParams_term_crit_set" "', argument " "1"" of type '" "CvRTParams *""'");
+ }
+ arg1 = (CvRTParams *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTermCriteria, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTParams_term_crit_set" "', argument " "2"" of type '" "CvTermCriteria *""'");
+ }
+ arg2 = (CvTermCriteria *)(argp2);
+ if (arg1) (arg1)->term_crit = *arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTParams_term_crit_get (const octave_value_list& args, int nargout) {
+ CvRTParams *arg1 = (CvRTParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvTermCriteria *result = 0 ;
+
+ if (!SWIG_check_num_args("CvRTParams_term_crit_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTParams_term_crit_get" "', argument " "1"" of type '" "CvRTParams *""'");
+ }
+ arg1 = (CvRTParams *)(argp1);
+ result = (CvTermCriteria *)& ((arg1)->term_crit);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTermCriteria, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvRTParams__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvRTParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvRTParams",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvRTParams *)new CvRTParams();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRTParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvRTParams__SWIG_1 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int arg2 ;
+ float arg3 ;
+ bool arg4 ;
+ int arg5 ;
+ float *arg6 = (float *) 0 ;
+ bool arg7 ;
+ int arg8 ;
+ int arg9 ;
+ float arg10 ;
+ int arg11 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ float val3 ;
+ int ecode3 = 0 ;
+ bool val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ bool val7 ;
+ int ecode7 = 0 ;
+ int val8 ;
+ int ecode8 = 0 ;
+ int val9 ;
+ int ecode9 = 0 ;
+ float val10 ;
+ int ecode10 = 0 ;
+ int val11 ;
+ int ecode11 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvRTParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvRTParams",args.length(),11,11,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvRTParams" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvRTParams" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_float(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvRTParams" "', argument " "3"" of type '" "float""'");
+ }
+ arg3 = (float)(val3);
+ ecode4 = SWIG_AsVal_bool(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvRTParams" "', argument " "4"" of type '" "bool""'");
+ }
+ arg4 = (bool)(val4);
+ ecode5 = SWIG_AsVal_int(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CvRTParams" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvRTParams" "', argument " "6"" of type '" "float const *""'");
+ }
+ arg6 = (float *)(argp6);
+ ecode7 = SWIG_AsVal_bool(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CvRTParams" "', argument " "7"" of type '" "bool""'");
+ }
+ arg7 = (bool)(val7);
+ ecode8 = SWIG_AsVal_int(args(7), &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CvRTParams" "', argument " "8"" of type '" "int""'");
+ }
+ arg8 = (int)(val8);
+ ecode9 = SWIG_AsVal_int(args(8), &val9);
+ if (!SWIG_IsOK(ecode9)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_CvRTParams" "', argument " "9"" of type '" "int""'");
+ }
+ arg9 = (int)(val9);
+ ecode10 = SWIG_AsVal_float(args(9), &val10);
+ if (!SWIG_IsOK(ecode10)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_CvRTParams" "', argument " "10"" of type '" "float""'");
+ }
+ arg10 = (float)(val10);
+ ecode11 = SWIG_AsVal_int(args(10), &val11);
+ if (!SWIG_IsOK(ecode11)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_CvRTParams" "', argument " "11"" of type '" "int""'");
+ }
+ arg11 = (int)(val11);
+ {
+ try {
+ result = (CvRTParams *)new CvRTParams(arg1,arg2,arg3,arg4,arg5,(float const *)arg6,arg7,arg8,arg9,arg10,arg11);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRTParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvRTParams (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[11]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8),octave_value_ref(args,9),octave_value_ref(args,10)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvRTParams__SWIG_0(args, nargout);
+ }
+ if (argc == 11) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _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) {
+ {
+ 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) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[6], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[7], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[8], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_float(argv[9], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[10], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvRTParams__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_delete_CvRTParams (const octave_value_list& args, int nargout) {
+ CvRTParams *arg1 = (CvRTParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvRTParams",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTParams, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvRTParams" "', argument " "1"" of type '" "CvRTParams *""'");
+ }
+ arg1 = (CvRTParams *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvRTParams_members[] = {
+{"calc_var_importance",0,_wrap_CvRTParams_calc_var_importance_get,_wrap_CvRTParams_calc_var_importance_set,0,0},
+{"nactive_vars",0,_wrap_CvRTParams_nactive_vars_get,_wrap_CvRTParams_nactive_vars_set,0,0},
+{"term_crit",0,_wrap_CvRTParams_term_crit_get,_wrap_CvRTParams_term_crit_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvRTParams_base_names[] = {"_p_CvDTreeParams",0};
+static const swig_type_info *swig_CvRTParams_base[] = {0,0};
+static swig_octave_class _wrap_class_CvRTParams = {"CvRTParams", &SWIGTYPE_p_CvRTParams,0,_wrap_new_CvRTParams,0,_wrap_delete_CvRTParams,swig_CvRTParams_members,swig_CvRTParams_base_names,swig_CvRTParams_base };
+
+static octave_value_list _wrap_new_CvRTrees (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvRTrees *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvRTrees",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvRTrees *)new CvRTrees();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRTrees, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvRTrees (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvRTrees",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvRTrees" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_train__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvRTParams arg9 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvRTrees_train",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_train" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvRTrees_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvRTrees_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvRTrees_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvRTrees_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvRTrees_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvRTrees_train" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvRTParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvRTrees_train" "', argument " "9"" of type '" "CvRTParams""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvRTrees_train" "', argument " "9"" of type '" "CvRTParams""'");
+ } else {
+ arg9 = *((CvRTParams *)(argp9));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_train__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvRTrees_train",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_train" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvRTrees_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvRTrees_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvRTrees_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvRTrees_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvRTrees_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvRTrees_train" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_train__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvRTrees_train",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_train" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvRTrees_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvRTrees_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvRTrees_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvRTrees_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvRTrees_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_train__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvRTrees_train",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_train" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvRTrees_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvRTrees_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvRTrees_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvRTrees_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_train__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvRTrees_train",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_train" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvRTrees_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvRTrees_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvRTrees_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_train__SWIG_5 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvRTrees_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_train" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvRTrees_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvRTrees_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_train__SWIG_6 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ CvRTParams arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvRTrees_train",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_train" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_train" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ {
+ res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_CvRTParams, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvRTrees_train" "', argument " "3"" of type '" "CvRTParams""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvRTrees_train" "', argument " "3"" of type '" "CvRTParams""'");
+ } else {
+ arg3 = *((CvRTParams *)(argp3));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_train__SWIG_7 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvRTrees_train",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_train" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_train" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ {
+ try {
+ result = (bool)(arg1)->train(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_train (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[9]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_train__SWIG_7(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvRTParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_train__SWIG_6(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_train__SWIG_5(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_train__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_train__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_train__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 8) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_train__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 9) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvRTParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_train__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvRTrees_predict__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvRTrees_predict",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_predict" "', argument " "1"" of type '" "CvRTrees const *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvRTrees_predict" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (float)((CvRTrees const *)arg1)->predict((CvMat const *)arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_predict__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvRTrees_predict",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_predict" "', argument " "1"" of type '" "CvRTrees const *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ result = (float)((CvRTrees const *)arg1)->predict((CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_predict (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[3]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_predict__SWIG_1(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_predict__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvRTrees_predict_prob__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvRTrees_predict_prob",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_predict_prob" "', argument " "1"" of type '" "CvRTrees const *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_predict_prob" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvRTrees_predict_prob" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (float)((CvRTrees const *)arg1)->predict_prob((CvMat const *)arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_predict_prob__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvRTrees_predict_prob",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_predict_prob" "', argument " "1"" of type '" "CvRTrees const *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_predict_prob" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ result = (float)((CvRTrees const *)arg1)->predict_prob((CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_predict_prob (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[3]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_predict_prob__SWIG_1(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_predict_prob__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvRTrees_clear (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvRTrees_clear",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_clear" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ {
+ try {
+ (arg1)->clear();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_get_var_importance (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvRTrees_get_var_importance",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_get_var_importance" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_var_importance();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_get_proximity__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvRTrees_get_proximity",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_get_proximity" "', argument " "1"" of type '" "CvRTrees const *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_get_proximity" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvRTrees_get_proximity" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvRTrees_get_proximity" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvRTrees_get_proximity" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (float)((CvRTrees const *)arg1)->get_proximity((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_get_proximity__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvRTrees_get_proximity",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_get_proximity" "', argument " "1"" of type '" "CvRTrees const *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_get_proximity" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvRTrees_get_proximity" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvRTrees_get_proximity" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (float)((CvRTrees const *)arg1)->get_proximity((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_get_proximity__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvRTrees_get_proximity",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_get_proximity" "', argument " "1"" of type '" "CvRTrees const *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_get_proximity" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvRTrees_get_proximity" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (float)((CvRTrees const *)arg1)->get_proximity((CvMat const *)arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_get_proximity (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[5]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4)
+ };
+
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_get_proximity__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_get_proximity__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_get_proximity__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvRTrees_calc_error__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ int arg3 ;
+ vector< float > *arg4 = (vector< float > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvRTrees_calc_error",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_calc_error" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_calc_error" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvRTrees_calc_error" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_vectorT_float_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvRTrees_calc_error" "', argument " "4"" of type '" "vector< float > *""'");
+ }
+ arg4 = (vector< float > *)(argp4);
+ {
+ try {
+ result = (float)(arg1)->calc_error(arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_calc_error__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ int arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvRTrees_calc_error",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_calc_error" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_calc_error" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvRTrees_calc_error" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ try {
+ result = (float)(arg1)->calc_error(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_calc_error (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[4]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3)
+ };
+
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvRTrees_calc_error__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvRTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_vectorT_float_t, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvRTrees_calc_error__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvRTrees_get_train_error (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvRTrees_get_train_error",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_get_train_error" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ {
+ try {
+ result = (float)(arg1)->get_train_error();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_read (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvRTrees_read",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_read" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvRTrees_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ {
+ try {
+ (arg1)->read(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_write (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ char *arg3 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvRTrees_write",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_write" "', argument " "1"" of type '" "CvRTrees const *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvRTrees_write" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvRTrees_write" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ {
+ try {
+ ((CvRTrees const *)arg1)->write(arg2,(char const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_get_active_var_mask (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvRTrees_get_active_var_mask",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_get_active_var_mask" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_active_var_mask();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_get_rng (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvRNG *result = 0 ;
+
+ if (!SWIG_check_num_args("CvRTrees_get_rng",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_get_rng" "', argument " "1"" of type '" "CvRTrees *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ {
+ try {
+ result = (CvRNG *)(arg1)->get_rng();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ {
+ CvRNG_Wrapper * wrapper = new CvRNG_Wrapper( *(result) );
+ _outv = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvRNG_Wrapper, 1 );
+ }
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_get_tree_count (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvRTrees_get_tree_count",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_get_tree_count" "', argument " "1"" of type '" "CvRTrees const *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ {
+ try {
+ result = (int)((CvRTrees const *)arg1)->get_tree_count();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvRTrees_get_tree (const octave_value_list& args, int nargout) {
+ CvRTrees *arg1 = (CvRTrees *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvForestTree *result = 0 ;
+
+ if (!SWIG_check_num_args("CvRTrees_get_tree",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRTrees_get_tree" "', argument " "1"" of type '" "CvRTrees const *""'");
+ }
+ arg1 = (CvRTrees *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvRTrees_get_tree" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ {
+ try {
+ result = (CvForestTree *)((CvRTrees const *)arg1)->get_tree(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvForestTree, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvRTrees_members[] = {
+{"train",_wrap_CvRTrees_train,0,0,0,0},
+{"predict",_wrap_CvRTrees_predict,0,0,0,0},
+{"predict_prob",_wrap_CvRTrees_predict_prob,0,0,0,0},
+{"clear",_wrap_CvRTrees_clear,0,0,0,0},
+{"get_var_importance",_wrap_CvRTrees_get_var_importance,0,0,0,0},
+{"get_proximity",_wrap_CvRTrees_get_proximity,0,0,0,0},
+{"calc_error",_wrap_CvRTrees_calc_error,0,0,0,0},
+{"get_train_error",_wrap_CvRTrees_get_train_error,0,0,0,0},
+{"read",_wrap_CvRTrees_read,0,0,0,0},
+{"write",_wrap_CvRTrees_write,0,0,0,0},
+{"get_active_var_mask",_wrap_CvRTrees_get_active_var_mask,0,0,0,0},
+{"get_rng",_wrap_CvRTrees_get_rng,0,0,0,0},
+{"get_tree_count",_wrap_CvRTrees_get_tree_count,0,0,0,0},
+{"get_tree",_wrap_CvRTrees_get_tree,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvRTrees_base_names[] = {"_p_CvStatModel",0};
+static const swig_type_info *swig_CvRTrees_base[] = {0,0};
+static swig_octave_class _wrap_class_CvRTrees = {"CvRTrees", &SWIGTYPE_p_CvRTrees,0,_wrap_new_CvRTrees,0,_wrap_delete_CvRTrees,swig_CvRTrees_members,swig_CvRTrees_base_names,swig_CvRTrees_base };
+
+static octave_value_list _wrap_CvERTreeTrainData_set_data__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvDTreeParams *arg9 = 0 ;
+ bool arg10 ;
+ bool arg11 ;
+ bool arg12 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ bool val10 ;
+ int ecode10 = 0 ;
+ bool val11 ;
+ int ecode11 = 0 ;
+ bool val12 ;
+ int ecode12 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_set_data",args.length(),12,12,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_set_data" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvERTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvERTreeTrainData_set_data" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvERTreeTrainData_set_data" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvERTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvERTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ arg9 = (CvDTreeParams *)(argp9);
+ ecode10 = SWIG_AsVal_bool(args(9), &val10);
+ if (!SWIG_IsOK(ecode10)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CvERTreeTrainData_set_data" "', argument " "10"" of type '" "bool""'");
+ }
+ arg10 = (bool)(val10);
+ ecode11 = SWIG_AsVal_bool(args(10), &val11);
+ if (!SWIG_IsOK(ecode11)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "CvERTreeTrainData_set_data" "', argument " "11"" of type '" "bool""'");
+ }
+ arg11 = (bool)(val11);
+ ecode12 = SWIG_AsVal_bool(args(11), &val12);
+ if (!SWIG_IsOK(ecode12)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "CvERTreeTrainData_set_data" "', argument " "12"" of type '" "bool""'");
+ }
+ arg12 = (bool)(val12);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,(CvDTreeParams const &)*arg9,arg10,arg11,arg12);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_set_data__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvDTreeParams *arg9 = 0 ;
+ bool arg10 ;
+ bool arg11 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ bool val10 ;
+ int ecode10 = 0 ;
+ bool val11 ;
+ int ecode11 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_set_data",args.length(),11,11,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_set_data" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvERTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvERTreeTrainData_set_data" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvERTreeTrainData_set_data" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvERTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvERTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ arg9 = (CvDTreeParams *)(argp9);
+ ecode10 = SWIG_AsVal_bool(args(9), &val10);
+ if (!SWIG_IsOK(ecode10)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CvERTreeTrainData_set_data" "', argument " "10"" of type '" "bool""'");
+ }
+ arg10 = (bool)(val10);
+ ecode11 = SWIG_AsVal_bool(args(10), &val11);
+ if (!SWIG_IsOK(ecode11)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "CvERTreeTrainData_set_data" "', argument " "11"" of type '" "bool""'");
+ }
+ arg11 = (bool)(val11);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,(CvDTreeParams const &)*arg9,arg10,arg11);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_set_data__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvDTreeParams *arg9 = 0 ;
+ bool arg10 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ bool val10 ;
+ int ecode10 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_set_data",args.length(),10,10,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_set_data" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvERTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvERTreeTrainData_set_data" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvERTreeTrainData_set_data" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvERTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvERTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ arg9 = (CvDTreeParams *)(argp9);
+ ecode10 = SWIG_AsVal_bool(args(9), &val10);
+ if (!SWIG_IsOK(ecode10)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CvERTreeTrainData_set_data" "', argument " "10"" of type '" "bool""'");
+ }
+ arg10 = (bool)(val10);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,(CvDTreeParams const &)*arg9,arg10);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_set_data__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvDTreeParams *arg9 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_set_data",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_set_data" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvERTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvERTreeTrainData_set_data" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvERTreeTrainData_set_data" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvERTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvERTreeTrainData_set_data" "', argument " "9"" of type '" "CvDTreeParams const &""'");
+ }
+ arg9 = (CvDTreeParams *)(argp9);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,(CvDTreeParams const &)*arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_set_data__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_set_data",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_set_data" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvERTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvERTreeTrainData_set_data" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvERTreeTrainData_set_data" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_set_data__SWIG_5 (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_set_data",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_set_data" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvERTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvERTreeTrainData_set_data" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_set_data__SWIG_6 (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_set_data",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_set_data" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvERTreeTrainData_set_data" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_set_data__SWIG_7 (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_set_data",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_set_data" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTreeTrainData_set_data" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_set_data__SWIG_8 (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_set_data",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_set_data" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_set_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTreeTrainData_set_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_set_data" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ (arg1)->set_data((CvMat const *)arg2,arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_set_data (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[12]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8),octave_value_ref(args,9),octave_value_ref(args,10),octave_value_ref(args,11)
+ };
+
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTreeTrainData_set_data__SWIG_8(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTreeTrainData_set_data__SWIG_7(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTreeTrainData_set_data__SWIG_6(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTreeTrainData_set_data__SWIG_5(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 8) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTreeTrainData_set_data__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 9) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTreeTrainData_set_data__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 10) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[9], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvERTreeTrainData_set_data__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 11) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[9], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[10], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvERTreeTrainData_set_data__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 12) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[9], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[10], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[11], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvERTreeTrainData_set_data__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_get_ord_var_data (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ int arg3 ;
+ float *arg4 = (float *) 0 ;
+ int *arg5 = (int *) 0 ;
+ float **arg6 = (float **) 0 ;
+ int **arg7 = (int **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *vptr6 ;
+ float *buffer6 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_get_ord_var_data",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_get_ord_var_data" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_get_ord_var_data" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTreeTrainData_get_ord_var_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_get_ord_var_data" "', argument " "4"" of type '" "float *""'");
+ }
+ arg4 = (float *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTreeTrainData_get_ord_var_data" "', argument " "5"" of type '" "int *""'");
+ }
+ arg5 = (int *)(argp5);
+ {
+ if ((SWIG_ConvertPtr(args(5), &vptr6, SWIGTYPE_p_float, 1)) == -1){
+ SWIG_fail;
+ }
+ buffer6 = (float *) vptr6;
+ arg6=&buffer6;
+ }
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvERTreeTrainData_get_ord_var_data" "', argument " "7"" of type '" "int const **""'");
+ }
+ arg7 = (int **)(argp7);
+ {
+ try {
+ result = (int)(arg1)->get_ord_var_data(arg2,arg3,arg4,arg5,(float const **)arg6,(int const **)arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_get_sample_indices (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int **arg4 = (int **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_get_sample_indices",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_get_sample_indices" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_get_sample_indices" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvERTreeTrainData_get_sample_indices" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_get_sample_indices" "', argument " "4"" of type '" "int const **""'");
+ }
+ arg4 = (int **)(argp4);
+ {
+ try {
+ (arg1)->get_sample_indices(arg2,arg3,(int const **)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_get_cv_labels (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int **arg4 = (int **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_get_cv_labels",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_get_cv_labels" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_get_cv_labels" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvERTreeTrainData_get_cv_labels" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_get_cv_labels" "', argument " "4"" of type '" "int const **""'");
+ }
+ arg4 = (int **)(argp4);
+ {
+ try {
+ (arg1)->get_cv_labels(arg2,arg3,(int const **)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_get_cat_var_data (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvDTreeNode *arg2 = (CvDTreeNode *) 0 ;
+ int arg3 ;
+ int *arg4 = (int *) 0 ;
+ int **arg5 = (int **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_get_cat_var_data",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_get_cat_var_data" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_get_cat_var_data" "', argument " "2"" of type '" "CvDTreeNode *""'");
+ }
+ arg2 = (CvDTreeNode *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTreeTrainData_get_cat_var_data" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_get_cat_var_data" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTreeTrainData_get_cat_var_data" "', argument " "5"" of type '" "int const **""'");
+ }
+ arg5 = (int **)(argp5);
+ {
+ try {
+ result = (int)(arg1)->get_cat_var_data(arg2,arg3,arg4,(int const **)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_get_vectors__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ float *arg3 = (float *) 0 ;
+ uchar *arg4 = (uchar *) 0 ;
+ float *arg5 = (float *) 0 ;
+ bool arg6 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ bool val6 ;
+ int ecode6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_get_vectors",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_get_vectors" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_get_vectors" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvERTreeTrainData_get_vectors" "', argument " "3"" of type '" "float *""'");
+ }
+ arg3 = (float *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_get_vectors" "', argument " "4"" of type '" "uchar *""'");
+ }
+ arg4 = (uchar *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTreeTrainData_get_vectors" "', argument " "5"" of type '" "float *""'");
+ }
+ arg5 = (float *)(argp5);
+ ecode6 = SWIG_AsVal_bool(args(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvERTreeTrainData_get_vectors" "', argument " "6"" of type '" "bool""'");
+ }
+ arg6 = (bool)(val6);
+ {
+ try {
+ (arg1)->get_vectors((CvMat const *)arg2,arg3,arg4,arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_get_vectors__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ float *arg3 = (float *) 0 ;
+ uchar *arg4 = (uchar *) 0 ;
+ float *arg5 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_get_vectors",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_get_vectors" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_get_vectors" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvERTreeTrainData_get_vectors" "', argument " "3"" of type '" "float *""'");
+ }
+ arg3 = (float *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTreeTrainData_get_vectors" "', argument " "4"" of type '" "uchar *""'");
+ }
+ arg4 = (uchar *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTreeTrainData_get_vectors" "', argument " "5"" of type '" "float *""'");
+ }
+ arg5 = (float *)(argp5);
+ {
+ try {
+ (arg1)->get_vectors((CvMat const *)arg2,arg3,arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_get_vectors (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[6]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5)
+ };
+
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTreeTrainData_get_vectors__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[5], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvERTreeTrainData_get_vectors__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_subsample_data (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeNode *result = 0 ;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_subsample_data",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_subsample_data" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_subsample_data" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ result = (CvDTreeNode *)(arg1)->subsample_data((CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeNode, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_missing_mask_set (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_missing_mask_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_missing_mask_set" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTreeTrainData_missing_mask_set" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ if (arg1) (arg1)->missing_mask = (CvMat const *)arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTreeTrainData_missing_mask_get (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvERTreeTrainData_missing_mask_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTreeTrainData_missing_mask_get" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ result = (CvMat *) ((arg1)->missing_mask);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvERTreeTrainData (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvERTreeTrainData *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvERTreeTrainData",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvERTreeTrainData *)new CvERTreeTrainData();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvERTreeTrainData, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvERTreeTrainData (const octave_value_list& args, int nargout) {
+ CvERTreeTrainData *arg1 = (CvERTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvERTreeTrainData",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTreeTrainData, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvERTreeTrainData" "', argument " "1"" of type '" "CvERTreeTrainData *""'");
+ }
+ arg1 = (CvERTreeTrainData *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvERTreeTrainData_members[] = {
+{"set_data",_wrap_CvERTreeTrainData_set_data,0,0,0,0},
+{"get_ord_var_data",_wrap_CvERTreeTrainData_get_ord_var_data,0,0,0,0},
+{"get_sample_indices",_wrap_CvERTreeTrainData_get_sample_indices,0,0,0,0},
+{"get_cv_labels",_wrap_CvERTreeTrainData_get_cv_labels,0,0,0,0},
+{"get_cat_var_data",_wrap_CvERTreeTrainData_get_cat_var_data,0,0,0,0},
+{"get_vectors",_wrap_CvERTreeTrainData_get_vectors,0,0,0,0},
+{"subsample_data",_wrap_CvERTreeTrainData_subsample_data,0,0,0,0},
+{"missing_mask",0,_wrap_CvERTreeTrainData_missing_mask_get,_wrap_CvERTreeTrainData_missing_mask_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvERTreeTrainData_base_names[] = {"_p_CvDTreeTrainData",0};
+static const swig_type_info *swig_CvERTreeTrainData_base[] = {0,0};
+static swig_octave_class _wrap_class_CvERTreeTrainData = {"CvERTreeTrainData", &SWIGTYPE_p_CvERTreeTrainData,0,_wrap_new_CvERTreeTrainData,0,_wrap_delete_CvERTreeTrainData,swig_CvERTreeTrainData_members,swig_CvERTreeTrainData_base_names,swig_CvERTreeTrainData_base };
+
+static octave_value_list _wrap_new_CvForestERTree (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvForestERTree *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvForestERTree",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvForestERTree *)new CvForestERTree();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvForestERTree, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvForestERTree (const octave_value_list& args, int nargout) {
+ CvForestERTree *arg1 = (CvForestERTree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvForestERTree",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvForestERTree, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvForestERTree" "', argument " "1"" of type '" "CvForestERTree *""'");
+ }
+ arg1 = (CvForestERTree *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvForestERTree_members[] = {
+{0,0,0,0}
+};
+static const char *swig_CvForestERTree_base_names[] = {"_p_CvForestTree",0};
+static const swig_type_info *swig_CvForestERTree_base[] = {0,0};
+static swig_octave_class _wrap_class_CvForestERTree = {"CvForestERTree", &SWIGTYPE_p_CvForestERTree,0,_wrap_new_CvForestERTree,0,_wrap_delete_CvForestERTree,swig_CvForestERTree_members,swig_CvForestERTree_base_names,swig_CvForestERTree_base };
+
+static octave_value_list _wrap_new_CvERTrees (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvERTrees *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvERTrees",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvERTrees *)new CvERTrees();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvERTrees, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvERTrees (const octave_value_list& args, int nargout) {
+ CvERTrees *arg1 = (CvERTrees *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvERTrees",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTrees, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvERTrees" "', argument " "1"" of type '" "CvERTrees *""'");
+ }
+ arg1 = (CvERTrees *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTrees_train__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvERTrees *arg1 = (CvERTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvRTParams arg9 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvERTrees_train",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTrees_train" "', argument " "1"" of type '" "CvERTrees *""'");
+ }
+ arg1 = (CvERTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTrees_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTrees_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTrees_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTrees_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvERTrees_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvERTrees_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvERTrees_train" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvRTParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvERTrees_train" "', argument " "9"" of type '" "CvRTParams""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvERTrees_train" "', argument " "9"" of type '" "CvRTParams""'");
+ } else {
+ arg9 = *((CvRTParams *)(argp9));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTrees_train__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvERTrees *arg1 = (CvERTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvERTrees_train",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTrees_train" "', argument " "1"" of type '" "CvERTrees *""'");
+ }
+ arg1 = (CvERTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTrees_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTrees_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTrees_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTrees_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvERTrees_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvERTrees_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvERTrees_train" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTrees_train__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvERTrees *arg1 = (CvERTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvERTrees_train",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTrees_train" "', argument " "1"" of type '" "CvERTrees *""'");
+ }
+ arg1 = (CvERTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTrees_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTrees_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTrees_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTrees_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvERTrees_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvERTrees_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTrees_train__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvERTrees *arg1 = (CvERTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvERTrees_train",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTrees_train" "', argument " "1"" of type '" "CvERTrees *""'");
+ }
+ arg1 = (CvERTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTrees_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTrees_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTrees_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTrees_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvERTrees_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTrees_train__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvERTrees *arg1 = (CvERTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvERTrees_train",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTrees_train" "', argument " "1"" of type '" "CvERTrees *""'");
+ }
+ arg1 = (CvERTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTrees_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTrees_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTrees_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvERTrees_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTrees_train__SWIG_5 (const octave_value_list& args, int nargout) {
+ CvERTrees *arg1 = (CvERTrees *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvERTrees_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTrees_train" "', argument " "1"" of type '" "CvERTrees *""'");
+ }
+ arg1 = (CvERTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTrees_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvERTrees_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvERTrees_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTrees_train__SWIG_6 (const octave_value_list& args, int nargout) {
+ CvERTrees *arg1 = (CvERTrees *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ CvRTParams arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvERTrees_train",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTrees_train" "', argument " "1"" of type '" "CvERTrees *""'");
+ }
+ arg1 = (CvERTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTrees_train" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ {
+ res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_CvRTParams, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvERTrees_train" "', argument " "3"" of type '" "CvRTParams""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvERTrees_train" "', argument " "3"" of type '" "CvRTParams""'");
+ } else {
+ arg3 = *((CvRTParams *)(argp3));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTrees_train__SWIG_7 (const octave_value_list& args, int nargout) {
+ CvERTrees *arg1 = (CvERTrees *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvERTrees_train",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvERTrees, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvERTrees_train" "', argument " "1"" of type '" "CvERTrees *""'");
+ }
+ arg1 = (CvERTrees *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvERTrees_train" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ {
+ try {
+ result = (bool)(arg1)->train(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvERTrees_train (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[9]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTrees_train__SWIG_7(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvRTParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTrees_train__SWIG_6(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTrees_train__SWIG_5(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTrees_train__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTrees_train__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTrees_train__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 8) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTrees_train__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 9) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvERTrees, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvRTParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvERTrees_train__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static swig_octave_member swig_CvERTrees_members[] = {
+{"train",_wrap_CvERTrees_train,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvERTrees_base_names[] = {"_p_CvRTrees",0};
+static const swig_type_info *swig_CvERTrees_base[] = {0,0};
+static swig_octave_class _wrap_class_CvERTrees = {"CvERTrees", &SWIGTYPE_p_CvERTrees,0,_wrap_new_CvERTrees,0,_wrap_delete_CvERTrees,swig_CvERTrees_members,swig_CvERTrees_base_names,swig_CvERTrees_base };
+
+static octave_value_list _wrap_CvBoostParams_boost_type_set (const octave_value_list& args, int nargout) {
+ CvBoostParams *arg1 = (CvBoostParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvBoostParams_boost_type_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostParams_boost_type_set" "', argument " "1"" of type '" "CvBoostParams *""'");
+ }
+ arg1 = (CvBoostParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBoostParams_boost_type_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->boost_type = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostParams_boost_type_get (const octave_value_list& args, int nargout) {
+ CvBoostParams *arg1 = (CvBoostParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvBoostParams_boost_type_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostParams_boost_type_get" "', argument " "1"" of type '" "CvBoostParams *""'");
+ }
+ arg1 = (CvBoostParams *)(argp1);
+ result = (int) ((arg1)->boost_type);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostParams_weak_count_set (const octave_value_list& args, int nargout) {
+ CvBoostParams *arg1 = (CvBoostParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvBoostParams_weak_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostParams_weak_count_set" "', argument " "1"" of type '" "CvBoostParams *""'");
+ }
+ arg1 = (CvBoostParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBoostParams_weak_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->weak_count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostParams_weak_count_get (const octave_value_list& args, int nargout) {
+ CvBoostParams *arg1 = (CvBoostParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvBoostParams_weak_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostParams_weak_count_get" "', argument " "1"" of type '" "CvBoostParams *""'");
+ }
+ arg1 = (CvBoostParams *)(argp1);
+ result = (int) ((arg1)->weak_count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostParams_split_criteria_set (const octave_value_list& args, int nargout) {
+ CvBoostParams *arg1 = (CvBoostParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvBoostParams_split_criteria_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostParams_split_criteria_set" "', argument " "1"" of type '" "CvBoostParams *""'");
+ }
+ arg1 = (CvBoostParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBoostParams_split_criteria_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->split_criteria = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostParams_split_criteria_get (const octave_value_list& args, int nargout) {
+ CvBoostParams *arg1 = (CvBoostParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvBoostParams_split_criteria_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostParams_split_criteria_get" "', argument " "1"" of type '" "CvBoostParams *""'");
+ }
+ arg1 = (CvBoostParams *)(argp1);
+ result = (int) ((arg1)->split_criteria);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostParams_weight_trim_rate_set (const octave_value_list& args, int nargout) {
+ CvBoostParams *arg1 = (CvBoostParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvBoostParams_weight_trim_rate_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostParams_weight_trim_rate_set" "', argument " "1"" of type '" "CvBoostParams *""'");
+ }
+ arg1 = (CvBoostParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBoostParams_weight_trim_rate_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->weight_trim_rate = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostParams_weight_trim_rate_get (const octave_value_list& args, int nargout) {
+ CvBoostParams *arg1 = (CvBoostParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvBoostParams_weight_trim_rate_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostParams_weight_trim_rate_get" "', argument " "1"" of type '" "CvBoostParams *""'");
+ }
+ arg1 = (CvBoostParams *)(argp1);
+ result = (double) ((arg1)->weight_trim_rate);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvBoostParams__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvBoostParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvBoostParams",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvBoostParams *)new CvBoostParams();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoostParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvBoostParams__SWIG_1 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int arg2 ;
+ double arg3 ;
+ int arg4 ;
+ bool arg5 ;
+ float *arg6 = (float *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ bool val5 ;
+ int ecode5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvBoostParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvBoostParams",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvBoostParams" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBoostParams" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvBoostParams" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ ecode4 = SWIG_AsVal_int(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvBoostParams" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_bool(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CvBoostParams" "', argument " "5"" of type '" "bool""'");
+ }
+ arg5 = (bool)(val5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvBoostParams" "', argument " "6"" of type '" "float const *""'");
+ }
+ arg6 = (float *)(argp6);
+ {
+ try {
+ result = (CvBoostParams *)new CvBoostParams(arg1,arg2,arg3,arg4,arg5,(float const *)arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoostParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvBoostParams (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[6]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvBoostParams__SWIG_0(args, nargout);
+ }
+ if (argc == 6) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(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_bool(argv[4], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_float, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvBoostParams__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_delete_CvBoostParams (const octave_value_list& args, int nargout) {
+ CvBoostParams *arg1 = (CvBoostParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvBoostParams",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostParams, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvBoostParams" "', argument " "1"" of type '" "CvBoostParams *""'");
+ }
+ arg1 = (CvBoostParams *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvBoostParams_members[] = {
+{"boost_type",0,_wrap_CvBoostParams_boost_type_get,_wrap_CvBoostParams_boost_type_set,0,0},
+{"weak_count",0,_wrap_CvBoostParams_weak_count_get,_wrap_CvBoostParams_weak_count_set,0,0},
+{"split_criteria",0,_wrap_CvBoostParams_split_criteria_get,_wrap_CvBoostParams_split_criteria_set,0,0},
+{"weight_trim_rate",0,_wrap_CvBoostParams_weight_trim_rate_get,_wrap_CvBoostParams_weight_trim_rate_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvBoostParams_base_names[] = {"_p_CvDTreeParams",0};
+static const swig_type_info *swig_CvBoostParams_base[] = {0,0};
+static swig_octave_class _wrap_class_CvBoostParams = {"CvBoostParams", &SWIGTYPE_p_CvBoostParams,0,_wrap_new_CvBoostParams,0,_wrap_delete_CvBoostParams,swig_CvBoostParams_members,swig_CvBoostParams_base_names,swig_CvBoostParams_base };
+
+static octave_value_list _wrap_new_CvBoostTree (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvBoostTree *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvBoostTree",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvBoostTree *)new CvBoostTree();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoostTree, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvBoostTree (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvBoostTree",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvBoostTree" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_train__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ CvDTreeTrainData *arg2 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvBoost *arg4 = (CvBoost *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoostTree_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostTree_train" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoostTree_train" "', argument " "2"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg2 = (CvDTreeTrainData *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoostTree_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoostTree_train" "', argument " "4"" of type '" "CvBoost *""'");
+ }
+ arg4 = (CvBoost *)(argp4);
+ {
+ try {
+ result = (bool)(arg1)->train(arg2,(CvMat const *)arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_scale (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvBoostTree_scale",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostTree_scale" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBoostTree_scale" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ {
+ try {
+ (arg1)->scale(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_read__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ CvBoost *arg4 = (CvBoost *) 0 ;
+ CvDTreeTrainData *arg5 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvBoostTree_read",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostTree_read" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoostTree_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoostTree_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoostTree_read" "', argument " "4"" of type '" "CvBoost *""'");
+ }
+ arg4 = (CvBoost *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoostTree_read" "', argument " "5"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg5 = (CvDTreeTrainData *)(argp5);
+ {
+ try {
+ (arg1)->read(arg2,arg3,arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_clear (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvBoostTree_clear",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostTree_clear" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ {
+ try {
+ (arg1)->clear();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_train__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvDTreeParams arg9 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoostTree_train",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostTree_train" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoostTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoostTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoostTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoostTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBoostTree_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvBoostTree_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvBoostTree_train" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvDTreeParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvBoostTree_train" "', argument " "9"" of type '" "CvDTreeParams""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBoostTree_train" "', argument " "9"" of type '" "CvDTreeParams""'");
+ } else {
+ arg9 = *((CvDTreeParams *)(argp9));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_train__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoostTree_train",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostTree_train" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoostTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoostTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoostTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoostTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBoostTree_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvBoostTree_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvBoostTree_train" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_train__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoostTree_train",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostTree_train" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoostTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoostTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoostTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoostTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBoostTree_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvBoostTree_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_train__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoostTree_train",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostTree_train" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoostTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoostTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoostTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoostTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBoostTree_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_train__SWIG_5 (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoostTree_train",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostTree_train" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoostTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoostTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoostTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoostTree_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_train__SWIG_6 (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoostTree_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostTree_train" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoostTree_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoostTree_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoostTree_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_train__SWIG_7 (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ CvDTreeTrainData *arg2 = (CvDTreeTrainData *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoostTree_train",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostTree_train" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoostTree_train" "', argument " "2"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg2 = (CvDTreeTrainData *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoostTree_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (bool)(arg1)->train(arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_train (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[9]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8)
+ };
+
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoostTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoostTree_train__SWIG_7(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoostTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoostTree_train__SWIG_6(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoostTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoostTree_train__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoostTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoostTree_train__SWIG_5(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoostTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoostTree_train__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoostTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoostTree_train__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 8) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoostTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoostTree_train__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 9) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoostTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvDTreeParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoostTree_train__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvBoostTree_read__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvBoostTree_read",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostTree_read" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoostTree_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoostTree_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ {
+ try {
+ (arg1)->read(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_read__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvBoostTree *arg1 = (CvBoostTree *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ CvDTreeTrainData *arg4 = (CvDTreeTrainData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvBoostTree_read",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoostTree, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoostTree_read" "', argument " "1"" of type '" "CvBoostTree *""'");
+ }
+ arg1 = (CvBoostTree *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoostTree_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoostTree_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoostTree_read" "', argument " "4"" of type '" "CvDTreeTrainData *""'");
+ }
+ arg4 = (CvDTreeTrainData *)(argp4);
+ {
+ try {
+ (arg1)->read(arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoostTree_read (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[5]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4)
+ };
+
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoostTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvFileNode, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoostTree_read__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoostTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvFileNode, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoostTree_read__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoostTree, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvFileStorage, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvFileNode, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvDTreeTrainData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoostTree_read__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static swig_octave_member swig_CvBoostTree_members[] = {
+{"scale",_wrap_CvBoostTree_scale,0,0,0,0},
+{"clear",_wrap_CvBoostTree_clear,0,0,0,0},
+{"train",_wrap_CvBoostTree_train,0,0,0,0},
+{"read",_wrap_CvBoostTree_read,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvBoostTree_base_names[] = {"_p_CvDTree",0};
+static const swig_type_info *swig_CvBoostTree_base[] = {0,0};
+static swig_octave_class _wrap_class_CvBoostTree = {"CvBoostTree", &SWIGTYPE_p_CvBoostTree,0,_wrap_new_CvBoostTree,0,_wrap_delete_CvBoostTree,swig_CvBoostTree_members,swig_CvBoostTree_base_names,swig_CvBoostTree_base };
+
+static octave_value_list _wrap_new_CvBoost__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvBoost *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvBoost",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvBoost *)new CvBoost();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoost, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvBoost (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvBoost",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvBoost" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvBoost__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvBoostParams arg8 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 ;
+ int res8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvBoost *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvBoost",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvBoost" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBoost" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvBoost" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvBoost" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvBoost" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvBoost" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CvBoost" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ {
+ res8 = SWIG_ConvertPtr(args(7), &argp8, SWIGTYPE_p_CvBoostParams, 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_CvBoost" "', argument " "8"" of type '" "CvBoostParams""'");
+ }
+ if (!argp8) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvBoost" "', argument " "8"" of type '" "CvBoostParams""'");
+ } else {
+ arg8 = *((CvBoostParams *)(argp8));
+ }
+ }
+ {
+ try {
+ result = (CvBoost *)new CvBoost((CvMat const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoost, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvBoost__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvBoost *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvBoost",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvBoost" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBoost" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvBoost" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvBoost" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvBoost" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvBoost" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_CvBoost" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ {
+ try {
+ result = (CvBoost *)new CvBoost((CvMat const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoost, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvBoost__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvBoost *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvBoost",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvBoost" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBoost" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvBoost" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvBoost" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvBoost" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_CvBoost" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ {
+ try {
+ result = (CvBoost *)new CvBoost((CvMat const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoost, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvBoost__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvBoost *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvBoost",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvBoost" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBoost" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvBoost" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvBoost" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvBoost" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (CvBoost *)new CvBoost((CvMat const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoost, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvBoost__SWIG_5 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvBoost *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvBoost",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvBoost" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBoost" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvBoost" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvBoost" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (CvBoost *)new CvBoost((CvMat const *)arg1,arg2,(CvMat const *)arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoost, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvBoost__SWIG_6 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvBoost *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvBoost",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvBoost" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvBoost" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_CvBoost" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (CvBoost *)new CvBoost((CvMat const *)arg1,arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoost, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvBoost (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[8]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvBoost__SWIG_0(args, nargout);
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvBoost__SWIG_6(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvBoost__SWIG_5(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvBoost__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvBoost__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvBoost__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 8) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvBoostParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvBoost__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvBoost_train__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvBoostParams arg9 ;
+ bool arg10 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ bool val10 ;
+ int ecode10 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoost_train",args.length(),10,10,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_train" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoost_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoost_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoost_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBoost_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvBoost_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvBoost_train" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvBoostParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvBoost_train" "', argument " "9"" of type '" "CvBoostParams""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBoost_train" "', argument " "9"" of type '" "CvBoostParams""'");
+ } else {
+ arg9 = *((CvBoostParams *)(argp9));
+ }
+ }
+ ecode10 = SWIG_AsVal_bool(args(9), &val10);
+ if (!SWIG_IsOK(ecode10)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "CvBoost_train" "', argument " "10"" of type '" "bool""'");
+ }
+ arg10 = (bool)(val10);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,arg9,arg10);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_train__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ CvBoostParams arg9 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 ;
+ int res9 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoost_train",args.length(),9,9,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_train" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoost_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoost_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoost_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBoost_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvBoost_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvBoost_train" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvBoostParams, 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "CvBoost_train" "', argument " "9"" of type '" "CvBoostParams""'");
+ }
+ if (!argp9) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBoost_train" "', argument " "9"" of type '" "CvBoostParams""'");
+ } else {
+ arg9 = *((CvBoostParams *)(argp9));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8,arg9);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_train__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ CvMat *arg8 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoost_train",args.length(),8,8,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_train" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoost_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoost_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoost_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBoost_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvBoost_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ res8 = SWIG_ConvertPtr(args(7), &argp8,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "CvBoost_train" "', argument " "8"" of type '" "CvMat const *""'");
+ }
+ arg8 = (CvMat *)(argp8);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7,(CvMat const *)arg8);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_train__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ CvMat *arg7 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoost_train",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_train" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoost_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoost_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoost_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBoost_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "CvBoost_train" "', argument " "7"" of type '" "CvMat const *""'");
+ }
+ arg7 = (CvMat *)(argp7);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6,(CvMat const *)arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_train__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoost_train",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_train" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoost_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoost_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoost_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvBoost_train" "', argument " "6"" of type '" "CvMat const *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5,(CvMat const *)arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_train__SWIG_5 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoost_train",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_train" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoost_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoost_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoost_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_train__SWIG_6 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoost_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_train" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoost_train" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoost_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (bool)(arg1)->train((CvMat const *)arg2,arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_train__SWIG_7 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ CvBoostParams arg3 ;
+ bool arg4 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 ;
+ int res3 = 0 ;
+ bool val4 ;
+ int ecode4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoost_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_train" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_train" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ {
+ res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_CvBoostParams, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoost_train" "', argument " "3"" of type '" "CvBoostParams""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBoost_train" "', argument " "3"" of type '" "CvBoostParams""'");
+ } else {
+ arg3 = *((CvBoostParams *)(argp3));
+ }
+ }
+ ecode4 = SWIG_AsVal_bool(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvBoost_train" "', argument " "4"" of type '" "bool""'");
+ }
+ arg4 = (bool)(val4);
+ {
+ try {
+ result = (bool)(arg1)->train(arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_train__SWIG_8 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ CvBoostParams arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoost_train",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_train" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_train" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ {
+ res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_CvBoostParams, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoost_train" "', argument " "3"" of type '" "CvBoostParams""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBoost_train" "', argument " "3"" of type '" "CvBoostParams""'");
+ } else {
+ arg3 = *((CvBoostParams *)(argp3));
+ }
+ }
+ {
+ try {
+ result = (bool)(arg1)->train(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_train__SWIG_9 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvBoost_train",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_train" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_train" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ {
+ try {
+ result = (bool)(arg1)->train(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_train (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[10]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6),octave_value_ref(args,7),octave_value_ref(args,8),octave_value_ref(args,9)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_train__SWIG_9(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvBoostParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_train__SWIG_8(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_train__SWIG_6(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvBoostParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[3], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvBoost_train__SWIG_7(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_train__SWIG_5(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_train__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_train__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 8) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_train__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 9) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvBoostParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_train__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 10) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CvBoostParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[9], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvBoost_train__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvBoost_predict__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvSlice arg5 ;
+ bool arg6 ;
+ bool arg7 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 ;
+ int res5 = 0 ;
+ bool val6 ;
+ int ecode6 = 0 ;
+ bool val7 ;
+ int ecode7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvBoost_predict",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_predict" "', argument " "1"" of type '" "CvBoost const *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoost_predict" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoost_predict" "', argument " "4"" of type '" "CvMat *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ res5 = SWIG_ConvertPtr(args(4), &argp5, SWIGTYPE_p_CvSlice, 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoost_predict" "', argument " "5"" of type '" "CvSlice""'");
+ }
+ if (!argp5) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBoost_predict" "', argument " "5"" of type '" "CvSlice""'");
+ } else {
+ arg5 = *((CvSlice *)(argp5));
+ }
+ }
+ ecode6 = SWIG_AsVal_bool(args(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvBoost_predict" "', argument " "6"" of type '" "bool""'");
+ }
+ arg6 = (bool)(val6);
+ ecode7 = SWIG_AsVal_bool(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvBoost_predict" "', argument " "7"" of type '" "bool""'");
+ }
+ arg7 = (bool)(val7);
+ {
+ try {
+ result = (float)((CvBoost const *)arg1)->predict((CvMat const *)arg2,(CvMat const *)arg3,arg4,arg5,arg6,arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_predict__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvSlice arg5 ;
+ bool arg6 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 ;
+ int res5 = 0 ;
+ bool val6 ;
+ int ecode6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvBoost_predict",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_predict" "', argument " "1"" of type '" "CvBoost const *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoost_predict" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoost_predict" "', argument " "4"" of type '" "CvMat *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ res5 = SWIG_ConvertPtr(args(4), &argp5, SWIGTYPE_p_CvSlice, 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoost_predict" "', argument " "5"" of type '" "CvSlice""'");
+ }
+ if (!argp5) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBoost_predict" "', argument " "5"" of type '" "CvSlice""'");
+ } else {
+ arg5 = *((CvSlice *)(argp5));
+ }
+ }
+ ecode6 = SWIG_AsVal_bool(args(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CvBoost_predict" "', argument " "6"" of type '" "bool""'");
+ }
+ arg6 = (bool)(val6);
+ {
+ try {
+ result = (float)((CvBoost const *)arg1)->predict((CvMat const *)arg2,(CvMat const *)arg3,arg4,arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_predict__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvSlice arg5 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvBoost_predict",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_predict" "', argument " "1"" of type '" "CvBoost const *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoost_predict" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoost_predict" "', argument " "4"" of type '" "CvMat *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ res5 = SWIG_ConvertPtr(args(4), &argp5, SWIGTYPE_p_CvSlice, 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvBoost_predict" "', argument " "5"" of type '" "CvSlice""'");
+ }
+ if (!argp5) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBoost_predict" "', argument " "5"" of type '" "CvSlice""'");
+ } else {
+ arg5 = *((CvSlice *)(argp5));
+ }
+ }
+ {
+ try {
+ result = (float)((CvBoost const *)arg1)->predict((CvMat const *)arg2,(CvMat const *)arg3,arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_predict__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvBoost_predict",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_predict" "', argument " "1"" of type '" "CvBoost const *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoost_predict" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoost_predict" "', argument " "4"" of type '" "CvMat *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (float)((CvBoost const *)arg1)->predict((CvMat const *)arg2,(CvMat const *)arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_predict__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvBoost_predict",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_predict" "', argument " "1"" of type '" "CvBoost const *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoost_predict" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (float)((CvBoost const *)arg1)->predict((CvMat const *)arg2,(CvMat const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_predict__SWIG_5 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvBoost_predict",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_predict" "', argument " "1"" of type '" "CvBoost const *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ result = (float)((CvBoost const *)arg1)->predict((CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_predict (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[7]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_predict__SWIG_5(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_predict__SWIG_4(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_predict__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvSlice, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_predict__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvSlice, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[5], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvBoost_predict__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvSlice, 0);
+ _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_CvBoost_predict__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvBoost_calc_error__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ int arg3 ;
+ vector< float > *arg4 = (vector< float > *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvBoost_calc_error",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_calc_error" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_calc_error" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoost_calc_error" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_vectorT_float_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvBoost_calc_error" "', argument " "4"" of type '" "vector< float > *""'");
+ }
+ arg4 = (vector< float > *)(argp4);
+ {
+ try {
+ result = (float)(arg1)->calc_error(arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_calc_error__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvMLData *arg2 = (CvMLData *) 0 ;
+ int arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvBoost_calc_error",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_calc_error" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_calc_error" "', argument " "2"" of type '" "CvMLData *""'");
+ }
+ arg2 = (CvMLData *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvBoost_calc_error" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ try {
+ result = (float)(arg1)->calc_error(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_calc_error (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[4]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3)
+ };
+
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvBoost_calc_error__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMLData, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_vectorT_float_t, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_calc_error__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvBoost_prune (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvSlice arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvBoost_prune",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_prune" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ {
+ res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSlice, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_prune" "', argument " "2"" of type '" "CvSlice""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvBoost_prune" "', argument " "2"" of type '" "CvSlice""'");
+ } else {
+ arg2 = *((CvSlice *)(argp2));
+ }
+ }
+ {
+ try {
+ (arg1)->prune(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_clear (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvBoost_clear",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_clear" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ {
+ try {
+ (arg1)->clear();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_write (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ char *arg3 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvBoost_write",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_write" "', argument " "1"" of type '" "CvBoost const *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_write" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoost_write" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ {
+ try {
+ ((CvBoost const *)arg1)->write(arg2,(char const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_read (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvBoost_read",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_read" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBoost_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvBoost_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ {
+ try {
+ (arg1)->read(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_get_active_vars__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvBoost_get_active_vars",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_get_active_vars" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ ecode2 = SWIG_AsVal_bool(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBoost_get_active_vars" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = (bool)(val2);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_active_vars(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_get_active_vars__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvBoost_get_active_vars",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_get_active_vars" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_active_vars();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_get_active_vars (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[2]={
+ octave_value_ref(args,0),octave_value_ref(args,1)
+ };
+
+ if (argc == 1) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvBoost_get_active_vars__SWIG_1(args, nargout);
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvBoost, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvBoost_get_active_vars__SWIG_0(args, nargout);
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvBoost_get_weak_predictors (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvSeq *result = 0 ;
+
+ if (!SWIG_check_num_args("CvBoost_get_weak_predictors",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_get_weak_predictors" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ {
+ try {
+ result = (CvSeq *)(arg1)->get_weak_predictors();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_get_weights (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvBoost_get_weights",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_get_weights" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_weights();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_get_subtree_weights (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvBoost_get_subtree_weights",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_get_subtree_weights" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_subtree_weights();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_get_weak_response (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvBoost_get_weak_response",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_get_weak_response" "', argument " "1"" of type '" "CvBoost *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_weak_response();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_get_params (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvBoostParams *result = 0 ;
+
+ if (!SWIG_check_num_args("CvBoost_get_params",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_get_params" "', argument " "1"" of type '" "CvBoost const *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ {
+ try {
+ result = (CvBoostParams *) &((CvBoost const *)arg1)->get_params();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBoostParams, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvBoost_get_data (const octave_value_list& args, int nargout) {
+ CvBoost *arg1 = (CvBoost *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvDTreeTrainData *result = 0 ;
+
+ if (!SWIG_check_num_args("CvBoost_get_data",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBoost, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBoost_get_data" "', argument " "1"" of type '" "CvBoost const *""'");
+ }
+ arg1 = (CvBoost *)(argp1);
+ {
+ try {
+ result = (CvDTreeTrainData *)((CvBoost const *)arg1)->get_data();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvDTreeTrainData, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvBoost_members[] = {
+{"train",_wrap_CvBoost_train,0,0,0,0},
+{"predict",_wrap_CvBoost_predict,0,0,0,0},
+{"calc_error",_wrap_CvBoost_calc_error,0,0,0,0},
+{"prune",_wrap_CvBoost_prune,0,0,0,0},
+{"clear",_wrap_CvBoost_clear,0,0,0,0},
+{"write",_wrap_CvBoost_write,0,0,0,0},
+{"read",_wrap_CvBoost_read,0,0,0,0},
+{"get_active_vars",_wrap_CvBoost_get_active_vars,0,0,0,0},
+{"get_weak_predictors",_wrap_CvBoost_get_weak_predictors,0,0,0,0},
+{"get_weights",_wrap_CvBoost_get_weights,0,0,0,0},
+{"get_subtree_weights",_wrap_CvBoost_get_subtree_weights,0,0,0,0},
+{"get_weak_response",_wrap_CvBoost_get_weak_response,0,0,0,0},
+{"get_params",_wrap_CvBoost_get_params,0,0,0,0},
+{"get_data",_wrap_CvBoost_get_data,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvBoost_base_names[] = {"_p_CvStatModel",0};
+static const swig_type_info *swig_CvBoost_base[] = {0,0};
+static swig_octave_class _wrap_class_CvBoost = {"CvBoost", &SWIGTYPE_p_CvBoost,0,_wrap_new_CvBoost,0,_wrap_delete_CvBoost,swig_CvBoost_members,swig_CvBoost_base_names,swig_CvBoost_base };
+
+static octave_value_list _wrap_new_CvANN_MLP_TrainParams__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvANN_MLP_TrainParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvANN_MLP_TrainParams",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvANN_MLP_TrainParams *)new CvANN_MLP_TrainParams();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvANN_MLP_TrainParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvANN_MLP_TrainParams__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvTermCriteria arg1 ;
+ int arg2 ;
+ double arg3 ;
+ double arg4 ;
+ void *argp1 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvANN_MLP_TrainParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvANN_MLP_TrainParams",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ {
+ res1 = SWIG_ConvertPtr(args(0), &argp1, SWIGTYPE_p_CvTermCriteria, 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvANN_MLP_TrainParams" "', argument " "1"" of type '" "CvTermCriteria""'");
+ }
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvANN_MLP_TrainParams" "', argument " "1"" of type '" "CvTermCriteria""'");
+ } else {
+ arg1 = *((CvTermCriteria *)(argp1));
+ }
+ }
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvANN_MLP_TrainParams" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvANN_MLP_TrainParams" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ ecode4 = SWIG_AsVal_double(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvANN_MLP_TrainParams" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = (double)(val4);
+ {
+ try {
+ result = (CvANN_MLP_TrainParams *)new CvANN_MLP_TrainParams(arg1,arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvANN_MLP_TrainParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvANN_MLP_TrainParams__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvTermCriteria arg1 ;
+ int arg2 ;
+ double arg3 ;
+ void *argp1 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvANN_MLP_TrainParams *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvANN_MLP_TrainParams",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ {
+ res1 = SWIG_ConvertPtr(args(0), &argp1, SWIGTYPE_p_CvTermCriteria, 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvANN_MLP_TrainParams" "', argument " "1"" of type '" "CvTermCriteria""'");
+ }
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvANN_MLP_TrainParams" "', argument " "1"" of type '" "CvTermCriteria""'");
+ } else {
+ arg1 = *((CvTermCriteria *)(argp1));
+ }
+ }
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvANN_MLP_TrainParams" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvANN_MLP_TrainParams" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ {
+ try {
+ result = (CvANN_MLP_TrainParams *)new CvANN_MLP_TrainParams(arg1,arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvANN_MLP_TrainParams, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvANN_MLP_TrainParams (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[4]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvANN_MLP_TrainParams__SWIG_0(args, nargout);
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvTermCriteria, 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_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvANN_MLP_TrainParams__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvTermCriteria, 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_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[3], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvANN_MLP_TrainParams__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_delete_CvANN_MLP_TrainParams (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvANN_MLP_TrainParams",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvANN_MLP_TrainParams" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_term_crit_set (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ CvTermCriteria *arg2 = (CvTermCriteria *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_term_crit_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_term_crit_set" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTermCriteria, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvANN_MLP_TrainParams_term_crit_set" "', argument " "2"" of type '" "CvTermCriteria *""'");
+ }
+ arg2 = (CvTermCriteria *)(argp2);
+ if (arg1) (arg1)->term_crit = *arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_term_crit_get (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvTermCriteria *result = 0 ;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_term_crit_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_term_crit_get" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ result = (CvTermCriteria *)& ((arg1)->term_crit);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTermCriteria, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_train_method_set (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_train_method_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_train_method_set" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvANN_MLP_TrainParams_train_method_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->train_method = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_train_method_get (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_train_method_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_train_method_get" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ result = (int) ((arg1)->train_method);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_bp_dw_scale_set (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_bp_dw_scale_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_bp_dw_scale_set" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvANN_MLP_TrainParams_bp_dw_scale_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->bp_dw_scale = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_bp_dw_scale_get (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_bp_dw_scale_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_bp_dw_scale_get" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ result = (double) ((arg1)->bp_dw_scale);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_bp_moment_scale_set (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_bp_moment_scale_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_bp_moment_scale_set" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvANN_MLP_TrainParams_bp_moment_scale_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->bp_moment_scale = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_bp_moment_scale_get (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_bp_moment_scale_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_bp_moment_scale_get" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ result = (double) ((arg1)->bp_moment_scale);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_rp_dw0_set (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_rp_dw0_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_rp_dw0_set" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvANN_MLP_TrainParams_rp_dw0_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->rp_dw0 = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_rp_dw0_get (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_rp_dw0_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_rp_dw0_get" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ result = (double) ((arg1)->rp_dw0);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_rp_dw_plus_set (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_rp_dw_plus_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_rp_dw_plus_set" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvANN_MLP_TrainParams_rp_dw_plus_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->rp_dw_plus = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_rp_dw_plus_get (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_rp_dw_plus_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_rp_dw_plus_get" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ result = (double) ((arg1)->rp_dw_plus);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_rp_dw_minus_set (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_rp_dw_minus_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_rp_dw_minus_set" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvANN_MLP_TrainParams_rp_dw_minus_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->rp_dw_minus = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_rp_dw_minus_get (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_rp_dw_minus_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_rp_dw_minus_get" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ result = (double) ((arg1)->rp_dw_minus);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_rp_dw_min_set (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_rp_dw_min_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_rp_dw_min_set" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvANN_MLP_TrainParams_rp_dw_min_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->rp_dw_min = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_rp_dw_min_get (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_rp_dw_min_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_rp_dw_min_get" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ result = (double) ((arg1)->rp_dw_min);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_rp_dw_max_set (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ double arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_rp_dw_max_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_rp_dw_max_set" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ ecode2 = SWIG_AsVal_double(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvANN_MLP_TrainParams_rp_dw_max_set" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ if (arg1) (arg1)->rp_dw_max = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_TrainParams_rp_dw_max_get (const octave_value_list& args, int nargout) {
+ CvANN_MLP_TrainParams *arg1 = (CvANN_MLP_TrainParams *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_TrainParams_rp_dw_max_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP_TrainParams, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_TrainParams_rp_dw_max_get" "', argument " "1"" of type '" "CvANN_MLP_TrainParams *""'");
+ }
+ arg1 = (CvANN_MLP_TrainParams *)(argp1);
+ result = (double) ((arg1)->rp_dw_max);
+ _outv = SWIG_From_double((double)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvANN_MLP_TrainParams_members[] = {
+{"term_crit",0,_wrap_CvANN_MLP_TrainParams_term_crit_get,_wrap_CvANN_MLP_TrainParams_term_crit_set,0,0},
+{"train_method",0,_wrap_CvANN_MLP_TrainParams_train_method_get,_wrap_CvANN_MLP_TrainParams_train_method_set,0,0},
+{"bp_dw_scale",0,_wrap_CvANN_MLP_TrainParams_bp_dw_scale_get,_wrap_CvANN_MLP_TrainParams_bp_dw_scale_set,0,0},
+{"bp_moment_scale",0,_wrap_CvANN_MLP_TrainParams_bp_moment_scale_get,_wrap_CvANN_MLP_TrainParams_bp_moment_scale_set,0,0},
+{"rp_dw0",0,_wrap_CvANN_MLP_TrainParams_rp_dw0_get,_wrap_CvANN_MLP_TrainParams_rp_dw0_set,0,0},
+{"rp_dw_plus",0,_wrap_CvANN_MLP_TrainParams_rp_dw_plus_get,_wrap_CvANN_MLP_TrainParams_rp_dw_plus_set,0,0},
+{"rp_dw_minus",0,_wrap_CvANN_MLP_TrainParams_rp_dw_minus_get,_wrap_CvANN_MLP_TrainParams_rp_dw_minus_set,0,0},
+{"rp_dw_min",0,_wrap_CvANN_MLP_TrainParams_rp_dw_min_get,_wrap_CvANN_MLP_TrainParams_rp_dw_min_set,0,0},
+{"rp_dw_max",0,_wrap_CvANN_MLP_TrainParams_rp_dw_max_get,_wrap_CvANN_MLP_TrainParams_rp_dw_max_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvANN_MLP_TrainParams_base_names[] = {0};
+static const swig_type_info *swig_CvANN_MLP_TrainParams_base[] = {0};
+static swig_octave_class _wrap_class_CvANN_MLP_TrainParams = {"CvANN_MLP_TrainParams", &SWIGTYPE_p_CvANN_MLP_TrainParams,0,_wrap_new_CvANN_MLP_TrainParams,0,_wrap_delete_CvANN_MLP_TrainParams,swig_CvANN_MLP_TrainParams_members,swig_CvANN_MLP_TrainParams_base_names,swig_CvANN_MLP_TrainParams_base };
+
+static octave_value_list _wrap_new_CvANN_MLP__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvANN_MLP *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvANN_MLP",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvANN_MLP *)new CvANN_MLP();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvANN_MLP, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvANN_MLP__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ double arg3 ;
+ double arg4 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvANN_MLP *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvANN_MLP",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvANN_MLP" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvANN_MLP" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvANN_MLP" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ ecode4 = SWIG_AsVal_double(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CvANN_MLP" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = (double)(val4);
+ {
+ try {
+ result = (CvANN_MLP *)new CvANN_MLP((CvMat const *)arg1,arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvANN_MLP, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvANN_MLP__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ double arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvANN_MLP *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvANN_MLP",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvANN_MLP" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvANN_MLP" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvANN_MLP" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ {
+ try {
+ result = (CvANN_MLP *)new CvANN_MLP((CvMat const *)arg1,arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvANN_MLP, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvANN_MLP__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvANN_MLP *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvANN_MLP",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvANN_MLP" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvANN_MLP" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ {
+ try {
+ result = (CvANN_MLP *)new CvANN_MLP((CvMat const *)arg1,arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvANN_MLP, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvANN_MLP__SWIG_4 (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvANN_MLP *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvANN_MLP",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvANN_MLP" "', argument " "1"" of type '" "CvMat const *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ {
+ try {
+ result = (CvANN_MLP *)new CvANN_MLP((CvMat const *)arg1);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvANN_MLP, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvANN_MLP (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[4]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvANN_MLP__SWIG_0(args, nargout);
+ }
+ if (argc == 1) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_new_CvANN_MLP__SWIG_4(args, nargout);
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvANN_MLP__SWIG_3(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 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_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvANN_MLP__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 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_double(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[3], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvANN_MLP__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_delete_CvANN_MLP (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvANN_MLP",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvANN_MLP" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_create__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ double arg4 ;
+ double arg5 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ double val5 ;
+ int ecode5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_create",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_create" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvANN_MLP_create" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvANN_MLP_create" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_double(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvANN_MLP_create" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = (double)(val4);
+ ecode5 = SWIG_AsVal_double(args(4), &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CvANN_MLP_create" "', argument " "5"" of type '" "double""'");
+ }
+ arg5 = (double)(val5);
+ {
+ try {
+ (arg1)->create((CvMat const *)arg2,arg3,arg4,arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_create__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ double arg4 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_create",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_create" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvANN_MLP_create" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvANN_MLP_create" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_double(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvANN_MLP_create" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = (double)(val4);
+ {
+ try {
+ (arg1)->create((CvMat const *)arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_create__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ int arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_create",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_create" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvANN_MLP_create" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvANN_MLP_create" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ try {
+ (arg1)->create((CvMat const *)arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_create__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_create",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_create" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvANN_MLP_create" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ {
+ try {
+ (arg1)->create((CvMat const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_create (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[5]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4)
+ };
+
+ if (argc == 2) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvANN_MLP, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvANN_MLP_create__SWIG_3(args, nargout);
+ }
+ }
+ }
+ if (argc == 3) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvANN_MLP, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvANN_MLP_create__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvANN_MLP, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[3], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvANN_MLP_create__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvANN_MLP, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[2], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[3], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_double(argv[4], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvANN_MLP_create__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_train__SWIG_0 (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvANN_MLP_TrainParams arg6 ;
+ int arg7 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 ;
+ int res6 = 0 ;
+ int val7 ;
+ int ecode7 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_train",args.length(),7,7,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_train" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvANN_MLP_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvANN_MLP_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvANN_MLP_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvANN_MLP_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ res6 = SWIG_ConvertPtr(args(5), &argp6, SWIGTYPE_p_CvANN_MLP_TrainParams, 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvANN_MLP_train" "', argument " "6"" of type '" "CvANN_MLP_TrainParams""'");
+ }
+ if (!argp6) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvANN_MLP_train" "', argument " "6"" of type '" "CvANN_MLP_TrainParams""'");
+ } else {
+ arg6 = *((CvANN_MLP_TrainParams *)(argp6));
+ }
+ }
+ ecode7 = SWIG_AsVal_int(args(6), &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CvANN_MLP_train" "', argument " "7"" of type '" "int""'");
+ }
+ arg7 = (int)(val7);
+ {
+ try {
+ result = (int)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6,arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_train__SWIG_1 (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvANN_MLP_TrainParams arg6 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_train",args.length(),6,6,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_train" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvANN_MLP_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvANN_MLP_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvANN_MLP_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvANN_MLP_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ res6 = SWIG_ConvertPtr(args(5), &argp6, SWIGTYPE_p_CvANN_MLP_TrainParams, 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CvANN_MLP_train" "', argument " "6"" of type '" "CvANN_MLP_TrainParams""'");
+ }
+ if (!argp6) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvANN_MLP_train" "', argument " "6"" of type '" "CvANN_MLP_TrainParams""'");
+ } else {
+ arg6 = *((CvANN_MLP_TrainParams *)(argp6));
+ }
+ }
+ {
+ try {
+ result = (int)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_train__SWIG_2 (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_train",args.length(),5,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_train" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvANN_MLP_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvANN_MLP_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvANN_MLP_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CvANN_MLP_train" "', argument " "5"" of type '" "CvMat const *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ {
+ try {
+ result = (int)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4,(CvMat const *)arg5);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_train__SWIG_3 (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvMat *arg4 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_train",args.length(),4,4,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_train" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvANN_MLP_train" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvANN_MLP_train" "', argument " "3"" of type '" "CvMat const *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvANN_MLP_train" "', argument " "4"" of type '" "CvMat const *""'");
+ }
+ arg4 = (CvMat *)(argp4);
+ {
+ try {
+ result = (int)(arg1)->train((CvMat const *)arg2,(CvMat const *)arg3,(CvMat const *)arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_train (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[7]={
+ octave_value_ref(args,0),octave_value_ref(args,1),octave_value_ref(args,2),octave_value_ref(args,3),octave_value_ref(args,4),octave_value_ref(args,5),octave_value_ref(args,6)
+ };
+
+ if (argc == 4) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvANN_MLP, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvANN_MLP_train__SWIG_3(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ if (argc == 5) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvANN_MLP, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvANN_MLP_train__SWIG_2(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 6) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvANN_MLP, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvANN_MLP_TrainParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ return _wrap_CvANN_MLP_train__SWIG_1(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (argc == 7) {
+ int _v;
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvANN_MLP, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CvMat, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ void *vptr = 0;
+ int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvANN_MLP_TrainParams, 0);
+ _v = SWIG_CheckState(res);
+ if (_v) {
+ {
+ int res = SWIG_AsVal_int(argv[6], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_CvANN_MLP_train__SWIG_0(args, nargout);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_predict (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_predict",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_predict" "', argument " "1"" of type '" "CvANN_MLP const *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvANN_MLP_predict" "', argument " "2"" of type '" "CvMat const *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvANN_MLP_predict" "', argument " "3"" of type '" "CvMat *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ {
+ try {
+ result = (float)((CvANN_MLP const *)arg1)->predict((CvMat const *)arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_clear (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_clear",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_clear" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ {
+ try {
+ (arg1)->clear();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_read (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ CvFileNode *arg3 = (CvFileNode *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_read",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_read" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvANN_MLP_read" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvFileNode, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvANN_MLP_read" "', argument " "3"" of type '" "CvFileNode *""'");
+ }
+ arg3 = (CvFileNode *)(argp3);
+ {
+ try {
+ (arg1)->read(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_write (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ CvFileStorage *arg2 = (CvFileStorage *) 0 ;
+ char *arg3 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvANN_MLP_write",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_write" "', argument " "1"" of type '" "CvANN_MLP const *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvANN_MLP_write" "', argument " "2"" of type '" "CvFileStorage *""'");
+ }
+ arg2 = (CvFileStorage *)(argp2);
+ res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvANN_MLP_write" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ {
+ try {
+ ((CvANN_MLP const *)arg1)->write(arg2,(char const *)arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+ if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_get_layer_count (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvANN_MLP_get_layer_count",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_get_layer_count" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ {
+ try {
+ result = (int)(arg1)->get_layer_count();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_get_layer_sizes (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvANN_MLP_get_layer_sizes",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_get_layer_sizes" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_layer_sizes();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvANN_MLP_get_weights (const octave_value_list& args, int nargout) {
+ CvANN_MLP *arg1 = (CvANN_MLP *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ double *result = 0 ;
+
+ if (!SWIG_check_num_args("CvANN_MLP_get_weights",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvANN_MLP, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvANN_MLP_get_weights" "', argument " "1"" of type '" "CvANN_MLP *""'");
+ }
+ arg1 = (CvANN_MLP *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvANN_MLP_get_weights" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ {
+ try {
+ result = (double *)(arg1)->get_weights(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvANN_MLP_members[] = {
+{"create",_wrap_CvANN_MLP_create,0,0,0,0},
+{"train",_wrap_CvANN_MLP_train,0,0,0,0},
+{"predict",_wrap_CvANN_MLP_predict,0,0,0,0},
+{"clear",_wrap_CvANN_MLP_clear,0,0,0,0},
+{"read",_wrap_CvANN_MLP_read,0,0,0,0},
+{"write",_wrap_CvANN_MLP_write,0,0,0,0},
+{"get_layer_count",_wrap_CvANN_MLP_get_layer_count,0,0,0,0},
+{"get_layer_sizes",_wrap_CvANN_MLP_get_layer_sizes,0,0,0,0},
+{"get_weights",_wrap_CvANN_MLP_get_weights,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvANN_MLP_base_names[] = {"_p_CvStatModel",0};
+static const swig_type_info *swig_CvANN_MLP_base[] = {0,0};
+static swig_octave_class _wrap_class_CvANN_MLP = {"CvANN_MLP", &SWIGTYPE_p_CvANN_MLP,0,_wrap_new_CvANN_MLP,0,_wrap_delete_CvANN_MLP,swig_CvANN_MLP_members,swig_CvANN_MLP_base_names,swig_CvANN_MLP_base };
+
+static octave_value_list _wrap_cvRandMVNormal (const octave_value_list& args, int nargout) {
+ CvMat *arg1 = (CvMat *) 0 ;
+ CvMat *arg2 = (CvMat *) 0 ;
+ CvMat *arg3 = (CvMat *) 0 ;
+ CvRNG *arg4 = (CvRNG *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *vptr4 ;
+ CvRNG_Wrapper *wrapper4 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("cvRandMVNormal",args.length(),4,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRandMVNormal" "', argument " "1"" of type '" "CvMat *""'");
+ }
+ arg1 = (CvMat *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvRandMVNormal" "', argument " "2"" of type '" "CvMat *""'");
+ }
+ arg2 = (CvMat *)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvRandMVNormal" "', argument " "3"" of type '" "CvMat *""'");
+ }
+ arg3 = (CvMat *)(argp3);
+ if (3<args.length()) {
+ {
+ if(SWIG_ConvertPtr(args(3), &vptr4, SWIGTYPE_p_CvRNG_Wrapper, 0)==-1){
+ SWIG_exception( SWIG_TypeError, "could not convert Octave object to C value");
+ SWIG_fail;
+ }
+ wrapper4 = (CvRNG_Wrapper *) vptr4;
+ arg4 = wrapper4->ptr();
+ }
+ }
+ {
+ try {
+ cvRandMVNormal(arg1,arg2,arg3,arg4);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_cvRandGaussMixture (const octave_value_list& args, int nargout) {
+ CvMat **arg1 ;
+ CvMat **arg2 ;
+ float *arg3 ;
+ int arg4 ;
+ CvMat *arg5 = (CvMat *) 0 ;
+ CvMat *arg6 = (CvMat *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("cvRandGaussMixture",args.length(),6,5,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRandGaussMixture" "', argument " "1"" of type '" "CvMat *[]""'");
+ }
+ arg1 = (CvMat **)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvRandGaussMixture" "', argument " "2"" of type '" "CvMat *[]""'");
+ }
+ arg2 = (CvMat **)(argp2);
+ res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvRandGaussMixture" "', argument " "3"" of type '" "float []""'");
+ }
+ arg3 = (float *)(argp3);
+ ecode4 = SWIG_AsVal_int(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvRandGaussMixture" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvRandGaussMixture" "', argument " "5"" of type '" "CvMat *""'");
+ }
+ arg5 = (CvMat *)(argp5);
+ if (5<args.length()) {
+ res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvRandGaussMixture" "', argument " "6"" of type '" "CvMat *""'");
+ }
+ arg6 = (CvMat *)(argp6);
+ }
+ {
+ try {
+ cvRandGaussMixture(arg1,arg2,arg3,arg4,arg5,arg6);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_cvCreateTestSet (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ CvMat **arg2 = (CvMat **) 0 ;
+ int arg3 ;
+ int arg4 ;
+ CvMat **arg5 = (CvMat **) 0 ;
+ int arg6 ;
+ void *arg7 = 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ int val6 ;
+ int ecode6 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("cvCreateTestSet",args.length(),6,6,1)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCreateTestSet" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvCreateTestSet" "', argument " "2"" of type '" "CvMat **""'");
+ }
+ arg2 = (CvMat **)(argp2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvCreateTestSet" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(args(3), &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCreateTestSet" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_p_CvMat, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvCreateTestSet" "', argument " "5"" of type '" "CvMat **""'");
+ }
+ arg5 = (CvMat **)(argp5);
+ ecode6 = SWIG_AsVal_int(args(5), &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvCreateTestSet" "', argument " "6"" of type '" "int""'");
+ }
+ arg6 = (int)(val6);
+ {
+ try {
+ cvCreateTestSet(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvTrainTestSplit__SWIG_0 (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvTrainTestSplit *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvTrainTestSplit",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvTrainTestSplit *)new CvTrainTestSplit();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTrainTestSplit, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvTrainTestSplit__SWIG_1 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ bool arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvTrainTestSplit *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvTrainTestSplit",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvTrainTestSplit" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_bool(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvTrainTestSplit" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = (bool)(val2);
+ {
+ try {
+ result = (CvTrainTestSplit *)new CvTrainTestSplit(arg1,arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTrainTestSplit, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvTrainTestSplit__SWIG_2 (const octave_value_list& args, int nargout) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvTrainTestSplit *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvTrainTestSplit",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvTrainTestSplit" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ {
+ try {
+ result = (CvTrainTestSplit *)new CvTrainTestSplit(arg1);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTrainTestSplit, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvTrainTestSplit__SWIG_3 (const octave_value_list& args, int nargout) {
+ float arg1 ;
+ bool arg2 ;
+ float val1 ;
+ int ecode1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvTrainTestSplit *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvTrainTestSplit",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_float(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvTrainTestSplit" "', argument " "1"" of type '" "float""'");
+ }
+ arg1 = (float)(val1);
+ ecode2 = SWIG_AsVal_bool(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CvTrainTestSplit" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = (bool)(val2);
+ {
+ try {
+ result = (CvTrainTestSplit *)new CvTrainTestSplit(arg1,arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTrainTestSplit, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvTrainTestSplit__SWIG_4 (const octave_value_list& args, int nargout) {
+ float arg1 ;
+ float val1 ;
+ int ecode1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvTrainTestSplit *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvTrainTestSplit",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_float(args(0), &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvTrainTestSplit" "', argument " "1"" of type '" "float""'");
+ }
+ arg1 = (float)(val1);
+ {
+ try {
+ result = (CvTrainTestSplit *)new CvTrainTestSplit(arg1);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTrainTestSplit, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvTrainTestSplit (const octave_value_list& args, int nargout) {
+ int argc = args.length();
+ octave_value_ref argv[2]={
+ octave_value_ref(args,0),octave_value_ref(args,1)
+ };
+
+ if (argc == 0) {
+ return _wrap_new_CvTrainTestSplit__SWIG_0(args, nargout);
+ }
+ if (argc == 1) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvTrainTestSplit__SWIG_2(args, nargout);
+ }
+ }
+ if (argc == 1) {
+ int _v;
+ {
+ int res = SWIG_AsVal_float(argv[0], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvTrainTestSplit__SWIG_4(args, nargout);
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ {
+ int res = SWIG_AsVal_int(argv[0], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvTrainTestSplit__SWIG_1(args, nargout);
+ }
+ }
+ }
+ if (argc == 2) {
+ int _v;
+ {
+ int res = SWIG_AsVal_float(argv[0], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ {
+ int res = SWIG_AsVal_bool(argv[1], NULL);
+ _v = SWIG_CheckState(res);
+ }
+ if (_v) {
+ return _wrap_new_CvTrainTestSplit__SWIG_3(args, nargout);
+ }
+ }
+ }
+
+ error("No matching function for overload");
+ return octave_value_list();
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_train_sample_part_mode_set (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit *arg1 = (CvTrainTestSplit *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_train_sample_part_mode_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_train_sample_part_mode_set" "', argument " "1"" of type '" "CvTrainTestSplit *""'");
+ }
+ arg1 = (CvTrainTestSplit *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTrainTestSplit_train_sample_part_mode_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->train_sample_part_mode = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_train_sample_part_mode_get (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit *arg1 = (CvTrainTestSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_train_sample_part_mode_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_train_sample_part_mode_get" "', argument " "1"" of type '" "CvTrainTestSplit *""'");
+ }
+ arg1 = (CvTrainTestSplit *)(argp1);
+ result = (int) ((arg1)->train_sample_part_mode);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_class_part_mode_set (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit *arg1 = (CvTrainTestSplit *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_class_part_mode_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_class_part_mode_set" "', argument " "1"" of type '" "CvTrainTestSplit *""'");
+ }
+ arg1 = (CvTrainTestSplit *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTrainTestSplit_class_part_mode_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->class_part_mode = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_class_part_mode_get (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit *arg1 = (CvTrainTestSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_class_part_mode_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_class_part_mode_get" "', argument " "1"" of type '" "CvTrainTestSplit *""'");
+ }
+ arg1 = (CvTrainTestSplit *)(argp1);
+ result = (int) ((arg1)->class_part_mode);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_mix_set (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit *arg1 = (CvTrainTestSplit *) 0 ;
+ bool arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ bool val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_mix_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_mix_set" "', argument " "1"" of type '" "CvTrainTestSplit *""'");
+ }
+ arg1 = (CvTrainTestSplit *)(argp1);
+ ecode2 = SWIG_AsVal_bool(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTrainTestSplit_mix_set" "', argument " "2"" of type '" "bool""'");
+ }
+ arg2 = (bool)(val2);
+ if (arg1) (arg1)->mix = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_mix_get (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit *arg1 = (CvTrainTestSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ bool result;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_mix_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_mix_get" "', argument " "1"" of type '" "CvTrainTestSplit *""'");
+ }
+ arg1 = (CvTrainTestSplit *)(argp1);
+ result = (bool) ((arg1)->mix);
+ _outv = SWIG_From_bool((bool)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_class_part_get (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit *arg1 = (CvTrainTestSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvTrainTestSplit_class_part *result = 0 ;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_class_part_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_class_part_get" "', argument " "1"" of type '" "CvTrainTestSplit *""'");
+ }
+ arg1 = (CvTrainTestSplit *)(argp1);
+ result = (CvTrainTestSplit_class_part *) ((arg1)->class_part);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTrainTestSplit_class_part, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_train_sample_part_get (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit *arg1 = (CvTrainTestSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvTrainTestSplit_train_sample_part *result = 0 ;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_train_sample_part_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_train_sample_part_get" "', argument " "1"" of type '" "CvTrainTestSplit *""'");
+ }
+ arg1 = (CvTrainTestSplit *)(argp1);
+ result = (CvTrainTestSplit_train_sample_part *)& ((arg1)->train_sample_part);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTrainTestSplit_train_sample_part, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvTrainTestSplit (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit *arg1 = (CvTrainTestSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvTrainTestSplit",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTrainTestSplit" "', argument " "1"" of type '" "CvTrainTestSplit *""'");
+ }
+ arg1 = (CvTrainTestSplit *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvTrainTestSplit_members[] = {
+{"train_sample_part_mode",0,_wrap_CvTrainTestSplit_train_sample_part_mode_get,_wrap_CvTrainTestSplit_train_sample_part_mode_set,0,0},
+{"class_part_mode",0,_wrap_CvTrainTestSplit_class_part_mode_get,_wrap_CvTrainTestSplit_class_part_mode_set,0,0},
+{"mix",0,_wrap_CvTrainTestSplit_mix_get,_wrap_CvTrainTestSplit_mix_set,0,0},
+{"class_part",0,_wrap_CvTrainTestSplit_class_part_get,octave_set_immutable,0,0},
+{"train_sample_part",0,_wrap_CvTrainTestSplit_train_sample_part_get,octave_set_immutable,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvTrainTestSplit_base_names[] = {0};
+static const swig_type_info *swig_CvTrainTestSplit_base[] = {0};
+static swig_octave_class _wrap_class_CvTrainTestSplit = {"CvTrainTestSplit", &SWIGTYPE_p_CvTrainTestSplit,0,_wrap_new_CvTrainTestSplit,0,_wrap_delete_CvTrainTestSplit,swig_CvTrainTestSplit_members,swig_CvTrainTestSplit_base_names,swig_CvTrainTestSplit_base };
+
+static octave_value_list _wrap_CvTrainTestSplit_class_part_count_set (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit_class_part *arg1 = (CvTrainTestSplit_class_part *) 0 ;
+ int *arg2 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_class_part_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit_class_part, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_class_part_count_set" "', argument " "1"" of type '" "CvTrainTestSplit_class_part *""'");
+ }
+ arg1 = (CvTrainTestSplit_class_part *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTrainTestSplit_class_part_count_set" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ if (arg1) (arg1)->count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_class_part_count_get (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit_class_part *arg1 = (CvTrainTestSplit_class_part *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int *result = 0 ;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_class_part_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit_class_part, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_class_part_count_get" "', argument " "1"" of type '" "CvTrainTestSplit_class_part *""'");
+ }
+ arg1 = (CvTrainTestSplit_class_part *)(argp1);
+ result = (int *) ((arg1)->count);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_class_part_portion_set (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit_class_part *arg1 = (CvTrainTestSplit_class_part *) 0 ;
+ float *arg2 = (float *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_class_part_portion_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit_class_part, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_class_part_portion_set" "', argument " "1"" of type '" "CvTrainTestSplit_class_part *""'");
+ }
+ arg1 = (CvTrainTestSplit_class_part *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTrainTestSplit_class_part_portion_set" "', argument " "2"" of type '" "float *""'");
+ }
+ arg2 = (float *)(argp2);
+ if (arg1) (arg1)->portion = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_class_part_portion_get (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit_class_part *arg1 = (CvTrainTestSplit_class_part *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float *result = 0 ;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_class_part_portion_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit_class_part, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_class_part_portion_get" "', argument " "1"" of type '" "CvTrainTestSplit_class_part *""'");
+ }
+ arg1 = (CvTrainTestSplit_class_part *)(argp1);
+ result = (float *) ((arg1)->portion);
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvTrainTestSplit_class_part (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvTrainTestSplit_class_part *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvTrainTestSplit_class_part",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvTrainTestSplit_class_part *)new CvTrainTestSplit_class_part();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTrainTestSplit_class_part, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvTrainTestSplit_class_part (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit_class_part *arg1 = (CvTrainTestSplit_class_part *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvTrainTestSplit_class_part",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit_class_part, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTrainTestSplit_class_part" "', argument " "1"" of type '" "CvTrainTestSplit_class_part *""'");
+ }
+ arg1 = (CvTrainTestSplit_class_part *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvTrainTestSplit_class_part_members[] = {
+{"count",0,_wrap_CvTrainTestSplit_class_part_count_get,_wrap_CvTrainTestSplit_class_part_count_set,0,0},
+{"portion",0,_wrap_CvTrainTestSplit_class_part_portion_get,_wrap_CvTrainTestSplit_class_part_portion_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvTrainTestSplit_class_part_base_names[] = {0};
+static const swig_type_info *swig_CvTrainTestSplit_class_part_base[] = {0};
+static swig_octave_class _wrap_class_CvTrainTestSplit_class_part = {"CvTrainTestSplit_class_part", &SWIGTYPE_p_CvTrainTestSplit_class_part,0,_wrap_new_CvTrainTestSplit_class_part,0,_wrap_delete_CvTrainTestSplit_class_part,swig_CvTrainTestSplit_class_part_members,swig_CvTrainTestSplit_class_part_base_names,swig_CvTrainTestSplit_class_part_base };
+
+static octave_value_list _wrap_CvTrainTestSplit_train_sample_part_count_set (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit_train_sample_part *arg1 = (CvTrainTestSplit_train_sample_part *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_train_sample_part_count_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit_train_sample_part, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_train_sample_part_count_set" "', argument " "1"" of type '" "CvTrainTestSplit_train_sample_part *""'");
+ }
+ arg1 = (CvTrainTestSplit_train_sample_part *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTrainTestSplit_train_sample_part_count_set" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->count = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_train_sample_part_count_get (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit_train_sample_part *arg1 = (CvTrainTestSplit_train_sample_part *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_train_sample_part_count_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit_train_sample_part, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_train_sample_part_count_get" "', argument " "1"" of type '" "CvTrainTestSplit_train_sample_part *""'");
+ }
+ arg1 = (CvTrainTestSplit_train_sample_part *)(argp1);
+ result = (int) ((arg1)->count);
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_train_sample_part_portion_set (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit_train_sample_part *arg1 = (CvTrainTestSplit_train_sample_part *) 0 ;
+ float arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ float val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_train_sample_part_portion_set",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit_train_sample_part, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_train_sample_part_portion_set" "', argument " "1"" of type '" "CvTrainTestSplit_train_sample_part *""'");
+ }
+ arg1 = (CvTrainTestSplit_train_sample_part *)(argp1);
+ ecode2 = SWIG_AsVal_float(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTrainTestSplit_train_sample_part_portion_set" "', argument " "2"" of type '" "float""'");
+ }
+ arg2 = (float)(val2);
+ if (arg1) (arg1)->portion = arg2;
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvTrainTestSplit_train_sample_part_portion_get (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit_train_sample_part *arg1 = (CvTrainTestSplit_train_sample_part *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ float result;
+
+ if (!SWIG_check_num_args("CvTrainTestSplit_train_sample_part_portion_get",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit_train_sample_part, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTrainTestSplit_train_sample_part_portion_get" "', argument " "1"" of type '" "CvTrainTestSplit_train_sample_part *""'");
+ }
+ arg1 = (CvTrainTestSplit_train_sample_part *)(argp1);
+ result = (float) ((arg1)->portion);
+ _outv = SWIG_From_float((float)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_new_CvTrainTestSplit_train_sample_part (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvTrainTestSplit_train_sample_part *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvTrainTestSplit_train_sample_part",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvTrainTestSplit_train_sample_part *)new CvTrainTestSplit_train_sample_part();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTrainTestSplit_train_sample_part, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvTrainTestSplit_train_sample_part (const octave_value_list& args, int nargout) {
+ CvTrainTestSplit_train_sample_part *arg1 = (CvTrainTestSplit_train_sample_part *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvTrainTestSplit_train_sample_part",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTrainTestSplit_train_sample_part, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTrainTestSplit_train_sample_part" "', argument " "1"" of type '" "CvTrainTestSplit_train_sample_part *""'");
+ }
+ arg1 = (CvTrainTestSplit_train_sample_part *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvTrainTestSplit_train_sample_part_members[] = {
+{"count",0,_wrap_CvTrainTestSplit_train_sample_part_count_get,_wrap_CvTrainTestSplit_train_sample_part_count_set,0,0},
+{"portion",0,_wrap_CvTrainTestSplit_train_sample_part_portion_get,_wrap_CvTrainTestSplit_train_sample_part_portion_set,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvTrainTestSplit_train_sample_part_base_names[] = {0};
+static const swig_type_info *swig_CvTrainTestSplit_train_sample_part_base[] = {0};
+static swig_octave_class _wrap_class_CvTrainTestSplit_train_sample_part = {"CvTrainTestSplit_train_sample_part", &SWIGTYPE_p_CvTrainTestSplit_train_sample_part,0,_wrap_new_CvTrainTestSplit_train_sample_part,0,_wrap_delete_CvTrainTestSplit_train_sample_part,swig_CvTrainTestSplit_train_sample_part_members,swig_CvTrainTestSplit_train_sample_part_base_names,swig_CvTrainTestSplit_train_sample_part_base };
+
+static octave_value_list _wrap_new_CvMLData (const octave_value_list& args, int nargout) {
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMLData *result = 0 ;
+
+ if (!SWIG_check_num_args("new_CvMLData",args.length(),0,0,0)) {
+ SWIG_fail;
+ }
+ {
+ try {
+ result = (CvMLData *)new CvMLData();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMLData, 1 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_delete_CvMLData (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("delete_CvMLData",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMLData" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ {
+ try {
+ delete arg1;
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_read_csv (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvMLData_read_csv",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_read_csv" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMLData_read_csv" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ {
+ try {
+ result = (int)(arg1)->read_csv((char const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_get_values (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvMLData_get_values",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_get_values" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_values();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_get_responses (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvMLData_get_responses",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_get_responses" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_responses();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_get_missing (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvMLData_get_missing",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_get_missing" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_missing();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_set_response_idx (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvMLData_set_response_idx",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_set_response_idx" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMLData_set_response_idx" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ {
+ try {
+ (arg1)->set_response_idx(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_get_response_idx (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvMLData_get_response_idx",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_get_response_idx" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ {
+ try {
+ result = (int)(arg1)->get_response_idx();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_get_train_sample_idx (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvMLData_get_train_sample_idx",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_get_train_sample_idx" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_train_sample_idx();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_get_test_sample_idx (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvMLData_get_test_sample_idx",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_get_test_sample_idx" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_test_sample_idx();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_mix_train_and_test_idx (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvMLData_mix_train_and_test_idx",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_mix_train_and_test_idx" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ {
+ try {
+ (arg1)->mix_train_and_test_idx();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_set_train_test_split (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ CvTrainTestSplit *arg2 = (CvTrainTestSplit *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvMLData_set_train_test_split",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_set_train_test_split" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTrainTestSplit, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMLData_set_train_test_split" "', argument " "2"" of type '" "CvTrainTestSplit const *""'");
+ }
+ arg2 = (CvTrainTestSplit *)(argp2);
+ {
+ try {
+ (arg1)->set_train_test_split((CvTrainTestSplit const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_get_var_idx (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvMLData_get_var_idx",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_get_var_idx" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_var_idx();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_chahge_var_idx (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ int arg2 ;
+ bool arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ bool val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvMLData_chahge_var_idx",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_chahge_var_idx" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMLData_chahge_var_idx" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_bool(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMLData_chahge_var_idx" "', argument " "3"" of type '" "bool""'");
+ }
+ arg3 = (bool)(val3);
+ {
+ try {
+ (arg1)->chahge_var_idx(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_get_var_types (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ CvMat *result = 0 ;
+
+ if (!SWIG_check_num_args("CvMLData_get_var_types",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_get_var_types" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ {
+ try {
+ result = (CvMat *)(arg1)->get_var_types();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 );
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_get_var_type (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ int result;
+
+ if (!SWIG_check_num_args("CvMLData_get_var_type",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_get_var_type" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMLData_get_var_type" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ {
+ try {
+ result = (int)(arg1)->get_var_type(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_int((int)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_set_var_types (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvMLData_set_var_types",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_set_var_types" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMLData_set_var_types" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ {
+ try {
+ (arg1)->set_var_types((char const *)arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+ if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_change_var_type (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvMLData_change_var_type",args.length(),3,3,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_change_var_type" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ ecode2 = SWIG_AsVal_int(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMLData_change_var_type" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(args(2), &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMLData_change_var_type" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ {
+ try {
+ (arg1)->change_var_type(arg2,arg3);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_set_delimiter (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ char arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ char val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvMLData_set_delimiter",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_set_delimiter" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ ecode2 = SWIG_AsVal_char(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMLData_set_delimiter" "', argument " "2"" of type '" "char""'");
+ }
+ arg2 = (char)(val2);
+ {
+ try {
+ (arg1)->set_delimiter(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_get_delimiter (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ char result;
+
+ if (!SWIG_check_num_args("CvMLData_get_delimiter",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_get_delimiter" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ {
+ try {
+ result = (char)(arg1)->get_delimiter();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_char((char)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_set_miss_ch (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ char arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ char val2 ;
+ int ecode2 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+
+ if (!SWIG_check_num_args("CvMLData_set_miss_ch",args.length(),2,2,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_set_miss_ch" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ ecode2 = SWIG_AsVal_char(args(1), &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMLData_set_miss_ch" "', argument " "2"" of type '" "char""'");
+ }
+ arg2 = (char)(val2);
+ {
+ try {
+ (arg1)->set_miss_ch(arg2);
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = octave_value();
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static octave_value_list _wrap_CvMLData_get_miss_ch (const octave_value_list& args, int nargout) {
+ CvMLData *arg1 = (CvMLData *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ octave_value_list _out;
+ octave_value_list *_outp=&_out;
+ octave_value _outv;
+ char result;
+
+ if (!SWIG_check_num_args("CvMLData_get_miss_ch",args.length(),1,1,0)) {
+ SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMLData, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMLData_get_miss_ch" "', argument " "1"" of type '" "CvMLData *""'");
+ }
+ arg1 = (CvMLData *)(argp1);
+ {
+ try {
+ result = (char)(arg1)->get_miss_ch();
+ }
+ catch (...)
+ {
+ SWIG_fail;
+ }
+ }
+ _outv = SWIG_From_char((char)(result));
+ if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
+fail:
+ return _out;
+}
+
+
+static swig_octave_member swig_CvMLData_members[] = {
+{"read_csv",_wrap_CvMLData_read_csv,0,0,0,0},
+{"get_values",_wrap_CvMLData_get_values,0,0,0,0},
+{"get_responses",_wrap_CvMLData_get_responses,0,0,0,0},
+{"get_missing",_wrap_CvMLData_get_missing,0,0,0,0},
+{"set_response_idx",_wrap_CvMLData_set_response_idx,0,0,0,0},
+{"get_response_idx",_wrap_CvMLData_get_response_idx,0,0,0,0},
+{"get_train_sample_idx",_wrap_CvMLData_get_train_sample_idx,0,0,0,0},
+{"get_test_sample_idx",_wrap_CvMLData_get_test_sample_idx,0,0,0,0},
+{"mix_train_and_test_idx",_wrap_CvMLData_mix_train_and_test_idx,0,0,0,0},
+{"set_train_test_split",_wrap_CvMLData_set_train_test_split,0,0,0,0},
+{"get_var_idx",_wrap_CvMLData_get_var_idx,0,0,0,0},
+{"chahge_var_idx",_wrap_CvMLData_chahge_var_idx,0,0,0,0},
+{"get_var_types",_wrap_CvMLData_get_var_types,0,0,0,0},
+{"get_var_type",_wrap_CvMLData_get_var_type,0,0,0,0},
+{"set_var_types",_wrap_CvMLData_set_var_types,0,0,0,0},
+{"change_var_type",_wrap_CvMLData_change_var_type,0,0,0,0},
+{"set_delimiter",_wrap_CvMLData_set_delimiter,0,0,0,0},
+{"get_delimiter",_wrap_CvMLData_get_delimiter,0,0,0,0},
+{"set_miss_ch",_wrap_CvMLData_set_miss_ch,0,0,0,0},
+{"get_miss_ch",_wrap_CvMLData_get_miss_ch,0,0,0,0},
+{0,0,0,0}
+};
+static const char *swig_CvMLData_base_names[] = {0};
+static const swig_type_info *swig_CvMLData_base[] = {0};
+static swig_octave_class _wrap_class_CvMLData = {"CvMLData", &SWIGTYPE_p_CvMLData,0,_wrap_new_CvMLData,0,_wrap_delete_CvMLData,swig_CvMLData_members,swig_CvMLData_base_names,swig_CvMLData_base };
+
+
+static const struct swig_octave_member swig_globals[] = {
+{"new_CvRNG_Wrapper",_wrap_new_CvRNG_Wrapper,0,0,2,0},
+{"CvRNG_Wrapper_ptr",_wrap_CvRNG_Wrapper_ptr,0,0,2,0},
+{"CvRNG_Wrapper_ref",_wrap_CvRNG_Wrapper_ref,0,0,2,0},
+{"CvRNG_Wrapper___eq__",_wrap_CvRNG_Wrapper___eq__,0,0,2,0},
+{"CvRNG_Wrapper___ne__",_wrap_CvRNG_Wrapper___ne__,0,0,2,0},
+{"delete_CvRNG_Wrapper",_wrap_delete_CvRNG_Wrapper,0,0,2,0},
+{"new_CvSubdiv2DEdge_Wrapper",_wrap_new_CvSubdiv2DEdge_Wrapper,0,0,2,0},
+{"CvSubdiv2DEdge_Wrapper_ptr",_wrap_CvSubdiv2DEdge_Wrapper_ptr,0,0,2,0},
+{"CvSubdiv2DEdge_Wrapper_ref",_wrap_CvSubdiv2DEdge_Wrapper_ref,0,0,2,0},
+{"CvSubdiv2DEdge_Wrapper___eq__",_wrap_CvSubdiv2DEdge_Wrapper___eq__,0,0,2,0},
+{"CvSubdiv2DEdge_Wrapper___ne__",_wrap_CvSubdiv2DEdge_Wrapper___ne__,0,0,2,0},
+{"delete_CvSubdiv2DEdge_Wrapper",_wrap_delete_CvSubdiv2DEdge_Wrapper,0,0,2,0},
+{"CvVectors_type_set",_wrap_CvVectors_type_set,0,0,2,0},
+{"CvVectors_type_get",_wrap_CvVectors_type_get,0,0,2,0},
+{"CvVectors_dims_set",_wrap_CvVectors_dims_set,0,0,2,0},
+{"CvVectors_dims_get",_wrap_CvVectors_dims_get,0,0,2,0},
+{"CvVectors_count_set",_wrap_CvVectors_count_set,0,0,2,0},
+{"CvVectors_count_get",_wrap_CvVectors_count_get,0,0,2,0},
+{"CvVectors_next_set",_wrap_CvVectors_next_set,0,0,2,0},
+{"CvVectors_next_get",_wrap_CvVectors_next_get,0,0,2,0},
+{"CvVectors_data_get",_wrap_CvVectors_data_get,0,0,2,0},
+{"new_CvVectors",_wrap_new_CvVectors,0,0,2,0},
+{"delete_CvVectors",_wrap_delete_CvVectors,0,0,2,0},
+{"CvVectors_data_ptr_set",_wrap_CvVectors_data_ptr_set,0,0,2,0},
+{"CvVectors_data_ptr_get",_wrap_CvVectors_data_ptr_get,0,0,2,0},
+{"CvVectors_data_fl_set",_wrap_CvVectors_data_fl_set,0,0,2,0},
+{"CvVectors_data_fl_get",_wrap_CvVectors_data_fl_get,0,0,2,0},
+{"CvVectors_data_db_set",_wrap_CvVectors_data_db_set,0,0,2,0},
+{"CvVectors_data_db_get",_wrap_CvVectors_data_db_get,0,0,2,0},
+{"new_CvVectors_data",_wrap_new_CvVectors_data,0,0,2,0},
+{"delete_CvVectors_data",_wrap_delete_CvVectors_data,0,0,2,0},
+{"new_CvStatModel",_wrap_new_CvStatModel,0,0,2,0},
+{"delete_CvStatModel",_wrap_delete_CvStatModel,0,0,2,0},
+{"CvStatModel_clear",_wrap_CvStatModel_clear,0,0,2,0},
+{"CvStatModel_save",_wrap_CvStatModel_save,0,0,2,0},
+{"CvStatModel_load",_wrap_CvStatModel_load,0,0,2,0},
+{"CvStatModel_write",_wrap_CvStatModel_write,0,0,2,0},
+{"CvStatModel_read",_wrap_CvStatModel_read,0,0,2,0},
+{"new_CvParamGrid",_wrap_new_CvParamGrid,0,0,2,0},
+{"CvParamGrid_check",_wrap_CvParamGrid_check,0,0,2,0},
+{"CvParamGrid_min_val_set",_wrap_CvParamGrid_min_val_set,0,0,2,0},
+{"CvParamGrid_min_val_get",_wrap_CvParamGrid_min_val_get,0,0,2,0},
+{"CvParamGrid_max_val_set",_wrap_CvParamGrid_max_val_set,0,0,2,0},
+{"CvParamGrid_max_val_get",_wrap_CvParamGrid_max_val_get,0,0,2,0},
+{"CvParamGrid_step_set",_wrap_CvParamGrid_step_set,0,0,2,0},
+{"CvParamGrid_step_get",_wrap_CvParamGrid_step_get,0,0,2,0},
+{"delete_CvParamGrid",_wrap_delete_CvParamGrid,0,0,2,0},
+{"delete_CvNormalBayesClassifier",_wrap_delete_CvNormalBayesClassifier,0,0,2,0},
+{"new_CvNormalBayesClassifier",_wrap_new_CvNormalBayesClassifier,0,0,2,0},
+{"CvNormalBayesClassifier_train",_wrap_CvNormalBayesClassifier_train,0,0,2,0},
+{"CvNormalBayesClassifier_predict",_wrap_CvNormalBayesClassifier_predict,0,0,2,0},
+{"CvNormalBayesClassifier_clear",_wrap_CvNormalBayesClassifier_clear,0,0,2,0},
+{"CvNormalBayesClassifier_write",_wrap_CvNormalBayesClassifier_write,0,0,2,0},
+{"CvNormalBayesClassifier_read",_wrap_CvNormalBayesClassifier_read,0,0,2,0},
+{"delete_CvKNearest",_wrap_delete_CvKNearest,0,0,2,0},
+{"new_CvKNearest",_wrap_new_CvKNearest,0,0,2,0},
+{"CvKNearest_train",_wrap_CvKNearest_train,0,0,2,0},
+{"CvKNearest_find_nearest",_wrap_CvKNearest_find_nearest,0,0,2,0},
+{"CvKNearest_clear",_wrap_CvKNearest_clear,0,0,2,0},
+{"CvKNearest_get_max_k",_wrap_CvKNearest_get_max_k,0,0,2,0},
+{"CvKNearest_get_var_count",_wrap_CvKNearest_get_var_count,0,0,2,0},
+{"CvKNearest_get_sample_count",_wrap_CvKNearest_get_sample_count,0,0,2,0},
+{"CvKNearest_is_regression",_wrap_CvKNearest_is_regression,0,0,2,0},
+{"new_CvSVMParams",_wrap_new_CvSVMParams,0,0,2,0},
+{"CvSVMParams_svm_type_set",_wrap_CvSVMParams_svm_type_set,0,0,2,0},
+{"CvSVMParams_svm_type_get",_wrap_CvSVMParams_svm_type_get,0,0,2,0},
+{"CvSVMParams_kernel_type_set",_wrap_CvSVMParams_kernel_type_set,0,0,2,0},
+{"CvSVMParams_kernel_type_get",_wrap_CvSVMParams_kernel_type_get,0,0,2,0},
+{"CvSVMParams_degree_set",_wrap_CvSVMParams_degree_set,0,0,2,0},
+{"CvSVMParams_degree_get",_wrap_CvSVMParams_degree_get,0,0,2,0},
+{"CvSVMParams_gamma_set",_wrap_CvSVMParams_gamma_set,0,0,2,0},
+{"CvSVMParams_gamma_get",_wrap_CvSVMParams_gamma_get,0,0,2,0},
+{"CvSVMParams_coef0_set",_wrap_CvSVMParams_coef0_set,0,0,2,0},
+{"CvSVMParams_coef0_get",_wrap_CvSVMParams_coef0_get,0,0,2,0},
+{"CvSVMParams_C_set",_wrap_CvSVMParams_C_set,0,0,2,0},
+{"CvSVMParams_C_get",_wrap_CvSVMParams_C_get,0,0,2,0},
+{"CvSVMParams_nu_set",_wrap_CvSVMParams_nu_set,0,0,2,0},
+{"CvSVMParams_nu_get",_wrap_CvSVMParams_nu_get,0,0,2,0},
+{"CvSVMParams_p_set",_wrap_CvSVMParams_p_set,0,0,2,0},
+{"CvSVMParams_p_get",_wrap_CvSVMParams_p_get,0,0,2,0},
+{"CvSVMParams_class_weights_set",_wrap_CvSVMParams_class_weights_set,0,0,2,0},
+{"CvSVMParams_class_weights_get",_wrap_CvSVMParams_class_weights_get,0,0,2,0},
+{"CvSVMParams_term_crit_set",_wrap_CvSVMParams_term_crit_set,0,0,2,0},
+{"CvSVMParams_term_crit_get",_wrap_CvSVMParams_term_crit_get,0,0,2,0},
+{"delete_CvSVMParams",_wrap_delete_CvSVMParams,0,0,2,0},
+{"new_CvSVMKernel",_wrap_new_CvSVMKernel,0,0,2,0},
+{"CvSVMKernel_create",_wrap_CvSVMKernel_create,0,0,2,0},
+{"delete_CvSVMKernel",_wrap_delete_CvSVMKernel,0,0,2,0},
+{"CvSVMKernel_clear",_wrap_CvSVMKernel_clear,0,0,2,0},
+{"CvSVMKernel_calc",_wrap_CvSVMKernel_calc,0,0,2,0},
+{"CvSVMKernel_params_set",_wrap_CvSVMKernel_params_set,0,0,2,0},
+{"CvSVMKernel_params_get",_wrap_CvSVMKernel_params_get,0,0,2,0},
+{"CvSVMKernel_calc_func_set",_wrap_CvSVMKernel_calc_func_set,0,0,2,0},
+{"CvSVMKernel_calc_func_get",_wrap_CvSVMKernel_calc_func_get,0,0,2,0},
+{"CvSVMKernel_calc_non_rbf_base",_wrap_CvSVMKernel_calc_non_rbf_base,0,0,2,0},
+{"CvSVMKernel_calc_linear",_wrap_CvSVMKernel_calc_linear,0,0,2,0},
+{"CvSVMKernel_calc_rbf",_wrap_CvSVMKernel_calc_rbf,0,0,2,0},
+{"CvSVMKernel_calc_poly",_wrap_CvSVMKernel_calc_poly,0,0,2,0},
+{"CvSVMKernel_calc_sigmoid",_wrap_CvSVMKernel_calc_sigmoid,0,0,2,0},
+{"CvSVMKernelRow_prev_set",_wrap_CvSVMKernelRow_prev_set,0,0,2,0},
+{"CvSVMKernelRow_prev_get",_wrap_CvSVMKernelRow_prev_get,0,0,2,0},
+{"CvSVMKernelRow_next_set",_wrap_CvSVMKernelRow_next_set,0,0,2,0},
+{"CvSVMKernelRow_next_get",_wrap_CvSVMKernelRow_next_get,0,0,2,0},
+{"CvSVMKernelRow_data_set",_wrap_CvSVMKernelRow_data_set,0,0,2,0},
+{"CvSVMKernelRow_data_get",_wrap_CvSVMKernelRow_data_get,0,0,2,0},
+{"new_CvSVMKernelRow",_wrap_new_CvSVMKernelRow,0,0,2,0},
+{"delete_CvSVMKernelRow",_wrap_delete_CvSVMKernelRow,0,0,2,0},
+{"CvSVMSolutionInfo_obj_set",_wrap_CvSVMSolutionInfo_obj_set,0,0,2,0},
+{"CvSVMSolutionInfo_obj_get",_wrap_CvSVMSolutionInfo_obj_get,0,0,2,0},
+{"CvSVMSolutionInfo_rho_set",_wrap_CvSVMSolutionInfo_rho_set,0,0,2,0},
+{"CvSVMSolutionInfo_rho_get",_wrap_CvSVMSolutionInfo_rho_get,0,0,2,0},
+{"CvSVMSolutionInfo_upper_bound_p_set",_wrap_CvSVMSolutionInfo_upper_bound_p_set,0,0,2,0},
+{"CvSVMSolutionInfo_upper_bound_p_get",_wrap_CvSVMSolutionInfo_upper_bound_p_get,0,0,2,0},
+{"CvSVMSolutionInfo_upper_bound_n_set",_wrap_CvSVMSolutionInfo_upper_bound_n_set,0,0,2,0},
+{"CvSVMSolutionInfo_upper_bound_n_get",_wrap_CvSVMSolutionInfo_upper_bound_n_get,0,0,2,0},
+{"CvSVMSolutionInfo_r_set",_wrap_CvSVMSolutionInfo_r_set,0,0,2,0},
+{"CvSVMSolutionInfo_r_get",_wrap_CvSVMSolutionInfo_r_get,0,0,2,0},
+{"new_CvSVMSolutionInfo",_wrap_new_CvSVMSolutionInfo,0,0,2,0},
+{"delete_CvSVMSolutionInfo",_wrap_delete_CvSVMSolutionInfo,0,0,2,0},
+{"new_CvSVMSolver",_wrap_new_CvSVMSolver,0,0,2,0},
+{"CvSVMSolver_create",_wrap_CvSVMSolver_create,0,0,2,0},
+{"delete_CvSVMSolver",_wrap_delete_CvSVMSolver,0,0,2,0},
+{"CvSVMSolver_clear",_wrap_CvSVMSolver_clear,0,0,2,0},
+{"CvSVMSolver_solve_generic",_wrap_CvSVMSolver_solve_generic,0,0,2,0},
+{"CvSVMSolver_solve_c_svc",_wrap_CvSVMSolver_solve_c_svc,0,0,2,0},
+{"CvSVMSolver_solve_nu_svc",_wrap_CvSVMSolver_solve_nu_svc,0,0,2,0},
+{"CvSVMSolver_solve_one_class",_wrap_CvSVMSolver_solve_one_class,0,0,2,0},
+{"CvSVMSolver_solve_eps_svr",_wrap_CvSVMSolver_solve_eps_svr,0,0,2,0},
+{"CvSVMSolver_solve_nu_svr",_wrap_CvSVMSolver_solve_nu_svr,0,0,2,0},
+{"CvSVMSolver_get_row_base",_wrap_CvSVMSolver_get_row_base,0,0,2,0},
+{"CvSVMSolver_get_row",_wrap_CvSVMSolver_get_row,0,0,2,0},
+{"CvSVMSolver_sample_count_set",_wrap_CvSVMSolver_sample_count_set,0,0,2,0},
+{"CvSVMSolver_sample_count_get",_wrap_CvSVMSolver_sample_count_get,0,0,2,0},
+{"CvSVMSolver_var_count_set",_wrap_CvSVMSolver_var_count_set,0,0,2,0},
+{"CvSVMSolver_var_count_get",_wrap_CvSVMSolver_var_count_get,0,0,2,0},
+{"CvSVMSolver_cache_size_set",_wrap_CvSVMSolver_cache_size_set,0,0,2,0},
+{"CvSVMSolver_cache_size_get",_wrap_CvSVMSolver_cache_size_get,0,0,2,0},
+{"CvSVMSolver_cache_line_size_set",_wrap_CvSVMSolver_cache_line_size_set,0,0,2,0},
+{"CvSVMSolver_cache_line_size_get",_wrap_CvSVMSolver_cache_line_size_get,0,0,2,0},
+{"CvSVMSolver_samples_set",_wrap_CvSVMSolver_samples_set,0,0,2,0},
+{"CvSVMSolver_samples_get",_wrap_CvSVMSolver_samples_get,0,0,2,0},
+{"CvSVMSolver_params_set",_wrap_CvSVMSolver_params_set,0,0,2,0},
+{"CvSVMSolver_params_get",_wrap_CvSVMSolver_params_get,0,0,2,0},
+{"CvSVMSolver_storage_set",_wrap_CvSVMSolver_storage_set,0,0,2,0},
+{"CvSVMSolver_storage_get",_wrap_CvSVMSolver_storage_get,0,0,2,0},
+{"CvSVMSolver_lru_list_set",_wrap_CvSVMSolver_lru_list_set,0,0,2,0},
+{"CvSVMSolver_lru_list_get",_wrap_CvSVMSolver_lru_list_get,0,0,2,0},
+{"CvSVMSolver_rows_set",_wrap_CvSVMSolver_rows_set,0,0,2,0},
+{"CvSVMSolver_rows_get",_wrap_CvSVMSolver_rows_get,0,0,2,0},
+{"CvSVMSolver_alpha_count_set",_wrap_CvSVMSolver_alpha_count_set,0,0,2,0},
+{"CvSVMSolver_alpha_count_get",_wrap_CvSVMSolver_alpha_count_get,0,0,2,0},
+{"CvSVMSolver_G_set",_wrap_CvSVMSolver_G_set,0,0,2,0},
+{"CvSVMSolver_G_get",_wrap_CvSVMSolver_G_get,0,0,2,0},
+{"CvSVMSolver_alpha_set",_wrap_CvSVMSolver_alpha_set,0,0,2,0},
+{"CvSVMSolver_alpha_get",_wrap_CvSVMSolver_alpha_get,0,0,2,0},
+{"CvSVMSolver_alpha_status_set",_wrap_CvSVMSolver_alpha_status_set,0,0,2,0},
+{"CvSVMSolver_alpha_status_get",_wrap_CvSVMSolver_alpha_status_get,0,0,2,0},
+{"CvSVMSolver_y_set",_wrap_CvSVMSolver_y_set,0,0,2,0},
+{"CvSVMSolver_y_get",_wrap_CvSVMSolver_y_get,0,0,2,0},
+{"CvSVMSolver_b_set",_wrap_CvSVMSolver_b_set,0,0,2,0},
+{"CvSVMSolver_b_get",_wrap_CvSVMSolver_b_get,0,0,2,0},
+{"CvSVMSolver_buf_set",_wrap_CvSVMSolver_buf_set,0,0,2,0},
+{"CvSVMSolver_buf_get",_wrap_CvSVMSolver_buf_get,0,0,2,0},
+{"CvSVMSolver_eps_set",_wrap_CvSVMSolver_eps_set,0,0,2,0},
+{"CvSVMSolver_eps_get",_wrap_CvSVMSolver_eps_get,0,0,2,0},
+{"CvSVMSolver_max_iter_set",_wrap_CvSVMSolver_max_iter_set,0,0,2,0},
+{"CvSVMSolver_max_iter_get",_wrap_CvSVMSolver_max_iter_get,0,0,2,0},
+{"CvSVMSolver_C_set",_wrap_CvSVMSolver_C_set,0,0,2,0},
+{"CvSVMSolver_C_get",_wrap_CvSVMSolver_C_get,0,0,2,0},
+{"CvSVMSolver_kernel_set",_wrap_CvSVMSolver_kernel_set,0,0,2,0},
+{"CvSVMSolver_kernel_get",_wrap_CvSVMSolver_kernel_get,0,0,2,0},
+{"CvSVMSolver_select_working_set_func_set",_wrap_CvSVMSolver_select_working_set_func_set,0,0,2,0},
+{"CvSVMSolver_select_working_set_func_get",_wrap_CvSVMSolver_select_working_set_func_get,0,0,2,0},
+{"CvSVMSolver_calc_rho_func_set",_wrap_CvSVMSolver_calc_rho_func_set,0,0,2,0},
+{"CvSVMSolver_calc_rho_func_get",_wrap_CvSVMSolver_calc_rho_func_get,0,0,2,0},
+{"CvSVMSolver_get_row_func_set",_wrap_CvSVMSolver_get_row_func_set,0,0,2,0},
+{"CvSVMSolver_get_row_func_get",_wrap_CvSVMSolver_get_row_func_get,0,0,2,0},
+{"CvSVMSolver_select_working_set",_wrap_CvSVMSolver_select_working_set,0,0,2,0},
+{"CvSVMSolver_select_working_set_nu_svm",_wrap_CvSVMSolver_select_working_set_nu_svm,0,0,2,0},
+{"CvSVMSolver_calc_rho",_wrap_CvSVMSolver_calc_rho,0,0,2,0},
+{"CvSVMSolver_calc_rho_nu_svm",_wrap_CvSVMSolver_calc_rho_nu_svm,0,0,2,0},
+{"CvSVMSolver_get_row_svc",_wrap_CvSVMSolver_get_row_svc,0,0,2,0},
+{"CvSVMSolver_get_row_one_class",_wrap_CvSVMSolver_get_row_one_class,0,0,2,0},
+{"CvSVMSolver_get_row_svr",_wrap_CvSVMSolver_get_row_svr,0,0,2,0},
+{"CvSVMDecisionFunc_rho_set",_wrap_CvSVMDecisionFunc_rho_set,0,0,2,0},
+{"CvSVMDecisionFunc_rho_get",_wrap_CvSVMDecisionFunc_rho_get,0,0,2,0},
+{"CvSVMDecisionFunc_sv_count_set",_wrap_CvSVMDecisionFunc_sv_count_set,0,0,2,0},
+{"CvSVMDecisionFunc_sv_count_get",_wrap_CvSVMDecisionFunc_sv_count_get,0,0,2,0},
+{"CvSVMDecisionFunc_alpha_set",_wrap_CvSVMDecisionFunc_alpha_set,0,0,2,0},
+{"CvSVMDecisionFunc_alpha_get",_wrap_CvSVMDecisionFunc_alpha_get,0,0,2,0},
+{"CvSVMDecisionFunc_sv_index_set",_wrap_CvSVMDecisionFunc_sv_index_set,0,0,2,0},
+{"CvSVMDecisionFunc_sv_index_get",_wrap_CvSVMDecisionFunc_sv_index_get,0,0,2,0},
+{"new_CvSVMDecisionFunc",_wrap_new_CvSVMDecisionFunc,0,0,2,0},
+{"delete_CvSVMDecisionFunc",_wrap_delete_CvSVMDecisionFunc,0,0,2,0},
+{"delete_CvSVM",_wrap_delete_CvSVM,0,0,2,0},
+{"new_CvSVM",_wrap_new_CvSVM,0,0,2,0},
+{"CvSVM_train",_wrap_CvSVM_train,0,0,2,0},
+{"CvSVM_train_auto",_wrap_CvSVM_train_auto,0,0,2,0},
+{"CvSVM_predict",_wrap_CvSVM_predict,0,0,2,0},
+{"CvSVM_get_support_vector_count",_wrap_CvSVM_get_support_vector_count,0,0,2,0},
+{"CvSVM_get_support_vector",_wrap_CvSVM_get_support_vector,0,0,2,0},
+{"CvSVM_get_params",_wrap_CvSVM_get_params,0,0,2,0},
+{"CvSVM_clear",_wrap_CvSVM_clear,0,0,2,0},
+{"CvSVM_get_default_grid",_wrap_CvSVM_get_default_grid,0,0,2,0},
+{"CvSVM_write",_wrap_CvSVM_write,0,0,2,0},
+{"CvSVM_read",_wrap_CvSVM_read,0,0,2,0},
+{"CvSVM_get_var_count",_wrap_CvSVM_get_var_count,0,0,2,0},
+{"new_CvEMParams",_wrap_new_CvEMParams,0,0,2,0},
+{"CvEMParams_nclusters_set",_wrap_CvEMParams_nclusters_set,0,0,2,0},
+{"CvEMParams_nclusters_get",_wrap_CvEMParams_nclusters_get,0,0,2,0},
+{"CvEMParams_cov_mat_type_set",_wrap_CvEMParams_cov_mat_type_set,0,0,2,0},
+{"CvEMParams_cov_mat_type_get",_wrap_CvEMParams_cov_mat_type_get,0,0,2,0},
+{"CvEMParams_start_step_set",_wrap_CvEMParams_start_step_set,0,0,2,0},
+{"CvEMParams_start_step_get",_wrap_CvEMParams_start_step_get,0,0,2,0},
+{"CvEMParams_probs_set",_wrap_CvEMParams_probs_set,0,0,2,0},
+{"CvEMParams_probs_get",_wrap_CvEMParams_probs_get,0,0,2,0},
+{"CvEMParams_weights_set",_wrap_CvEMParams_weights_set,0,0,2,0},
+{"CvEMParams_weights_get",_wrap_CvEMParams_weights_get,0,0,2,0},
+{"CvEMParams_means_set",_wrap_CvEMParams_means_set,0,0,2,0},
+{"CvEMParams_means_get",_wrap_CvEMParams_means_get,0,0,2,0},
+{"CvEMParams_covs_set",_wrap_CvEMParams_covs_set,0,0,2,0},
+{"CvEMParams_covs_get",_wrap_CvEMParams_covs_get,0,0,2,0},
+{"CvEMParams_term_crit_set",_wrap_CvEMParams_term_crit_set,0,0,2,0},
+{"CvEMParams_term_crit_get",_wrap_CvEMParams_term_crit_get,0,0,2,0},
+{"delete_CvEMParams",_wrap_delete_CvEMParams,0,0,2,0},
+{"new_CvEM",_wrap_new_CvEM,0,0,2,0},
+{"delete_CvEM",_wrap_delete_CvEM,0,0,2,0},
+{"CvEM_train",_wrap_CvEM_train,0,0,2,0},
+{"CvEM_predict",_wrap_CvEM_predict,0,0,2,0},
+{"CvEM_clear",_wrap_CvEM_clear,0,0,2,0},
+{"CvEM_get_nclusters",_wrap_CvEM_get_nclusters,0,0,2,0},
+{"CvEM_get_means",_wrap_CvEM_get_means,0,0,2,0},
+{"CvEM_get_weights",_wrap_CvEM_get_weights,0,0,2,0},
+{"CvEM_get_probs",_wrap_CvEM_get_probs,0,0,2,0},
+{"CvEM_get_log_likelihood",_wrap_CvEM_get_log_likelihood,0,0,2,0},
+{"CvEM_get_covs",_wrap_CvEM_get_covs,0,0,2,0},
+{"CvPair16u32s_u_set",_wrap_CvPair16u32s_u_set,0,0,2,0},
+{"CvPair16u32s_u_get",_wrap_CvPair16u32s_u_get,0,0,2,0},
+{"CvPair16u32s_i_set",_wrap_CvPair16u32s_i_set,0,0,2,0},
+{"CvPair16u32s_i_get",_wrap_CvPair16u32s_i_get,0,0,2,0},
+{"new_CvPair16u32s",_wrap_new_CvPair16u32s,0,0,2,0},
+{"delete_CvPair16u32s",_wrap_delete_CvPair16u32s,0,0,2,0},
+{"CvDTreeSplit_var_idx_set",_wrap_CvDTreeSplit_var_idx_set,0,0,2,0},
+{"CvDTreeSplit_var_idx_get",_wrap_CvDTreeSplit_var_idx_get,0,0,2,0},
+{"CvDTreeSplit_condensed_idx_set",_wrap_CvDTreeSplit_condensed_idx_set,0,0,2,0},
+{"CvDTreeSplit_condensed_idx_get",_wrap_CvDTreeSplit_condensed_idx_get,0,0,2,0},
+{"CvDTreeSplit_inversed_set",_wrap_CvDTreeSplit_inversed_set,0,0,2,0},
+{"CvDTreeSplit_inversed_get",_wrap_CvDTreeSplit_inversed_get,0,0,2,0},
+{"CvDTreeSplit_quality_set",_wrap_CvDTreeSplit_quality_set,0,0,2,0},
+{"CvDTreeSplit_quality_get",_wrap_CvDTreeSplit_quality_get,0,0,2,0},
+{"CvDTreeSplit_next_set",_wrap_CvDTreeSplit_next_set,0,0,2,0},
+{"CvDTreeSplit_next_get",_wrap_CvDTreeSplit_next_get,0,0,2,0},
+{"new_CvDTreeSplit",_wrap_new_CvDTreeSplit,0,0,2,0},
+{"delete_CvDTreeSplit",_wrap_delete_CvDTreeSplit,0,0,2,0},
+{"CvDTreeNode_class_idx_set",_wrap_CvDTreeNode_class_idx_set,0,0,2,0},
+{"CvDTreeNode_class_idx_get",_wrap_CvDTreeNode_class_idx_get,0,0,2,0},
+{"CvDTreeNode_Tn_set",_wrap_CvDTreeNode_Tn_set,0,0,2,0},
+{"CvDTreeNode_Tn_get",_wrap_CvDTreeNode_Tn_get,0,0,2,0},
+{"CvDTreeNode_value_set",_wrap_CvDTreeNode_value_set,0,0,2,0},
+{"CvDTreeNode_value_get",_wrap_CvDTreeNode_value_get,0,0,2,0},
+{"CvDTreeNode_parent_set",_wrap_CvDTreeNode_parent_set,0,0,2,0},
+{"CvDTreeNode_parent_get",_wrap_CvDTreeNode_parent_get,0,0,2,0},
+{"CvDTreeNode_left_set",_wrap_CvDTreeNode_left_set,0,0,2,0},
+{"CvDTreeNode_left_get",_wrap_CvDTreeNode_left_get,0,0,2,0},
+{"CvDTreeNode_right_set",_wrap_CvDTreeNode_right_set,0,0,2,0},
+{"CvDTreeNode_right_get",_wrap_CvDTreeNode_right_get,0,0,2,0},
+{"CvDTreeNode_split_set",_wrap_CvDTreeNode_split_set,0,0,2,0},
+{"CvDTreeNode_split_get",_wrap_CvDTreeNode_split_get,0,0,2,0},
+{"CvDTreeNode_sample_count_set",_wrap_CvDTreeNode_sample_count_set,0,0,2,0},
+{"CvDTreeNode_sample_count_get",_wrap_CvDTreeNode_sample_count_get,0,0,2,0},
+{"CvDTreeNode_depth_set",_wrap_CvDTreeNode_depth_set,0,0,2,0},
+{"CvDTreeNode_depth_get",_wrap_CvDTreeNode_depth_get,0,0,2,0},
+{"CvDTreeNode_num_valid_set",_wrap_CvDTreeNode_num_valid_set,0,0,2,0},
+{"CvDTreeNode_num_valid_get",_wrap_CvDTreeNode_num_valid_get,0,0,2,0},
+{"CvDTreeNode_offset_set",_wrap_CvDTreeNode_offset_set,0,0,2,0},
+{"CvDTreeNode_offset_get",_wrap_CvDTreeNode_offset_get,0,0,2,0},
+{"CvDTreeNode_buf_idx_set",_wrap_CvDTreeNode_buf_idx_set,0,0,2,0},
+{"CvDTreeNode_buf_idx_get",_wrap_CvDTreeNode_buf_idx_get,0,0,2,0},
+{"CvDTreeNode_maxlr_set",_wrap_CvDTreeNode_maxlr_set,0,0,2,0},
+{"CvDTreeNode_maxlr_get",_wrap_CvDTreeNode_maxlr_get,0,0,2,0},
+{"CvDTreeNode_complexity_set",_wrap_CvDTreeNode_complexity_set,0,0,2,0},
+{"CvDTreeNode_complexity_get",_wrap_CvDTreeNode_complexity_get,0,0,2,0},
+{"CvDTreeNode_alpha_set",_wrap_CvDTreeNode_alpha_set,0,0,2,0},
+{"CvDTreeNode_alpha_get",_wrap_CvDTreeNode_alpha_get,0,0,2,0},
+{"CvDTreeNode_node_risk_set",_wrap_CvDTreeNode_node_risk_set,0,0,2,0},
+{"CvDTreeNode_node_risk_get",_wrap_CvDTreeNode_node_risk_get,0,0,2,0},
+{"CvDTreeNode_tree_risk_set",_wrap_CvDTreeNode_tree_risk_set,0,0,2,0},
+{"CvDTreeNode_tree_risk_get",_wrap_CvDTreeNode_tree_risk_get,0,0,2,0},
+{"CvDTreeNode_tree_error_set",_wrap_CvDTreeNode_tree_error_set,0,0,2,0},
+{"CvDTreeNode_tree_error_get",_wrap_CvDTreeNode_tree_error_get,0,0,2,0},
+{"CvDTreeNode_cv_Tn_set",_wrap_CvDTreeNode_cv_Tn_set,0,0,2,0},
+{"CvDTreeNode_cv_Tn_get",_wrap_CvDTreeNode_cv_Tn_get,0,0,2,0},
+{"CvDTreeNode_cv_node_risk_set",_wrap_CvDTreeNode_cv_node_risk_set,0,0,2,0},
+{"CvDTreeNode_cv_node_risk_get",_wrap_CvDTreeNode_cv_node_risk_get,0,0,2,0},
+{"CvDTreeNode_cv_node_error_set",_wrap_CvDTreeNode_cv_node_error_set,0,0,2,0},
+{"CvDTreeNode_cv_node_error_get",_wrap_CvDTreeNode_cv_node_error_get,0,0,2,0},
+{"CvDTreeNode_get_num_valid",_wrap_CvDTreeNode_get_num_valid,0,0,2,0},
+{"CvDTreeNode_set_num_valid",_wrap_CvDTreeNode_set_num_valid,0,0,2,0},
+{"new_CvDTreeNode",_wrap_new_CvDTreeNode,0,0,2,0},
+{"delete_CvDTreeNode",_wrap_delete_CvDTreeNode,0,0,2,0},
+{"CvDTreeParams_max_categories_set",_wrap_CvDTreeParams_max_categories_set,0,0,2,0},
+{"CvDTreeParams_max_categories_get",_wrap_CvDTreeParams_max_categories_get,0,0,2,0},
+{"CvDTreeParams_max_depth_set",_wrap_CvDTreeParams_max_depth_set,0,0,2,0},
+{"CvDTreeParams_max_depth_get",_wrap_CvDTreeParams_max_depth_get,0,0,2,0},
+{"CvDTreeParams_min_sample_count_set",_wrap_CvDTreeParams_min_sample_count_set,0,0,2,0},
+{"CvDTreeParams_min_sample_count_get",_wrap_CvDTreeParams_min_sample_count_get,0,0,2,0},
+{"CvDTreeParams_cv_folds_set",_wrap_CvDTreeParams_cv_folds_set,0,0,2,0},
+{"CvDTreeParams_cv_folds_get",_wrap_CvDTreeParams_cv_folds_get,0,0,2,0},
+{"CvDTreeParams_use_surrogates_set",_wrap_CvDTreeParams_use_surrogates_set,0,0,2,0},
+{"CvDTreeParams_use_surrogates_get",_wrap_CvDTreeParams_use_surrogates_get,0,0,2,0},
+{"CvDTreeParams_use_1se_rule_set",_wrap_CvDTreeParams_use_1se_rule_set,0,0,2,0},
+{"CvDTreeParams_use_1se_rule_get",_wrap_CvDTreeParams_use_1se_rule_get,0,0,2,0},
+{"CvDTreeParams_truncate_pruned_tree_set",_wrap_CvDTreeParams_truncate_pruned_tree_set,0,0,2,0},
+{"CvDTreeParams_truncate_pruned_tree_get",_wrap_CvDTreeParams_truncate_pruned_tree_get,0,0,2,0},
+{"CvDTreeParams_regression_accuracy_set",_wrap_CvDTreeParams_regression_accuracy_set,0,0,2,0},
+{"CvDTreeParams_regression_accuracy_get",_wrap_CvDTreeParams_regression_accuracy_get,0,0,2,0},
+{"CvDTreeParams_priors_set",_wrap_CvDTreeParams_priors_set,0,0,2,0},
+{"CvDTreeParams_priors_get",_wrap_CvDTreeParams_priors_get,0,0,2,0},
+{"new_CvDTreeParams",_wrap_new_CvDTreeParams,0,0,2,0},
+{"delete_CvDTreeParams",_wrap_delete_CvDTreeParams,0,0,2,0},
+{"new_CvDTreeTrainData",_wrap_new_CvDTreeTrainData,0,0,2,0},
+{"delete_CvDTreeTrainData",_wrap_delete_CvDTreeTrainData,0,0,2,0},
+{"CvDTreeTrainData_set_data",_wrap_CvDTreeTrainData_set_data,0,0,2,0},
+{"CvDTreeTrainData_do_responses_copy",_wrap_CvDTreeTrainData_do_responses_copy,0,0,2,0},
+{"CvDTreeTrainData_get_vectors",_wrap_CvDTreeTrainData_get_vectors,0,0,2,0},
+{"CvDTreeTrainData_subsample_data",_wrap_CvDTreeTrainData_subsample_data,0,0,2,0},
+{"CvDTreeTrainData_write_params",_wrap_CvDTreeTrainData_write_params,0,0,2,0},
+{"CvDTreeTrainData_read_params",_wrap_CvDTreeTrainData_read_params,0,0,2,0},
+{"CvDTreeTrainData_clear",_wrap_CvDTreeTrainData_clear,0,0,2,0},
+{"CvDTreeTrainData_get_num_classes",_wrap_CvDTreeTrainData_get_num_classes,0,0,2,0},
+{"CvDTreeTrainData_get_var_type",_wrap_CvDTreeTrainData_get_var_type,0,0,2,0},
+{"CvDTreeTrainData_get_work_var_count",_wrap_CvDTreeTrainData_get_work_var_count,0,0,2,0},
+{"CvDTreeTrainData_get_ord_responses",_wrap_CvDTreeTrainData_get_ord_responses,0,0,2,0},
+{"CvDTreeTrainData_get_class_labels",_wrap_CvDTreeTrainData_get_class_labels,0,0,2,0},
+{"CvDTreeTrainData_get_cv_labels",_wrap_CvDTreeTrainData_get_cv_labels,0,0,2,0},
+{"CvDTreeTrainData_get_sample_indices",_wrap_CvDTreeTrainData_get_sample_indices,0,0,2,0},
+{"CvDTreeTrainData_get_cat_var_data",_wrap_CvDTreeTrainData_get_cat_var_data,0,0,2,0},
+{"CvDTreeTrainData_get_ord_var_data",_wrap_CvDTreeTrainData_get_ord_var_data,0,0,2,0},
+{"CvDTreeTrainData_get_child_buf_idx",_wrap_CvDTreeTrainData_get_child_buf_idx,0,0,2,0},
+{"CvDTreeTrainData_set_params",_wrap_CvDTreeTrainData_set_params,0,0,2,0},
+{"CvDTreeTrainData_new_node",_wrap_CvDTreeTrainData_new_node,0,0,2,0},
+{"CvDTreeTrainData_new_split_ord",_wrap_CvDTreeTrainData_new_split_ord,0,0,2,0},
+{"CvDTreeTrainData_new_split_cat",_wrap_CvDTreeTrainData_new_split_cat,0,0,2,0},
+{"CvDTreeTrainData_free_node_data",_wrap_CvDTreeTrainData_free_node_data,0,0,2,0},
+{"CvDTreeTrainData_free_train_data",_wrap_CvDTreeTrainData_free_train_data,0,0,2,0},
+{"CvDTreeTrainData_free_node",_wrap_CvDTreeTrainData_free_node,0,0,2,0},
+{"CvDTreeTrainData_get_pred_float_buf",_wrap_CvDTreeTrainData_get_pred_float_buf,0,0,2,0},
+{"CvDTreeTrainData_get_pred_int_buf",_wrap_CvDTreeTrainData_get_pred_int_buf,0,0,2,0},
+{"CvDTreeTrainData_get_resp_float_buf",_wrap_CvDTreeTrainData_get_resp_float_buf,0,0,2,0},
+{"CvDTreeTrainData_get_resp_int_buf",_wrap_CvDTreeTrainData_get_resp_int_buf,0,0,2,0},
+{"CvDTreeTrainData_get_cv_lables_buf",_wrap_CvDTreeTrainData_get_cv_lables_buf,0,0,2,0},
+{"CvDTreeTrainData_get_sample_idx_buf",_wrap_CvDTreeTrainData_get_sample_idx_buf,0,0,2,0},
+{"CvDTreeTrainData_pred_float_buf_set",_wrap_CvDTreeTrainData_pred_float_buf_set,0,0,2,0},
+{"CvDTreeTrainData_pred_float_buf_get",_wrap_CvDTreeTrainData_pred_float_buf_get,0,0,2,0},
+{"CvDTreeTrainData_pred_int_buf_set",_wrap_CvDTreeTrainData_pred_int_buf_set,0,0,2,0},
+{"CvDTreeTrainData_pred_int_buf_get",_wrap_CvDTreeTrainData_pred_int_buf_get,0,0,2,0},
+{"CvDTreeTrainData_resp_float_buf_set",_wrap_CvDTreeTrainData_resp_float_buf_set,0,0,2,0},
+{"CvDTreeTrainData_resp_float_buf_get",_wrap_CvDTreeTrainData_resp_float_buf_get,0,0,2,0},
+{"CvDTreeTrainData_resp_int_buf_set",_wrap_CvDTreeTrainData_resp_int_buf_set,0,0,2,0},
+{"CvDTreeTrainData_resp_int_buf_get",_wrap_CvDTreeTrainData_resp_int_buf_get,0,0,2,0},
+{"CvDTreeTrainData_cv_lables_buf_set",_wrap_CvDTreeTrainData_cv_lables_buf_set,0,0,2,0},
+{"CvDTreeTrainData_cv_lables_buf_get",_wrap_CvDTreeTrainData_cv_lables_buf_get,0,0,2,0},
+{"CvDTreeTrainData_sample_idx_buf_set",_wrap_CvDTreeTrainData_sample_idx_buf_set,0,0,2,0},
+{"CvDTreeTrainData_sample_idx_buf_get",_wrap_CvDTreeTrainData_sample_idx_buf_get,0,0,2,0},
+{"CvDTreeTrainData_sample_count_set",_wrap_CvDTreeTrainData_sample_count_set,0,0,2,0},
+{"CvDTreeTrainData_sample_count_get",_wrap_CvDTreeTrainData_sample_count_get,0,0,2,0},
+{"CvDTreeTrainData_var_all_set",_wrap_CvDTreeTrainData_var_all_set,0,0,2,0},
+{"CvDTreeTrainData_var_all_get",_wrap_CvDTreeTrainData_var_all_get,0,0,2,0},
+{"CvDTreeTrainData_var_count_set",_wrap_CvDTreeTrainData_var_count_set,0,0,2,0},
+{"CvDTreeTrainData_var_count_get",_wrap_CvDTreeTrainData_var_count_get,0,0,2,0},
+{"CvDTreeTrainData_max_c_count_set",_wrap_CvDTreeTrainData_max_c_count_set,0,0,2,0},
+{"CvDTreeTrainData_max_c_count_get",_wrap_CvDTreeTrainData_max_c_count_get,0,0,2,0},
+{"CvDTreeTrainData_ord_var_count_set",_wrap_CvDTreeTrainData_ord_var_count_set,0,0,2,0},
+{"CvDTreeTrainData_ord_var_count_get",_wrap_CvDTreeTrainData_ord_var_count_get,0,0,2,0},
+{"CvDTreeTrainData_cat_var_count_set",_wrap_CvDTreeTrainData_cat_var_count_set,0,0,2,0},
+{"CvDTreeTrainData_cat_var_count_get",_wrap_CvDTreeTrainData_cat_var_count_get,0,0,2,0},
+{"CvDTreeTrainData_work_var_count_set",_wrap_CvDTreeTrainData_work_var_count_set,0,0,2,0},
+{"CvDTreeTrainData_work_var_count_get",_wrap_CvDTreeTrainData_work_var_count_get,0,0,2,0},
+{"CvDTreeTrainData_have_labels_set",_wrap_CvDTreeTrainData_have_labels_set,0,0,2,0},
+{"CvDTreeTrainData_have_labels_get",_wrap_CvDTreeTrainData_have_labels_get,0,0,2,0},
+{"CvDTreeTrainData_have_priors_set",_wrap_CvDTreeTrainData_have_priors_set,0,0,2,0},
+{"CvDTreeTrainData_have_priors_get",_wrap_CvDTreeTrainData_have_priors_get,0,0,2,0},
+{"CvDTreeTrainData_is_classifier_set",_wrap_CvDTreeTrainData_is_classifier_set,0,0,2,0},
+{"CvDTreeTrainData_is_classifier_get",_wrap_CvDTreeTrainData_is_classifier_get,0,0,2,0},
+{"CvDTreeTrainData_tflag_set",_wrap_CvDTreeTrainData_tflag_set,0,0,2,0},
+{"CvDTreeTrainData_tflag_get",_wrap_CvDTreeTrainData_tflag_get,0,0,2,0},
+{"CvDTreeTrainData_train_data_set",_wrap_CvDTreeTrainData_train_data_set,0,0,2,0},
+{"CvDTreeTrainData_train_data_get",_wrap_CvDTreeTrainData_train_data_get,0,0,2,0},
+{"CvDTreeTrainData_responses_set",_wrap_CvDTreeTrainData_responses_set,0,0,2,0},
+{"CvDTreeTrainData_responses_get",_wrap_CvDTreeTrainData_responses_get,0,0,2,0},
+{"CvDTreeTrainData_responses_copy_set",_wrap_CvDTreeTrainData_responses_copy_set,0,0,2,0},
+{"CvDTreeTrainData_responses_copy_get",_wrap_CvDTreeTrainData_responses_copy_get,0,0,2,0},
+{"CvDTreeTrainData_buf_count_set",_wrap_CvDTreeTrainData_buf_count_set,0,0,2,0},
+{"CvDTreeTrainData_buf_count_get",_wrap_CvDTreeTrainData_buf_count_get,0,0,2,0},
+{"CvDTreeTrainData_buf_size_set",_wrap_CvDTreeTrainData_buf_size_set,0,0,2,0},
+{"CvDTreeTrainData_buf_size_get",_wrap_CvDTreeTrainData_buf_size_get,0,0,2,0},
+{"CvDTreeTrainData_shared_set",_wrap_CvDTreeTrainData_shared_set,0,0,2,0},
+{"CvDTreeTrainData_shared_get",_wrap_CvDTreeTrainData_shared_get,0,0,2,0},
+{"CvDTreeTrainData_is_buf_16u_set",_wrap_CvDTreeTrainData_is_buf_16u_set,0,0,2,0},
+{"CvDTreeTrainData_is_buf_16u_get",_wrap_CvDTreeTrainData_is_buf_16u_get,0,0,2,0},
+{"CvDTreeTrainData_cat_count_set",_wrap_CvDTreeTrainData_cat_count_set,0,0,2,0},
+{"CvDTreeTrainData_cat_count_get",_wrap_CvDTreeTrainData_cat_count_get,0,0,2,0},
+{"CvDTreeTrainData_cat_ofs_set",_wrap_CvDTreeTrainData_cat_ofs_set,0,0,2,0},
+{"CvDTreeTrainData_cat_ofs_get",_wrap_CvDTreeTrainData_cat_ofs_get,0,0,2,0},
+{"CvDTreeTrainData_cat_map_set",_wrap_CvDTreeTrainData_cat_map_set,0,0,2,0},
+{"CvDTreeTrainData_cat_map_get",_wrap_CvDTreeTrainData_cat_map_get,0,0,2,0},
+{"CvDTreeTrainData_counts_set",_wrap_CvDTreeTrainData_counts_set,0,0,2,0},
+{"CvDTreeTrainData_counts_get",_wrap_CvDTreeTrainData_counts_get,0,0,2,0},
+{"CvDTreeTrainData_buf_set",_wrap_CvDTreeTrainData_buf_set,0,0,2,0},
+{"CvDTreeTrainData_buf_get",_wrap_CvDTreeTrainData_buf_get,0,0,2,0},
+{"CvDTreeTrainData_direction_set",_wrap_CvDTreeTrainData_direction_set,0,0,2,0},
+{"CvDTreeTrainData_direction_get",_wrap_CvDTreeTrainData_direction_get,0,0,2,0},
+{"CvDTreeTrainData_split_buf_set",_wrap_CvDTreeTrainData_split_buf_set,0,0,2,0},
+{"CvDTreeTrainData_split_buf_get",_wrap_CvDTreeTrainData_split_buf_get,0,0,2,0},
+{"CvDTreeTrainData_var_idx_set",_wrap_CvDTreeTrainData_var_idx_set,0,0,2,0},
+{"CvDTreeTrainData_var_idx_get",_wrap_CvDTreeTrainData_var_idx_get,0,0,2,0},
+{"CvDTreeTrainData_var_type_set",_wrap_CvDTreeTrainData_var_type_set,0,0,2,0},
+{"CvDTreeTrainData_var_type_get",_wrap_CvDTreeTrainData_var_type_get,0,0,2,0},
+{"CvDTreeTrainData_priors_set",_wrap_CvDTreeTrainData_priors_set,0,0,2,0},
+{"CvDTreeTrainData_priors_get",_wrap_CvDTreeTrainData_priors_get,0,0,2,0},
+{"CvDTreeTrainData_priors_mult_set",_wrap_CvDTreeTrainData_priors_mult_set,0,0,2,0},
+{"CvDTreeTrainData_priors_mult_get",_wrap_CvDTreeTrainData_priors_mult_get,0,0,2,0},
+{"CvDTreeTrainData_params_set",_wrap_CvDTreeTrainData_params_set,0,0,2,0},
+{"CvDTreeTrainData_params_get",_wrap_CvDTreeTrainData_params_get,0,0,2,0},
+{"CvDTreeTrainData_tree_storage_set",_wrap_CvDTreeTrainData_tree_storage_set,0,0,2,0},
+{"CvDTreeTrainData_tree_storage_get",_wrap_CvDTreeTrainData_tree_storage_get,0,0,2,0},
+{"CvDTreeTrainData_temp_storage_set",_wrap_CvDTreeTrainData_temp_storage_set,0,0,2,0},
+{"CvDTreeTrainData_temp_storage_get",_wrap_CvDTreeTrainData_temp_storage_get,0,0,2,0},
+{"CvDTreeTrainData_data_root_set",_wrap_CvDTreeTrainData_data_root_set,0,0,2,0},
+{"CvDTreeTrainData_data_root_get",_wrap_CvDTreeTrainData_data_root_get,0,0,2,0},
+{"CvDTreeTrainData_node_heap_set",_wrap_CvDTreeTrainData_node_heap_set,0,0,2,0},
+{"CvDTreeTrainData_node_heap_get",_wrap_CvDTreeTrainData_node_heap_get,0,0,2,0},
+{"CvDTreeTrainData_split_heap_set",_wrap_CvDTreeTrainData_split_heap_set,0,0,2,0},
+{"CvDTreeTrainData_split_heap_get",_wrap_CvDTreeTrainData_split_heap_get,0,0,2,0},
+{"CvDTreeTrainData_cv_heap_set",_wrap_CvDTreeTrainData_cv_heap_set,0,0,2,0},
+{"CvDTreeTrainData_cv_heap_get",_wrap_CvDTreeTrainData_cv_heap_get,0,0,2,0},
+{"CvDTreeTrainData_nv_heap_set",_wrap_CvDTreeTrainData_nv_heap_set,0,0,2,0},
+{"CvDTreeTrainData_nv_heap_get",_wrap_CvDTreeTrainData_nv_heap_get,0,0,2,0},
+{"CvDTreeTrainData_rng_set",_wrap_CvDTreeTrainData_rng_set,0,0,2,0},
+{"CvDTreeTrainData_rng_get",_wrap_CvDTreeTrainData_rng_get,0,0,2,0},
+{"new_CvDTree",_wrap_new_CvDTree,0,0,2,0},
+{"delete_CvDTree",_wrap_delete_CvDTree,0,0,2,0},
+{"CvDTree_calc_error",_wrap_CvDTree_calc_error,0,0,2,0},
+{"CvDTree_train",_wrap_CvDTree_train,0,0,2,0},
+{"CvDTree_predict",_wrap_CvDTree_predict,0,0,2,0},
+{"CvDTree_get_var_importance",_wrap_CvDTree_get_var_importance,0,0,2,0},
+{"CvDTree_clear",_wrap_CvDTree_clear,0,0,2,0},
+{"CvDTree_read",_wrap_CvDTree_read,0,0,2,0},
+{"CvDTree_write",_wrap_CvDTree_write,0,0,2,0},
+{"CvDTree_get_root",_wrap_CvDTree_get_root,0,0,2,0},
+{"CvDTree_get_pruned_tree_idx",_wrap_CvDTree_get_pruned_tree_idx,0,0,2,0},
+{"CvDTree_get_data",_wrap_CvDTree_get_data,0,0,2,0},
+{"CvDTree_pruned_tree_idx_set",_wrap_CvDTree_pruned_tree_idx_set,0,0,2,0},
+{"CvDTree_pruned_tree_idx_get",_wrap_CvDTree_pruned_tree_idx_get,0,0,2,0},
+{"new_CvForestTree",_wrap_new_CvForestTree,0,0,2,0},
+{"delete_CvForestTree",_wrap_delete_CvForestTree,0,0,2,0},
+{"CvForestTree_get_var_count",_wrap_CvForestTree_get_var_count,0,0,2,0},
+{"CvForestTree_train",_wrap_CvForestTree_train,0,0,2,0},
+{"CvForestTree_read",_wrap_CvForestTree_read,0,0,2,0},
+{"CvRTParams_calc_var_importance_set",_wrap_CvRTParams_calc_var_importance_set,0,0,2,0},
+{"CvRTParams_calc_var_importance_get",_wrap_CvRTParams_calc_var_importance_get,0,0,2,0},
+{"CvRTParams_nactive_vars_set",_wrap_CvRTParams_nactive_vars_set,0,0,2,0},
+{"CvRTParams_nactive_vars_get",_wrap_CvRTParams_nactive_vars_get,0,0,2,0},
+{"CvRTParams_term_crit_set",_wrap_CvRTParams_term_crit_set,0,0,2,0},
+{"CvRTParams_term_crit_get",_wrap_CvRTParams_term_crit_get,0,0,2,0},
+{"new_CvRTParams",_wrap_new_CvRTParams,0,0,2,0},
+{"delete_CvRTParams",_wrap_delete_CvRTParams,0,0,2,0},
+{"new_CvRTrees",_wrap_new_CvRTrees,0,0,2,0},
+{"delete_CvRTrees",_wrap_delete_CvRTrees,0,0,2,0},
+{"CvRTrees_train",_wrap_CvRTrees_train,0,0,2,0},
+{"CvRTrees_predict",_wrap_CvRTrees_predict,0,0,2,0},
+{"CvRTrees_predict_prob",_wrap_CvRTrees_predict_prob,0,0,2,0},
+{"CvRTrees_clear",_wrap_CvRTrees_clear,0,0,2,0},
+{"CvRTrees_get_var_importance",_wrap_CvRTrees_get_var_importance,0,0,2,0},
+{"CvRTrees_get_proximity",_wrap_CvRTrees_get_proximity,0,0,2,0},
+{"CvRTrees_calc_error",_wrap_CvRTrees_calc_error,0,0,2,0},
+{"CvRTrees_get_train_error",_wrap_CvRTrees_get_train_error,0,0,2,0},
+{"CvRTrees_read",_wrap_CvRTrees_read,0,0,2,0},
+{"CvRTrees_write",_wrap_CvRTrees_write,0,0,2,0},
+{"CvRTrees_get_active_var_mask",_wrap_CvRTrees_get_active_var_mask,0,0,2,0},
+{"CvRTrees_get_rng",_wrap_CvRTrees_get_rng,0,0,2,0},
+{"CvRTrees_get_tree_count",_wrap_CvRTrees_get_tree_count,0,0,2,0},
+{"CvRTrees_get_tree",_wrap_CvRTrees_get_tree,0,0,2,0},
+{"CvERTreeTrainData_set_data",_wrap_CvERTreeTrainData_set_data,0,0,2,0},
+{"CvERTreeTrainData_get_ord_var_data",_wrap_CvERTreeTrainData_get_ord_var_data,0,0,2,0},
+{"CvERTreeTrainData_get_sample_indices",_wrap_CvERTreeTrainData_get_sample_indices,0,0,2,0},
+{"CvERTreeTrainData_get_cv_labels",_wrap_CvERTreeTrainData_get_cv_labels,0,0,2,0},
+{"CvERTreeTrainData_get_cat_var_data",_wrap_CvERTreeTrainData_get_cat_var_data,0,0,2,0},
+{"CvERTreeTrainData_get_vectors",_wrap_CvERTreeTrainData_get_vectors,0,0,2,0},
+{"CvERTreeTrainData_subsample_data",_wrap_CvERTreeTrainData_subsample_data,0,0,2,0},
+{"CvERTreeTrainData_missing_mask_set",_wrap_CvERTreeTrainData_missing_mask_set,0,0,2,0},
+{"CvERTreeTrainData_missing_mask_get",_wrap_CvERTreeTrainData_missing_mask_get,0,0,2,0},
+{"new_CvERTreeTrainData",_wrap_new_CvERTreeTrainData,0,0,2,0},
+{"delete_CvERTreeTrainData",_wrap_delete_CvERTreeTrainData,0,0,2,0},
+{"new_CvForestERTree",_wrap_new_CvForestERTree,0,0,2,0},
+{"delete_CvForestERTree",_wrap_delete_CvForestERTree,0,0,2,0},
+{"new_CvERTrees",_wrap_new_CvERTrees,0,0,2,0},
+{"delete_CvERTrees",_wrap_delete_CvERTrees,0,0,2,0},
+{"CvERTrees_train",_wrap_CvERTrees_train,0,0,2,0},
+{"CvBoostParams_boost_type_set",_wrap_CvBoostParams_boost_type_set,0,0,2,0},
+{"CvBoostParams_boost_type_get",_wrap_CvBoostParams_boost_type_get,0,0,2,0},
+{"CvBoostParams_weak_count_set",_wrap_CvBoostParams_weak_count_set,0,0,2,0},
+{"CvBoostParams_weak_count_get",_wrap_CvBoostParams_weak_count_get,0,0,2,0},
+{"CvBoostParams_split_criteria_set",_wrap_CvBoostParams_split_criteria_set,0,0,2,0},
+{"CvBoostParams_split_criteria_get",_wrap_CvBoostParams_split_criteria_get,0,0,2,0},
+{"CvBoostParams_weight_trim_rate_set",_wrap_CvBoostParams_weight_trim_rate_set,0,0,2,0},
+{"CvBoostParams_weight_trim_rate_get",_wrap_CvBoostParams_weight_trim_rate_get,0,0,2,0},
+{"new_CvBoostParams",_wrap_new_CvBoostParams,0,0,2,0},
+{"delete_CvBoostParams",_wrap_delete_CvBoostParams,0,0,2,0},
+{"new_CvBoostTree",_wrap_new_CvBoostTree,0,0,2,0},
+{"delete_CvBoostTree",_wrap_delete_CvBoostTree,0,0,2,0},
+{"CvBoostTree_scale",_wrap_CvBoostTree_scale,0,0,2,0},
+{"CvBoostTree_clear",_wrap_CvBoostTree_clear,0,0,2,0},
+{"CvBoostTree_train",_wrap_CvBoostTree_train,0,0,2,0},
+{"CvBoostTree_read",_wrap_CvBoostTree_read,0,0,2,0},
+{"delete_CvBoost",_wrap_delete_CvBoost,0,0,2,0},
+{"new_CvBoost",_wrap_new_CvBoost,0,0,2,0},
+{"CvBoost_train",_wrap_CvBoost_train,0,0,2,0},
+{"CvBoost_predict",_wrap_CvBoost_predict,0,0,2,0},
+{"CvBoost_calc_error",_wrap_CvBoost_calc_error,0,0,2,0},
+{"CvBoost_prune",_wrap_CvBoost_prune,0,0,2,0},
+{"CvBoost_clear",_wrap_CvBoost_clear,0,0,2,0},
+{"CvBoost_write",_wrap_CvBoost_write,0,0,2,0},
+{"CvBoost_read",_wrap_CvBoost_read,0,0,2,0},
+{"CvBoost_get_active_vars",_wrap_CvBoost_get_active_vars,0,0,2,0},
+{"CvBoost_get_weak_predictors",_wrap_CvBoost_get_weak_predictors,0,0,2,0},
+{"CvBoost_get_weights",_wrap_CvBoost_get_weights,0,0,2,0},
+{"CvBoost_get_subtree_weights",_wrap_CvBoost_get_subtree_weights,0,0,2,0},
+{"CvBoost_get_weak_response",_wrap_CvBoost_get_weak_response,0,0,2,0},
+{"CvBoost_get_params",_wrap_CvBoost_get_params,0,0,2,0},
+{"CvBoost_get_data",_wrap_CvBoost_get_data,0,0,2,0},
+{"new_CvANN_MLP_TrainParams",_wrap_new_CvANN_MLP_TrainParams,0,0,2,0},
+{"delete_CvANN_MLP_TrainParams",_wrap_delete_CvANN_MLP_TrainParams,0,0,2,0},
+{"CvANN_MLP_TrainParams_term_crit_set",_wrap_CvANN_MLP_TrainParams_term_crit_set,0,0,2,0},
+{"CvANN_MLP_TrainParams_term_crit_get",_wrap_CvANN_MLP_TrainParams_term_crit_get,0,0,2,0},
+{"CvANN_MLP_TrainParams_train_method_set",_wrap_CvANN_MLP_TrainParams_train_method_set,0,0,2,0},
+{"CvANN_MLP_TrainParams_train_method_get",_wrap_CvANN_MLP_TrainParams_train_method_get,0,0,2,0},
+{"CvANN_MLP_TrainParams_bp_dw_scale_set",_wrap_CvANN_MLP_TrainParams_bp_dw_scale_set,0,0,2,0},
+{"CvANN_MLP_TrainParams_bp_dw_scale_get",_wrap_CvANN_MLP_TrainParams_bp_dw_scale_get,0,0,2,0},
+{"CvANN_MLP_TrainParams_bp_moment_scale_set",_wrap_CvANN_MLP_TrainParams_bp_moment_scale_set,0,0,2,0},
+{"CvANN_MLP_TrainParams_bp_moment_scale_get",_wrap_CvANN_MLP_TrainParams_bp_moment_scale_get,0,0,2,0},
+{"CvANN_MLP_TrainParams_rp_dw0_set",_wrap_CvANN_MLP_TrainParams_rp_dw0_set,0,0,2,0},
+{"CvANN_MLP_TrainParams_rp_dw0_get",_wrap_CvANN_MLP_TrainParams_rp_dw0_get,0,0,2,0},
+{"CvANN_MLP_TrainParams_rp_dw_plus_set",_wrap_CvANN_MLP_TrainParams_rp_dw_plus_set,0,0,2,0},
+{"CvANN_MLP_TrainParams_rp_dw_plus_get",_wrap_CvANN_MLP_TrainParams_rp_dw_plus_get,0,0,2,0},
+{"CvANN_MLP_TrainParams_rp_dw_minus_set",_wrap_CvANN_MLP_TrainParams_rp_dw_minus_set,0,0,2,0},
+{"CvANN_MLP_TrainParams_rp_dw_minus_get",_wrap_CvANN_MLP_TrainParams_rp_dw_minus_get,0,0,2,0},
+{"CvANN_MLP_TrainParams_rp_dw_min_set",_wrap_CvANN_MLP_TrainParams_rp_dw_min_set,0,0,2,0},
+{"CvANN_MLP_TrainParams_rp_dw_min_get",_wrap_CvANN_MLP_TrainParams_rp_dw_min_get,0,0,2,0},
+{"CvANN_MLP_TrainParams_rp_dw_max_set",_wrap_CvANN_MLP_TrainParams_rp_dw_max_set,0,0,2,0},
+{"CvANN_MLP_TrainParams_rp_dw_max_get",_wrap_CvANN_MLP_TrainParams_rp_dw_max_get,0,0,2,0},
+{"new_CvANN_MLP",_wrap_new_CvANN_MLP,0,0,2,0},
+{"delete_CvANN_MLP",_wrap_delete_CvANN_MLP,0,0,2,0},
+{"CvANN_MLP_create",_wrap_CvANN_MLP_create,0,0,2,0},
+{"CvANN_MLP_train",_wrap_CvANN_MLP_train,0,0,2,0},
+{"CvANN_MLP_predict",_wrap_CvANN_MLP_predict,0,0,2,0},
+{"CvANN_MLP_clear",_wrap_CvANN_MLP_clear,0,0,2,0},
+{"CvANN_MLP_read",_wrap_CvANN_MLP_read,0,0,2,0},
+{"CvANN_MLP_write",_wrap_CvANN_MLP_write,0,0,2,0},
+{"CvANN_MLP_get_layer_count",_wrap_CvANN_MLP_get_layer_count,0,0,2,0},
+{"CvANN_MLP_get_layer_sizes",_wrap_CvANN_MLP_get_layer_sizes,0,0,2,0},
+{"CvANN_MLP_get_weights",_wrap_CvANN_MLP_get_weights,0,0,2,0},
+{"cvRandMVNormal",_wrap_cvRandMVNormal,0,0,2,0},
+{"cvRandGaussMixture",_wrap_cvRandGaussMixture,0,0,2,0},
+{"cvCreateTestSet",_wrap_cvCreateTestSet,0,0,2,0},
+{"new_CvTrainTestSplit",_wrap_new_CvTrainTestSplit,0,0,2,0},
+{"CvTrainTestSplit_train_sample_part_mode_set",_wrap_CvTrainTestSplit_train_sample_part_mode_set,0,0,2,0},
+{"CvTrainTestSplit_train_sample_part_mode_get",_wrap_CvTrainTestSplit_train_sample_part_mode_get,0,0,2,0},
+{"CvTrainTestSplit_class_part_mode_set",_wrap_CvTrainTestSplit_class_part_mode_set,0,0,2,0},
+{"CvTrainTestSplit_class_part_mode_get",_wrap_CvTrainTestSplit_class_part_mode_get,0,0,2,0},
+{"CvTrainTestSplit_mix_set",_wrap_CvTrainTestSplit_mix_set,0,0,2,0},
+{"CvTrainTestSplit_mix_get",_wrap_CvTrainTestSplit_mix_get,0,0,2,0},
+{"CvTrainTestSplit_class_part_get",_wrap_CvTrainTestSplit_class_part_get,0,0,2,0},
+{"CvTrainTestSplit_train_sample_part_get",_wrap_CvTrainTestSplit_train_sample_part_get,0,0,2,0},
+{"delete_CvTrainTestSplit",_wrap_delete_CvTrainTestSplit,0,0,2,0},
+{"CvTrainTestSplit_class_part_count_set",_wrap_CvTrainTestSplit_class_part_count_set,0,0,2,0},
+{"CvTrainTestSplit_class_part_count_get",_wrap_CvTrainTestSplit_class_part_count_get,0,0,2,0},
+{"CvTrainTestSplit_class_part_portion_set",_wrap_CvTrainTestSplit_class_part_portion_set,0,0,2,0},
+{"CvTrainTestSplit_class_part_portion_get",_wrap_CvTrainTestSplit_class_part_portion_get,0,0,2,0},
+{"new_CvTrainTestSplit_class_part",_wrap_new_CvTrainTestSplit_class_part,0,0,2,0},
+{"delete_CvTrainTestSplit_class_part",_wrap_delete_CvTrainTestSplit_class_part,0,0,2,0},
+{"CvTrainTestSplit_train_sample_part_count_set",_wrap_CvTrainTestSplit_train_sample_part_count_set,0,0,2,0},
+{"CvTrainTestSplit_train_sample_part_count_get",_wrap_CvTrainTestSplit_train_sample_part_count_get,0,0,2,0},
+{"CvTrainTestSplit_train_sample_part_portion_set",_wrap_CvTrainTestSplit_train_sample_part_portion_set,0,0,2,0},
+{"CvTrainTestSplit_train_sample_part_portion_get",_wrap_CvTrainTestSplit_train_sample_part_portion_get,0,0,2,0},
+{"new_CvTrainTestSplit_train_sample_part",_wrap_new_CvTrainTestSplit_train_sample_part,0,0,2,0},
+{"delete_CvTrainTestSplit_train_sample_part",_wrap_delete_CvTrainTestSplit_train_sample_part,0,0,2,0},
+{"new_CvMLData",_wrap_new_CvMLData,0,0,2,0},
+{"delete_CvMLData",_wrap_delete_CvMLData,0,0,2,0},
+{"CvMLData_read_csv",_wrap_CvMLData_read_csv,0,0,2,0},
+{"CvMLData_get_values",_wrap_CvMLData_get_values,0,0,2,0},
+{"CvMLData_get_responses",_wrap_CvMLData_get_responses,0,0,2,0},
+{"CvMLData_get_missing",_wrap_CvMLData_get_missing,0,0,2,0},
+{"CvMLData_set_response_idx",_wrap_CvMLData_set_response_idx,0,0,2,0},
+{"CvMLData_get_response_idx",_wrap_CvMLData_get_response_idx,0,0,2,0},
+{"CvMLData_get_train_sample_idx",_wrap_CvMLData_get_train_sample_idx,0,0,2,0},
+{"CvMLData_get_test_sample_idx",_wrap_CvMLData_get_test_sample_idx,0,0,2,0},
+{"CvMLData_mix_train_and_test_idx",_wrap_CvMLData_mix_train_and_test_idx,0,0,2,0},
+{"CvMLData_set_train_test_split",_wrap_CvMLData_set_train_test_split,0,0,2,0},
+{"CvMLData_get_var_idx",_wrap_CvMLData_get_var_idx,0,0,2,0},
+{"CvMLData_chahge_var_idx",_wrap_CvMLData_chahge_var_idx,0,0,2,0},
+{"CvMLData_get_var_types",_wrap_CvMLData_get_var_types,0,0,2,0},
+{"CvMLData_get_var_type",_wrap_CvMLData_get_var_type,0,0,2,0},
+{"CvMLData_set_var_types",_wrap_CvMLData_set_var_types,0,0,2,0},
+{"CvMLData_change_var_type",_wrap_CvMLData_change_var_type,0,0,2,0},
+{"CvMLData_set_delimiter",_wrap_CvMLData_set_delimiter,0,0,2,0},
+{"CvMLData_get_delimiter",_wrap_CvMLData_get_delimiter,0,0,2,0},
+{"CvMLData_set_miss_ch",_wrap_CvMLData_set_miss_ch,0,0,2,0},
+{"CvMLData_get_miss_ch",_wrap_CvMLData_get_miss_ch,0,0,2,0},
+{0,0,0,0,0}
+};
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_CvERTreesTo_p_CvRTrees(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvRTrees *) ((CvERTrees *) x));
+}
+static void *_p_CvERTreeTrainDataTo_p_CvDTreeTrainData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvDTreeTrainData *) ((CvERTreeTrainData *) x));
+}
+static void *_p_CvForestERTreeTo_p_CvForestTree(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvForestTree *) ((CvForestERTree *) x));
+}
+static void *_p_CvRTParamsTo_p_CvDTreeParams(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvDTreeParams *) ((CvRTParams *) x));
+}
+static void *_p_CvBoostParamsTo_p_CvDTreeParams(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvDTreeParams *) ((CvBoostParams *) x));
+}
+static void *_p_CvNormalBayesClassifierTo_p_CvStatModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvStatModel *) ((CvNormalBayesClassifier *) x));
+}
+static void *_p_CvSVMTo_p_CvStatModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvStatModel *) ((CvSVM *) x));
+}
+static void *_p_CvForestERTreeTo_p_CvStatModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvStatModel *) (CvDTree *)(CvForestTree *) ((CvForestERTree *) x));
+}
+static void *_p_CvANN_MLPTo_p_CvStatModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvStatModel *) ((CvANN_MLP *) x));
+}
+static void *_p_CvKNearestTo_p_CvStatModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvStatModel *) ((CvKNearest *) x));
+}
+static void *_p_CvForestTreeTo_p_CvStatModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvStatModel *) (CvDTree *) ((CvForestTree *) x));
+}
+static void *_p_CvRTreesTo_p_CvStatModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvStatModel *) ((CvRTrees *) x));
+}
+static void *_p_CvBoostTreeTo_p_CvStatModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvStatModel *) (CvDTree *) ((CvBoostTree *) x));
+}
+static void *_p_CvERTreesTo_p_CvStatModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvStatModel *) (CvRTrees *) ((CvERTrees *) x));
+}
+static void *_p_CvEMTo_p_CvStatModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvStatModel *) ((CvEM *) x));
+}
+static void *_p_CvDTreeTo_p_CvStatModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvStatModel *) ((CvDTree *) x));
+}
+static void *_p_CvBoostTo_p_CvStatModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvStatModel *) ((CvBoost *) x));
+}
+static void *_p_CvForestERTreeTo_p_CvDTree(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvDTree *) (CvForestTree *) ((CvForestERTree *) x));
+}
+static void *_p_CvForestTreeTo_p_CvDTree(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvDTree *) ((CvForestTree *) x));
+}
+static void *_p_CvBoostTreeTo_p_CvDTree(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((CvDTree *) ((CvBoostTree *) x));
+}
+static swig_type_info _swigt__m_CvSVMKernel__f_int_int_p_p_q_const__float_p_q_const__float_p_float__void = {"_m_CvSVMKernel__f_int_int_p_p_q_const__float_p_q_const__float_p_float__void", "void (CvSVMKernel::*)(int,int,float const **,float const *,float *)|CvSVMKernel::Calc", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__m_CvSVMSolver__f_int_p_float_p_float_bool__p_float = {"_m_CvSVMSolver__f_int_p_float_p_float_bool__p_float", "CvSVMSolver::GetRow|float *(CvSVMSolver::*)(int,float *,float *,bool)", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__m_CvSVMSolver__f_r_double_r_double__void = {"_m_CvSVMSolver__f_r_double_r_double__void", "void (CvSVMSolver::*)(double &,double &)|CvSVMSolver::CalcRho", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__m_CvSVMSolver__f_r_int_r_int__bool = {"_m_CvSVMSolver__f_r_int_r_int__bool", "CvSVMSolver::SelectWorkingSet|bool (CvSVMSolver::*)(int &,int &)", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Calc = {"_p_Calc", "Calc *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CalcRho = {"_p_CalcRho", "CalcRho *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Cv32suf = {"_p_Cv32suf", "Cv32suf *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Cv64suf = {"_p_Cv64suf", "Cv64suf *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvANN_MLP = {"_p_CvANN_MLP", "CvANN_MLP *|cv::NeuralNet_MLP *", 0, 0, (void*)&_wrap_class_CvANN_MLP, 0};
+static swig_type_info _swigt__p_CvANN_MLP_TrainParams = {"_p_CvANN_MLP_TrainParams", "CvANN_MLP_TrainParams *|cv::ANN_MLP_TrainParams *", 0, 0, (void*)&_wrap_class_CvANN_MLP_TrainParams, 0};
+static swig_type_info _swigt__p_CvAttrList = {"_p_CvAttrList", "CvAttrList *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvAvgComp = {"_p_CvAvgComp", "CvAvgComp *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvBoost = {"_p_CvBoost", "CvBoost *|cv::Boost *", 0, 0, (void*)&_wrap_class_CvBoost, 0};
+static swig_type_info _swigt__p_CvBoostParams = {"_p_CvBoostParams", "CvBoostParams *|cv::BoostParams *", 0, 0, (void*)&_wrap_class_CvBoostParams, 0};
+static swig_type_info _swigt__p_CvBoostTree = {"_p_CvBoostTree", "CvBoostTree *|cv::BoostTree *", 0, 0, (void*)&_wrap_class_CvBoostTree, 0};
+static swig_type_info _swigt__p_CvBox2D = {"_p_CvBox2D", "CvBox2D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvChain = {"_p_CvChain", "CvChain *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvChainPtReader = {"_p_CvChainPtReader", "CvChainPtReader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvConDensation = {"_p_CvConDensation", "CvConDensation *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvConnectedComp = {"_p_CvConnectedComp", "CvConnectedComp *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvContour = {"_p_CvContour", "CvPoint2DSeq *|CvContour *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvContourTree = {"_p_CvContourTree", "CvContourTree *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvConvexityDefect = {"_p_CvConvexityDefect", "CvConvexityDefect *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvDTree = {"_p_CvDTree", "CvDTree *|cv::DecisionTree *", 0, 0, (void*)&_wrap_class_CvDTree, 0};
+static swig_type_info _swigt__p_CvDTreeNode = {"_p_CvDTreeNode", "CvDTreeNode *", 0, 0, (void*)&_wrap_class_CvDTreeNode, 0};
+static swig_type_info _swigt__p_CvDTreeParams = {"_p_CvDTreeParams", "CvDTreeParams *|cv::DTreeParams *", 0, 0, (void*)&_wrap_class_CvDTreeParams, 0};
+static swig_type_info _swigt__p_CvDTreeSplit = {"_p_CvDTreeSplit", "CvDTreeSplit *", 0, 0, (void*)&_wrap_class_CvDTreeSplit, 0};
+static swig_type_info _swigt__p_CvDTreeTrainData = {"_p_CvDTreeTrainData", "CvDTreeTrainData *", 0, 0, (void*)&_wrap_class_CvDTreeTrainData, 0};
+static swig_type_info _swigt__p_CvEM = {"_p_CvEM", "cv::ExpectationMaximization *|CvEM *", 0, 0, (void*)&_wrap_class_CvEM, 0};
+static swig_type_info _swigt__p_CvEMParams = {"_p_CvEMParams", "CvEMParams *|cv::EMParams *", 0, 0, (void*)&_wrap_class_CvEMParams, 0};
+static swig_type_info _swigt__p_CvERTreeTrainData = {"_p_CvERTreeTrainData", "CvERTreeTrainData *|cv::ERTreeTRainData *", 0, 0, (void*)&_wrap_class_CvERTreeTrainData, 0};
+static swig_type_info _swigt__p_CvERTrees = {"_p_CvERTrees", "CvERTrees *|cv::ERTrees *", 0, 0, (void*)&_wrap_class_CvERTrees, 0};
+static swig_type_info _swigt__p_CvFileNode = {"_p_CvFileNode", "CvFileNode *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvFileStorage = {"_p_CvFileStorage", "CvFileStorage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvFilter = {"_p_CvFilter", "enum CvFilter *|CvFilter *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvFont = {"_p_CvFont", "CvFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvForestERTree = {"_p_CvForestERTree", "CvForestERTree *|cv::ERTree *", 0, 0, (void*)&_wrap_class_CvForestERTree, 0};
+static swig_type_info _swigt__p_CvForestTree = {"_p_CvForestTree", "CvForestTree *|cv::ForestTree *", 0, 0, (void*)&_wrap_class_CvForestTree, 0};
+static swig_type_info _swigt__p_CvGenericHash = {"_p_CvGenericHash", "CvGenericHash *|CvFileNodeHash *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvGraph = {"_p_CvGraph", "CvGraph *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvGraphEdge = {"_p_CvGraphEdge", "CvGraphEdge *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvGraphScanner = {"_p_CvGraphScanner", "CvGraphScanner *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvGraphVtx = {"_p_CvGraphVtx", "CvGraphVtx *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvGraphVtx2D = {"_p_CvGraphVtx2D", "CvGraphVtx2D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvHaarClassifier = {"_p_CvHaarClassifier", "CvHaarClassifier *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvHaarClassifierCascade = {"_p_CvHaarClassifierCascade", "CvHaarClassifierCascade *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvHaarFeature = {"_p_CvHaarFeature", "CvHaarFeature *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvHaarStageClassifier = {"_p_CvHaarStageClassifier", "CvHaarStageClassifier *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvHidHaarClassifierCascade = {"_p_CvHidHaarClassifierCascade", "CvHidHaarClassifierCascade *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvHistogram = {"_p_CvHistogram", "CvHistogram *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvHuMoments = {"_p_CvHuMoments", "CvHuMoments *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvKNearest = {"_p_CvKNearest", "CvKNearest *|cv::KNearest *", 0, 0, (void*)&_wrap_class_CvKNearest, 0};
+static swig_type_info _swigt__p_CvKalman = {"_p_CvKalman", "CvKalman *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvLineIterator = {"_p_CvLineIterator", "CvLineIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvMLData = {"_p_CvMLData", "CvMLData *|cv::TrainData *", 0, 0, (void*)&_wrap_class_CvMLData, 0};
+static swig_type_info _swigt__p_CvMSERParams = {"_p_CvMSERParams", "CvMSERParams *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvMat = {"_p_CvMat", "CvMat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvMatND = {"_p_CvMatND", "CvMatND *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvMatrix3 = {"_p_CvMatrix3", "CvMatrix3 *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvMemBlock = {"_p_CvMemBlock", "CvMemBlock *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvMemStorage = {"_p_CvMemStorage", "CvMemStorage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvMemStoragePos = {"_p_CvMemStoragePos", "CvMemStoragePos *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvModuleInfo = {"_p_CvModuleInfo", "CvModuleInfo *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvMoments = {"_p_CvMoments", "CvMoments *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvNArrayIterator = {"_p_CvNArrayIterator", "CvNArrayIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvNextEdgeType = {"_p_CvNextEdgeType", "enum CvNextEdgeType *|CvNextEdgeType *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvNormalBayesClassifier = {"_p_CvNormalBayesClassifier", "CvNormalBayesClassifier *|cv::NormalBayesClassifier *", 0, 0, (void*)&_wrap_class_CvNormalBayesClassifier, 0};
+static swig_type_info _swigt__p_CvPOSITObject = {"_p_CvPOSITObject", "CvPOSITObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvPair16u32s = {"_p_CvPair16u32s", "CvPair16u32s *", 0, 0, (void*)&_wrap_class_CvPair16u32s, 0};
+static swig_type_info _swigt__p_CvParamGrid = {"_p_CvParamGrid", "CvParamGrid *|cv::ParamGrid *", 0, 0, (void*)&_wrap_class_CvParamGrid, 0};
+static swig_type_info _swigt__p_CvPluginFuncInfo = {"_p_CvPluginFuncInfo", "CvPluginFuncInfo *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvPoint = {"_p_CvPoint", "CvPoint *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvPoint2D32f = {"_p_CvPoint2D32f", "CvPoint2D32f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvPoint2D64f = {"_p_CvPoint2D64f", "CvPoint2D64f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvPoint3D32f = {"_p_CvPoint3D32f", "CvPoint3D32f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvPoint3D64f = {"_p_CvPoint3D64f", "CvPoint3D64f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvQuadEdge2D = {"_p_CvQuadEdge2D", "CvQuadEdge2D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvRNG_Wrapper = {"_p_CvRNG_Wrapper", "CvRNG_Wrapper *", 0, 0, (void*)&_wrap_class_CvRNG_Wrapper, 0};
+static swig_type_info _swigt__p_CvRTParams = {"_p_CvRTParams", "CvRTParams *|cv::RandomTreeParams *", 0, 0, (void*)&_wrap_class_CvRTParams, 0};
+static swig_type_info _swigt__p_CvRTrees = {"_p_CvRTrees", "CvRTrees *|cv::RandomTrees *", 0, 0, (void*)&_wrap_class_CvRTrees, 0};
+static swig_type_info _swigt__p_CvRect = {"_p_CvRect", "CvRect *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSURFParams = {"_p_CvSURFParams", "CvSURFParams *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSURFPoint = {"_p_CvSURFPoint", "CvSURFPoint *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSVM = {"_p_CvSVM", "CvSVM *|cv::SVM *", 0, 0, (void*)&_wrap_class_CvSVM, 0};
+static swig_type_info _swigt__p_CvSVMDecisionFunc = {"_p_CvSVMDecisionFunc", "CvSVMDecisionFunc *", 0, 0, (void*)&_wrap_class_CvSVMDecisionFunc, 0};
+static swig_type_info _swigt__p_CvSVMKernel = {"_p_CvSVMKernel", "CvSVMKernel *|cv::SVMKernel *", 0, 0, (void*)&_wrap_class_CvSVMKernel, 0};
+static swig_type_info _swigt__p_CvSVMKernelRow = {"_p_CvSVMKernelRow", "CvSVMKernelRow *", 0, 0, (void*)&_wrap_class_CvSVMKernelRow, 0};
+static swig_type_info _swigt__p_CvSVMParams = {"_p_CvSVMParams", "CvSVMParams *|cv::SVMParams *", 0, 0, (void*)&_wrap_class_CvSVMParams, 0};
+static swig_type_info _swigt__p_CvSVMSolutionInfo = {"_p_CvSVMSolutionInfo", "CvSVMSolutionInfo *", 0, 0, (void*)&_wrap_class_CvSVMSolutionInfo, 0};
+static swig_type_info _swigt__p_CvSVMSolver = {"_p_CvSVMSolver", "CvSVMSolver *|cv::SVMSolver *", 0, 0, (void*)&_wrap_class_CvSVMSolver, 0};
+static swig_type_info _swigt__p_CvScalar = {"_p_CvScalar", "CvScalar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSeq = {"_p_CvSeq", "CvSeq *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSeqBlock = {"_p_CvSeqBlock", "CvSeqBlock *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSeqReader = {"_p_CvSeqReader", "CvSeqReader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSeqWriter = {"_p_CvSeqWriter", "CvSeqWriter *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSet = {"_p_CvSet", "CvSet *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSetElem = {"_p_CvSetElem", "CvSetElem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSize = {"_p_CvSize", "CvSize *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSize2D32f = {"_p_CvSize2D32f", "CvSize2D32f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSlice = {"_p_CvSlice", "CvSlice *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSparseMat = {"_p_CvSparseMat", "CvSparseMat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSparseMatIterator = {"_p_CvSparseMatIterator", "CvSparseMatIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSparseNode = {"_p_CvSparseNode", "CvSparseNode *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvStarDetectorParams = {"_p_CvStarDetectorParams", "CvStarDetectorParams *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvStarKeypoint = {"_p_CvStarKeypoint", "CvStarKeypoint *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvStatModel = {"_p_CvStatModel", "CvStatModel *|cv::StatModel *", 0, 0, (void*)&_wrap_class_CvStatModel, 0};
+static swig_type_info _swigt__p_CvStereoBMState = {"_p_CvStereoBMState", "CvStereoBMState *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvStereoGCState = {"_p_CvStereoGCState", "CvStereoGCState *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvString = {"_p_CvString", "CvString *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvStringHashNode = {"_p_CvStringHashNode", "CvStringHashNode *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSubdiv2D = {"_p_CvSubdiv2D", "CvSubdiv2D *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSubdiv2DEdge_Wrapper = {"_p_CvSubdiv2DEdge_Wrapper", "CvSubdiv2DEdge_Wrapper *", 0, 0, (void*)&_wrap_class_CvSubdiv2DEdge_Wrapper, 0};
+static swig_type_info _swigt__p_CvSubdiv2DPoint = {"_p_CvSubdiv2DPoint", "CvSubdiv2DPoint *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvSubdiv2DPointLocation = {"_p_CvSubdiv2DPointLocation", "enum CvSubdiv2DPointLocation *|CvSubdiv2DPointLocation *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvTermCriteria = {"_p_CvTermCriteria", "CvTermCriteria *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvTrainTestSplit = {"_p_CvTrainTestSplit", "CvTrainTestSplit *", 0, 0, (void*)&_wrap_class_CvTrainTestSplit, 0};
+static swig_type_info _swigt__p_CvTrainTestSplit_class_part = {"_p_CvTrainTestSplit_class_part", "CvTrainTestSplit_class_part *", 0, 0, (void*)&_wrap_class_CvTrainTestSplit_class_part, 0};
+static swig_type_info _swigt__p_CvTrainTestSplit_train_sample_part = {"_p_CvTrainTestSplit_train_sample_part", "CvTrainTestSplit_train_sample_part *", 0, 0, (void*)&_wrap_class_CvTrainTestSplit_train_sample_part, 0};
+static swig_type_info _swigt__p_CvTreeNodeIterator = {"_p_CvTreeNodeIterator", "CvTreeNodeIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvTypeInfo = {"_p_CvTypeInfo", "CvTypeInfo *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CvVectors = {"_p_CvVectors", "CvVectors *", 0, 0, (void*)&_wrap_class_CvVectors, 0};
+static swig_type_info _swigt__p_CvVectors_data = {"_p_CvVectors_data", "CvVectors_data *", 0, 0, (void*)&_wrap_class_CvVectors_data, 0};
+static swig_type_info _swigt__p_GetRow = {"_p_GetRow", "GetRow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_SelectWorkingSet = {"_p_SelectWorkingSet", "SelectWorkingSet *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p__IplConvKernel = {"_p__IplConvKernel", "_IplConvKernel *|IplConvKernel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p__IplConvKernelFP = {"_p__IplConvKernelFP", "_IplConvKernelFP *|IplConvKernelFP *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p__IplImage = {"_p__IplImage", "_IplImage *|IplImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p__IplROI = {"_p__IplROI", "_IplROI *|IplROI *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p__IplTileInfo = {"_p__IplTileInfo", "_IplTileInfo *|IplTileInfo *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 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_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", "CvHistType *|int *|CVStatus *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int64_t = {"_p_int64_t", "int64_t *|int64 *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_CvMat = {"_p_p_CvMat", "CvMat **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_float = {"_p_p_float", "float **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_int = {"_p_p_int", "int **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_unsigned_char = {"_p_p_unsigned_char", "unsigned char **|uchar **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "schar *|signed char *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *|CvSubdiv2DEdge *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_uint64_t = {"_p_uint64_t", "uint64_t *|uint64 *|CvRNG *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "uchar *|unsigned char *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|ushort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_vectorT_float_t = {"_p_vectorT_float_t", "vector< float > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_vectorT_vectorT_float_t_t = {"_p_vectorT_vectorT_float_t_t", "vector< vector< float > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_vectorT_vectorT_int_t_t = {"_p_vectorT_vectorT_int_t_t", "vector< vector< int > > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_void = {"_p_void", "CvArr *|void *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+ &_swigt__m_CvSVMKernel__f_int_int_p_p_q_const__float_p_q_const__float_p_float__void,
+ &_swigt__m_CvSVMSolver__f_int_p_float_p_float_bool__p_float,
+ &_swigt__m_CvSVMSolver__f_r_double_r_double__void,
+ &_swigt__m_CvSVMSolver__f_r_int_r_int__bool,
+ &_swigt__p_Calc,
+ &_swigt__p_CalcRho,
+ &_swigt__p_Cv32suf,
+ &_swigt__p_Cv64suf,
+ &_swigt__p_CvANN_MLP,
+ &_swigt__p_CvANN_MLP_TrainParams,
+ &_swigt__p_CvAttrList,
+ &_swigt__p_CvAvgComp,
+ &_swigt__p_CvBoost,
+ &_swigt__p_CvBoostParams,
+ &_swigt__p_CvBoostTree,
+ &_swigt__p_CvBox2D,
+ &_swigt__p_CvChain,
+ &_swigt__p_CvChainPtReader,
+ &_swigt__p_CvConDensation,
+ &_swigt__p_CvConnectedComp,
+ &_swigt__p_CvContour,
+ &_swigt__p_CvContourTree,
+ &_swigt__p_CvConvexityDefect,
+ &_swigt__p_CvDTree,
+ &_swigt__p_CvDTreeNode,
+ &_swigt__p_CvDTreeParams,
+ &_swigt__p_CvDTreeSplit,
+ &_swigt__p_CvDTreeTrainData,
+ &_swigt__p_CvEM,
+ &_swigt__p_CvEMParams,
+ &_swigt__p_CvERTreeTrainData,
+ &_swigt__p_CvERTrees,
+ &_swigt__p_CvFileNode,
+ &_swigt__p_CvFileStorage,
+ &_swigt__p_CvFilter,
+ &_swigt__p_CvFont,
+ &_swigt__p_CvForestERTree,
+ &_swigt__p_CvForestTree,
+ &_swigt__p_CvGenericHash,
+ &_swigt__p_CvGraph,
+ &_swigt__p_CvGraphEdge,
+ &_swigt__p_CvGraphScanner,
+ &_swigt__p_CvGraphVtx,
+ &_swigt__p_CvGraphVtx2D,
+ &_swigt__p_CvHaarClassifier,
+ &_swigt__p_CvHaarClassifierCascade,
+ &_swigt__p_CvHaarFeature,
+ &_swigt__p_CvHaarStageClassifier,
+ &_swigt__p_CvHidHaarClassifierCascade,
+ &_swigt__p_CvHistogram,
+ &_swigt__p_CvHuMoments,
+ &_swigt__p_CvKNearest,
+ &_swigt__p_CvKalman,
+ &_swigt__p_CvLineIterator,
+ &_swigt__p_CvMLData,
+ &_swigt__p_CvMSERParams,
+ &_swigt__p_CvMat,
+ &_swigt__p_CvMatND,
+ &_swigt__p_CvMatrix3,
+ &_swigt__p_CvMemBlock,
+ &_swigt__p_CvMemStorage,
+ &_swigt__p_CvMemStoragePos,
+ &_swigt__p_CvModuleInfo,
+ &_swigt__p_CvMoments,
+ &_swigt__p_CvNArrayIterator,
+ &_swigt__p_CvNextEdgeType,
+ &_swigt__p_CvNormalBayesClassifier,
+ &_swigt__p_CvPOSITObject,
+ &_swigt__p_CvPair16u32s,
+ &_swigt__p_CvParamGrid,
+ &_swigt__p_CvPluginFuncInfo,
+ &_swigt__p_CvPoint,
+ &_swigt__p_CvPoint2D32f,
+ &_swigt__p_CvPoint2D64f,
+ &_swigt__p_CvPoint3D32f,
+ &_swigt__p_CvPoint3D64f,
+ &_swigt__p_CvQuadEdge2D,
+ &_swigt__p_CvRNG_Wrapper,
+ &_swigt__p_CvRTParams,
+ &_swigt__p_CvRTrees,
+ &_swigt__p_CvRect,
+ &_swigt__p_CvSURFParams,
+ &_swigt__p_CvSURFPoint,
+ &_swigt__p_CvSVM,
+ &_swigt__p_CvSVMDecisionFunc,
+ &_swigt__p_CvSVMKernel,
+ &_swigt__p_CvSVMKernelRow,
+ &_swigt__p_CvSVMParams,
+ &_swigt__p_CvSVMSolutionInfo,
+ &_swigt__p_CvSVMSolver,
+ &_swigt__p_CvScalar,
+ &_swigt__p_CvSeq,
+ &_swigt__p_CvSeqBlock,
+ &_swigt__p_CvSeqReader,
+ &_swigt__p_CvSeqWriter,
+ &_swigt__p_CvSet,
+ &_swigt__p_CvSetElem,
+ &_swigt__p_CvSize,
+ &_swigt__p_CvSize2D32f,
+ &_swigt__p_CvSlice,
+ &_swigt__p_CvSparseMat,
+ &_swigt__p_CvSparseMatIterator,
+ &_swigt__p_CvSparseNode,
+ &_swigt__p_CvStarDetectorParams,
+ &_swigt__p_CvStarKeypoint,
+ &_swigt__p_CvStatModel,
+ &_swigt__p_CvStereoBMState,
+ &_swigt__p_CvStereoGCState,
+ &_swigt__p_CvString,
+ &_swigt__p_CvStringHashNode,
+ &_swigt__p_CvSubdiv2D,
+ &_swigt__p_CvSubdiv2DEdge_Wrapper,
+ &_swigt__p_CvSubdiv2DPoint,
+ &_swigt__p_CvSubdiv2DPointLocation,
+ &_swigt__p_CvTermCriteria,
+ &_swigt__p_CvTrainTestSplit,
+ &_swigt__p_CvTrainTestSplit_class_part,
+ &_swigt__p_CvTrainTestSplit_train_sample_part,
+ &_swigt__p_CvTreeNodeIterator,
+ &_swigt__p_CvTypeInfo,
+ &_swigt__p_CvVectors,
+ &_swigt__p_CvVectors_data,
+ &_swigt__p_GetRow,
+ &_swigt__p_SelectWorkingSet,
+ &_swigt__p__IplConvKernel,
+ &_swigt__p__IplConvKernelFP,
+ &_swigt__p__IplImage,
+ &_swigt__p__IplROI,
+ &_swigt__p__IplTileInfo,
+ &_swigt__p_bool,
+ &_swigt__p_char,
+ &_swigt__p_double,
+ &_swigt__p_float,
+ &_swigt__p_int,
+ &_swigt__p_int64_t,
+ &_swigt__p_p_CvMat,
+ &_swigt__p_p_double,
+ &_swigt__p_p_float,
+ &_swigt__p_p_int,
+ &_swigt__p_p_unsigned_char,
+ &_swigt__p_signed_char,
+ &_swigt__p_size_t,
+ &_swigt__p_uint64_t,
+ &_swigt__p_unsigned_char,
+ &_swigt__p_unsigned_short,
+ &_swigt__p_vectorT_float_t,
+ &_swigt__p_vectorT_vectorT_float_t_t,
+ &_swigt__p_vectorT_vectorT_int_t_t,
+ &_swigt__p_void,
+};
+
+static swig_cast_info _swigc__m_CvSVMKernel__f_int_int_p_p_q_const__float_p_q_const__float_p_float__void[] = { {&_swigt__m_CvSVMKernel__f_int_int_p_p_q_const__float_p_q_const__float_p_float__void, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__m_CvSVMSolver__f_int_p_float_p_float_bool__p_float[] = { {&_swigt__m_CvSVMSolver__f_int_p_float_p_float_bool__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__m_CvSVMSolver__f_r_double_r_double__void[] = { {&_swigt__m_CvSVMSolver__f_r_double_r_double__void, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__m_CvSVMSolver__f_r_int_r_int__bool[] = { {&_swigt__m_CvSVMSolver__f_r_int_r_int__bool, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Calc[] = { {&_swigt__p_Calc, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CalcRho[] = { {&_swigt__p_CalcRho, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Cv32suf[] = { {&_swigt__p_Cv32suf, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Cv64suf[] = { {&_swigt__p_Cv64suf, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvANN_MLP[] = { {&_swigt__p_CvANN_MLP, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvANN_MLP_TrainParams[] = { {&_swigt__p_CvANN_MLP_TrainParams, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvAttrList[] = { {&_swigt__p_CvAttrList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvAvgComp[] = { {&_swigt__p_CvAvgComp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvBoost[] = { {&_swigt__p_CvBoost, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvBoostParams[] = { {&_swigt__p_CvBoostParams, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvBoostTree[] = { {&_swigt__p_CvBoostTree, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvBox2D[] = { {&_swigt__p_CvBox2D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvChain[] = { {&_swigt__p_CvChain, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvChainPtReader[] = { {&_swigt__p_CvChainPtReader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvConDensation[] = { {&_swigt__p_CvConDensation, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvConnectedComp[] = { {&_swigt__p_CvConnectedComp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvContour[] = { {&_swigt__p_CvContour, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvContourTree[] = { {&_swigt__p_CvContourTree, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvConvexityDefect[] = { {&_swigt__p_CvConvexityDefect, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvDTree[] = { {&_swigt__p_CvForestERTree, _p_CvForestERTreeTo_p_CvDTree, 0, 0}, {&_swigt__p_CvForestTree, _p_CvForestTreeTo_p_CvDTree, 0, 0}, {&_swigt__p_CvBoostTree, _p_CvBoostTreeTo_p_CvDTree, 0, 0}, {&_swigt__p_CvDTree, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvDTreeNode[] = { {&_swigt__p_CvDTreeNode, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvDTreeParams[] = { {&_swigt__p_CvRTParams, _p_CvRTParamsTo_p_CvDTreeParams, 0, 0}, {&_swigt__p_CvBoostParams, _p_CvBoostParamsTo_p_CvDTreeParams, 0, 0}, {&_swigt__p_CvDTreeParams, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvDTreeSplit[] = { {&_swigt__p_CvDTreeSplit, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvDTreeTrainData[] = { {&_swigt__p_CvDTreeTrainData, 0, 0, 0}, {&_swigt__p_CvERTreeTrainData, _p_CvERTreeTrainDataTo_p_CvDTreeTrainData, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvEM[] = { {&_swigt__p_CvEM, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvEMParams[] = { {&_swigt__p_CvEMParams, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvERTreeTrainData[] = { {&_swigt__p_CvERTreeTrainData, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvERTrees[] = { {&_swigt__p_CvERTrees, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvFileNode[] = { {&_swigt__p_CvFileNode, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvFileStorage[] = { {&_swigt__p_CvFileStorage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvFilter[] = { {&_swigt__p_CvFilter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvFont[] = { {&_swigt__p_CvFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvForestERTree[] = { {&_swigt__p_CvForestERTree, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvForestTree[] = { {&_swigt__p_CvForestERTree, _p_CvForestERTreeTo_p_CvForestTree, 0, 0}, {&_swigt__p_CvForestTree, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvGenericHash[] = { {&_swigt__p_CvGenericHash, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvGraph[] = { {&_swigt__p_CvGraph, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvGraphEdge[] = { {&_swigt__p_CvGraphEdge, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvGraphScanner[] = { {&_swigt__p_CvGraphScanner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvGraphVtx[] = { {&_swigt__p_CvGraphVtx, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvGraphVtx2D[] = { {&_swigt__p_CvGraphVtx2D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvHaarClassifier[] = { {&_swigt__p_CvHaarClassifier, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvHaarClassifierCascade[] = { {&_swigt__p_CvHaarClassifierCascade, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvHaarFeature[] = { {&_swigt__p_CvHaarFeature, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvHaarStageClassifier[] = { {&_swigt__p_CvHaarStageClassifier, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvHidHaarClassifierCascade[] = { {&_swigt__p_CvHidHaarClassifierCascade, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvHistogram[] = { {&_swigt__p_CvHistogram, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvHuMoments[] = { {&_swigt__p_CvHuMoments, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvKNearest[] = { {&_swigt__p_CvKNearest, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvKalman[] = { {&_swigt__p_CvKalman, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvLineIterator[] = { {&_swigt__p_CvLineIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvMLData[] = { {&_swigt__p_CvMLData, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvMSERParams[] = { {&_swigt__p_CvMSERParams, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvMat[] = { {&_swigt__p_CvMat, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvMatND[] = { {&_swigt__p_CvMatND, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvMatrix3[] = { {&_swigt__p_CvMatrix3, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvMemBlock[] = { {&_swigt__p_CvMemBlock, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvMemStorage[] = { {&_swigt__p_CvMemStorage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvMemStoragePos[] = { {&_swigt__p_CvMemStoragePos, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvModuleInfo[] = { {&_swigt__p_CvModuleInfo, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvMoments[] = { {&_swigt__p_CvMoments, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvNArrayIterator[] = { {&_swigt__p_CvNArrayIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvNextEdgeType[] = { {&_swigt__p_CvNextEdgeType, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvNormalBayesClassifier[] = { {&_swigt__p_CvNormalBayesClassifier, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvPOSITObject[] = { {&_swigt__p_CvPOSITObject, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvPair16u32s[] = { {&_swigt__p_CvPair16u32s, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvParamGrid[] = { {&_swigt__p_CvParamGrid, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvPluginFuncInfo[] = { {&_swigt__p_CvPluginFuncInfo, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvPoint[] = { {&_swigt__p_CvPoint, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvPoint2D32f[] = { {&_swigt__p_CvPoint2D32f, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvPoint2D64f[] = { {&_swigt__p_CvPoint2D64f, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvPoint3D32f[] = { {&_swigt__p_CvPoint3D32f, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvPoint3D64f[] = { {&_swigt__p_CvPoint3D64f, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvQuadEdge2D[] = { {&_swigt__p_CvQuadEdge2D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvRNG_Wrapper[] = { {&_swigt__p_CvRNG_Wrapper, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvRTParams[] = { {&_swigt__p_CvRTParams, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvRTrees[] = { {&_swigt__p_CvRTrees, 0, 0, 0}, {&_swigt__p_CvERTrees, _p_CvERTreesTo_p_CvRTrees, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvRect[] = { {&_swigt__p_CvRect, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSURFParams[] = { {&_swigt__p_CvSURFParams, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSURFPoint[] = { {&_swigt__p_CvSURFPoint, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSVM[] = { {&_swigt__p_CvSVM, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSVMDecisionFunc[] = { {&_swigt__p_CvSVMDecisionFunc, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSVMKernel[] = { {&_swigt__p_CvSVMKernel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSVMKernelRow[] = { {&_swigt__p_CvSVMKernelRow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSVMParams[] = { {&_swigt__p_CvSVMParams, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSVMSolutionInfo[] = { {&_swigt__p_CvSVMSolutionInfo, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSVMSolver[] = { {&_swigt__p_CvSVMSolver, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvScalar[] = { {&_swigt__p_CvScalar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSeq[] = { {&_swigt__p_CvSeq, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSeqBlock[] = { {&_swigt__p_CvSeqBlock, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSeqReader[] = { {&_swigt__p_CvSeqReader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSeqWriter[] = { {&_swigt__p_CvSeqWriter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSet[] = { {&_swigt__p_CvSet, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSetElem[] = { {&_swigt__p_CvSetElem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSize[] = { {&_swigt__p_CvSize, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSize2D32f[] = { {&_swigt__p_CvSize2D32f, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSlice[] = { {&_swigt__p_CvSlice, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSparseMat[] = { {&_swigt__p_CvSparseMat, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSparseMatIterator[] = { {&_swigt__p_CvSparseMatIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSparseNode[] = { {&_swigt__p_CvSparseNode, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvStarDetectorParams[] = { {&_swigt__p_CvStarDetectorParams, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvStarKeypoint[] = { {&_swigt__p_CvStarKeypoint, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvStatModel[] = { {&_swigt__p_CvNormalBayesClassifier, _p_CvNormalBayesClassifierTo_p_CvStatModel, 0, 0}, {&_swigt__p_CvForestERTree, _p_CvForestERTreeTo_p_CvStatModel, 0, 0}, {&_swigt__p_CvANN_MLP, _p_CvANN_MLPTo_p_CvStatModel, 0, 0}, {&_swigt__p_CvStatModel, 0, 0, 0}, {&_swigt__p_CvKNearest, _p_CvKNearestTo_p_CvStatModel, 0, 0}, {&_swigt__p_CvForestTree, _p_CvForestTreeTo_p_CvStatModel, 0, 0}, {&_swigt__p_CvRTrees, _p_CvRTreesTo_p_CvStatModel, 0, 0}, {&_swigt__p_CvBoostTree, _p_CvBoostTreeTo_p_CvStatModel, 0, 0}, {&_swigt__p_CvERTrees, _p_CvERTreesTo_p_CvStatModel, 0, 0}, {&_swigt__p_CvEM, _p_CvEMTo_p_CvStatModel, 0, 0}, {&_swigt__p_CvSVM, _p_CvSVMTo_p_CvStatModel, 0, 0}, {&_swigt__p_CvDTree, _p_CvDTreeTo_p_CvStatModel, 0, 0}, {&_swigt__p_CvBoost, _p_CvBoostTo_p_CvStatModel, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvStereoBMState[] = { {&_swigt__p_CvStereoBMState, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvStereoGCState[] = { {&_swigt__p_CvStereoGCState, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvString[] = { {&_swigt__p_CvString, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvStringHashNode[] = { {&_swigt__p_CvStringHashNode, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSubdiv2D[] = { {&_swigt__p_CvSubdiv2D, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSubdiv2DEdge_Wrapper[] = { {&_swigt__p_CvSubdiv2DEdge_Wrapper, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSubdiv2DPoint[] = { {&_swigt__p_CvSubdiv2DPoint, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvSubdiv2DPointLocation[] = { {&_swigt__p_CvSubdiv2DPointLocation, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvTermCriteria[] = { {&_swigt__p_CvTermCriteria, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvTrainTestSplit[] = { {&_swigt__p_CvTrainTestSplit, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvTrainTestSplit_class_part[] = { {&_swigt__p_CvTrainTestSplit_class_part, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvTrainTestSplit_train_sample_part[] = { {&_swigt__p_CvTrainTestSplit_train_sample_part, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvTreeNodeIterator[] = { {&_swigt__p_CvTreeNodeIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvTypeInfo[] = { {&_swigt__p_CvTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvVectors[] = { {&_swigt__p_CvVectors, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CvVectors_data[] = { {&_swigt__p_CvVectors_data, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_GetRow[] = { {&_swigt__p_GetRow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_SelectWorkingSet[] = { {&_swigt__p_SelectWorkingSet, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p__IplConvKernel[] = { {&_swigt__p__IplConvKernel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p__IplConvKernelFP[] = { {&_swigt__p__IplConvKernelFP, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p__IplImage[] = { {&_swigt__p__IplImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p__IplROI[] = { {&_swigt__p__IplROI, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p__IplTileInfo[] = { {&_swigt__p__IplTileInfo, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_bool[] = { {&_swigt__p_bool, 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_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_int64_t[] = { {&_swigt__p_int64_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_CvMat[] = { {&_swigt__p_p_CvMat, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_float[] = { {&_swigt__p_p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_int[] = { {&_swigt__p_p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_unsigned_char[] = { {&_swigt__p_p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_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_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_vectorT_float_t[] = { {&_swigt__p_vectorT_float_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_vectorT_vectorT_float_t_t[] = { {&_swigt__p_vectorT_vectorT_float_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_vectorT_vectorT_int_t_t[] = { {&_swigt__p_vectorT_vectorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+ _swigc__m_CvSVMKernel__f_int_int_p_p_q_const__float_p_q_const__float_p_float__void,
+ _swigc__m_CvSVMSolver__f_int_p_float_p_float_bool__p_float,
+ _swigc__m_CvSVMSolver__f_r_double_r_double__void,
+ _swigc__m_CvSVMSolver__f_r_int_r_int__bool,
+ _swigc__p_Calc,
+ _swigc__p_CalcRho,
+ _swigc__p_Cv32suf,
+ _swigc__p_Cv64suf,
+ _swigc__p_CvANN_MLP,
+ _swigc__p_CvANN_MLP_TrainParams,
+ _swigc__p_CvAttrList,
+ _swigc__p_CvAvgComp,
+ _swigc__p_CvBoost,
+ _swigc__p_CvBoostParams,
+ _swigc__p_CvBoostTree,
+ _swigc__p_CvBox2D,
+ _swigc__p_CvChain,
+ _swigc__p_CvChainPtReader,
+ _swigc__p_CvConDensation,
+ _swigc__p_CvConnectedComp,
+ _swigc__p_CvContour,
+ _swigc__p_CvContourTree,
+ _swigc__p_CvConvexityDefect,
+ _swigc__p_CvDTree,
+ _swigc__p_CvDTreeNode,
+ _swigc__p_CvDTreeParams,
+ _swigc__p_CvDTreeSplit,
+ _swigc__p_CvDTreeTrainData,
+ _swigc__p_CvEM,
+ _swigc__p_CvEMParams,
+ _swigc__p_CvERTreeTrainData,
+ _swigc__p_CvERTrees,
+ _swigc__p_CvFileNode,
+ _swigc__p_CvFileStorage,
+ _swigc__p_CvFilter,
+ _swigc__p_CvFont,
+ _swigc__p_CvForestERTree,
+ _swigc__p_CvForestTree,
+ _swigc__p_CvGenericHash,
+ _swigc__p_CvGraph,
+ _swigc__p_CvGraphEdge,
+ _swigc__p_CvGraphScanner,
+ _swigc__p_CvGraphVtx,
+ _swigc__p_CvGraphVtx2D,
+ _swigc__p_CvHaarClassifier,
+ _swigc__p_CvHaarClassifierCascade,
+ _swigc__p_CvHaarFeature,
+ _swigc__p_CvHaarStageClassifier,
+ _swigc__p_CvHidHaarClassifierCascade,
+ _swigc__p_CvHistogram,
+ _swigc__p_CvHuMoments,
+ _swigc__p_CvKNearest,
+ _swigc__p_CvKalman,
+ _swigc__p_CvLineIterator,
+ _swigc__p_CvMLData,
+ _swigc__p_CvMSERParams,
+ _swigc__p_CvMat,
+ _swigc__p_CvMatND,
+ _swigc__p_CvMatrix3,
+ _swigc__p_CvMemBlock,
+ _swigc__p_CvMemStorage,
+ _swigc__p_CvMemStoragePos,
+ _swigc__p_CvModuleInfo,
+ _swigc__p_CvMoments,
+ _swigc__p_CvNArrayIterator,
+ _swigc__p_CvNextEdgeType,
+ _swigc__p_CvNormalBayesClassifier,
+ _swigc__p_CvPOSITObject,
+ _swigc__p_CvPair16u32s,
+ _swigc__p_CvParamGrid,
+ _swigc__p_CvPluginFuncInfo,
+ _swigc__p_CvPoint,
+ _swigc__p_CvPoint2D32f,
+ _swigc__p_CvPoint2D64f,
+ _swigc__p_CvPoint3D32f,
+ _swigc__p_CvPoint3D64f,
+ _swigc__p_CvQuadEdge2D,
+ _swigc__p_CvRNG_Wrapper,
+ _swigc__p_CvRTParams,
+ _swigc__p_CvRTrees,
+ _swigc__p_CvRect,
+ _swigc__p_CvSURFParams,
+ _swigc__p_CvSURFPoint,
+ _swigc__p_CvSVM,
+ _swigc__p_CvSVMDecisionFunc,
+ _swigc__p_CvSVMKernel,
+ _swigc__p_CvSVMKernelRow,
+ _swigc__p_CvSVMParams,
+ _swigc__p_CvSVMSolutionInfo,
+ _swigc__p_CvSVMSolver,
+ _swigc__p_CvScalar,
+ _swigc__p_CvSeq,
+ _swigc__p_CvSeqBlock,
+ _swigc__p_CvSeqReader,
+ _swigc__p_CvSeqWriter,
+ _swigc__p_CvSet,
+ _swigc__p_CvSetElem,
+ _swigc__p_CvSize,
+ _swigc__p_CvSize2D32f,
+ _swigc__p_CvSlice,
+ _swigc__p_CvSparseMat,
+ _swigc__p_CvSparseMatIterator,
+ _swigc__p_CvSparseNode,
+ _swigc__p_CvStarDetectorParams,
+ _swigc__p_CvStarKeypoint,
+ _swigc__p_CvStatModel,
+ _swigc__p_CvStereoBMState,
+ _swigc__p_CvStereoGCState,
+ _swigc__p_CvString,
+ _swigc__p_CvStringHashNode,
+ _swigc__p_CvSubdiv2D,
+ _swigc__p_CvSubdiv2DEdge_Wrapper,
+ _swigc__p_CvSubdiv2DPoint,
+ _swigc__p_CvSubdiv2DPointLocation,
+ _swigc__p_CvTermCriteria,
+ _swigc__p_CvTrainTestSplit,
+ _swigc__p_CvTrainTestSplit_class_part,
+ _swigc__p_CvTrainTestSplit_train_sample_part,
+ _swigc__p_CvTreeNodeIterator,
+ _swigc__p_CvTypeInfo,
+ _swigc__p_CvVectors,
+ _swigc__p_CvVectors_data,
+ _swigc__p_GetRow,
+ _swigc__p_SelectWorkingSet,
+ _swigc__p__IplConvKernel,
+ _swigc__p__IplConvKernelFP,
+ _swigc__p__IplImage,
+ _swigc__p__IplROI,
+ _swigc__p__IplTileInfo,
+ _swigc__p_bool,
+ _swigc__p_char,
+ _swigc__p_double,
+ _swigc__p_float,
+ _swigc__p_int,
+ _swigc__p_int64_t,
+ _swigc__p_p_CvMat,
+ _swigc__p_p_double,
+ _swigc__p_p_float,
+ _swigc__p_p_int,
+ _swigc__p_p_unsigned_char,
+ _swigc__p_signed_char,
+ _swigc__p_size_t,
+ _swigc__p_uint64_t,
+ _swigc__p_unsigned_char,
+ _swigc__p_unsigned_short,
+ _swigc__p_vectorT_float_t,
+ _swigc__p_vectorT_vectorT_float_t_t,
+ _swigc__p_vectorT_vectorT_int_t_t,
+ _swigc__p_void,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * 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 staticly 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 found, init;
+
+ clientdata = clientdata;
+
+ /* 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);
+ module_head = &swig_module;
+ } else {
+ /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+ found=0;
+ iter=module_head;
+ do {
+ if (iter==&swig_module) {
+ found=1;
+ break;
+ }
+ iter=iter->next;
+ } while (iter!= module_head);
+
+ /* if the is found in the list, then all is done and we may leave */
+ if (found) return;
+ /* otherwise we must add out module into the list */
+ swig_module.next = module_head->next;
+ module_head->next = &swig_module;
+ }
+
+ /* When multiple interpeters 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
+
+
+
+static void SWIG_init_user(octave_swig_type* module_ns);
+
+DEFUN_DLD (SWIG_name,args,nargout,SWIG_name_d) {
+ static bool already_init=false;
+ if (already_init)
+ return octave_value_list();
+ already_init=true;
+
+ octave_swig_ref::register_type();
+ octave_swig_packed::register_type();
+ SWIG_InitializeModule(0);
+ SWIG_PropagateClientData();
+
+ install_builtin_function(swig_type,"swig_type",std::string());
+ install_builtin_function(swig_typequery,"swig_typequery",std::string());
+ install_builtin_function(swig_this,"swig_this",std::string());
+ install_builtin_function(swig_subclass,"subclass",std::string());
+
+ bool global_option=true; // * swig cli option should control this default
+ for (int j=0;j<args.length();++j)
+ if (args(j).is_string()&&args(j).string_value()=="noglobal")
+ global_option=true;
+ else if (args(j).is_string()&&args(j).string_value()=="noglobal")
+ global_option=false;
+
+ octave_swig_type* cvar_ns=new octave_swig_type;
+ for (int j=0;swig_globals[j].name;++j)
+ if (swig_globals[j].get_method)
+ cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
+
+ octave_swig_type* module_ns=new octave_swig_type(0, 0, 0, true);
+ module_ns->assign("cvar",Swig::swig_value_ref(cvar_ns));
+ for (int j=0;swig_globals[j].name;++j)
+ if (swig_globals[j].method)
+ module_ns->assign(swig_globals[j].name,&swig_globals[j]);
+
+ // * need better solution here; swig_type -> octave_class mapping is
+ // * really n-to-1, in some cases such as template partial spec, etc.
+ // * see failing tests.
+ for (int j=0;swig_types[j];++j)
+ if (swig_types[j]->clientdata) {
+ swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
+ module_ns->assign(c->name,
+ Swig::swig_value_ref
+ (new octave_swig_type(0,swig_types[j])));
+ }
+
+ SWIG_init_user(module_ns);
+
+ SWIG_InstallOps(octave_swig_ref::static_type_id());
+
+ // the incref is necessary so install_global doesn't destroy module_ns,
+ // as it would if it installed something with the same name as the module.
+ module_ns->incref();
+ if (global_option)
+ module_ns->install_global();
+ module_ns->decref();
+
+#if USE_OCTAVE_API_VERSION<37
+ link_to_global_variable(curr_sym_tab->lookup(SWIG_name_d,true));
+#else
+ symbol_table::varref(SWIG_name_d);
+ symbol_table::mark_global(SWIG_name_d);
+#endif
+ set_global_value(SWIG_name_d,Swig::swig_value_ref(module_ns));
+
+#if USE_OCTAVE_API_VERSION>=37
+ mlock();
+#endif
+
+ return octave_value_list();
+}
+
+// workaround bug in octave where installing global variable of custom type and then
+// exiting without explicitly clearing the variable causes octave to segfault.
+#if USE_OCTAVE_API_VERSION>=37
+struct oct_file_unload {
+ ~oct_file_unload() {
+ string_vector vars = symbol_table::global_variable_names();
+ for (int i = 0; i < vars.length(); i++)
+ symbol_table::clear_global(vars[i]);
+ }
+};
+static oct_file_unload __unload;
+#endif
+
+
+static void SWIG_init_user(octave_swig_type* module_ns)
+{
+ feval("cv",octave_value_list(),0);
+ SWIG_Octave_SetConstant(module_ns,"CV_LOG2PI",octave_value((1.8378770664093454835606594728112)));
+ SWIG_Octave_SetConstant(module_ns,"CV_COL_SAMPLE",SWIG_From_int((int)(0)));
+ SWIG_Octave_SetConstant(module_ns,"CV_ROW_SAMPLE",SWIG_From_int((int)(1)));
+ SWIG_Octave_SetConstant(module_ns,"CV_VAR_NUMERICAL",SWIG_From_int((int)(0)));
+ SWIG_Octave_SetConstant(module_ns,"CV_VAR_ORDERED",SWIG_From_int((int)(0)));
+ SWIG_Octave_SetConstant(module_ns,"CV_VAR_CATEGORICAL",SWIG_From_int((int)(1)));
+ SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_ML_SVM",SWIG_FromCharPtr("opencv-ml-svm"));
+ SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_ML_KNN",SWIG_FromCharPtr("opencv-ml-knn"));
+ SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_ML_NBAYES",SWIG_FromCharPtr("opencv-ml-bayesian"));
+ SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_ML_EM",SWIG_FromCharPtr("opencv-ml-em"));
+ SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_ML_BOOSTING",SWIG_FromCharPtr("opencv-ml-boost-tree"));
+ SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_ML_TREE",SWIG_FromCharPtr("opencv-ml-tree"));
+ SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_ML_ANN_MLP",SWIG_FromCharPtr("opencv-ml-ann-mlp"));
+ SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_ML_CNN",SWIG_FromCharPtr("opencv-ml-cnn"));
+ SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_ML_RTREES",SWIG_FromCharPtr("opencv-ml-random-trees"));
+ SWIG_Octave_SetConstant(module_ns,"CV_TRAIN_ERROR",SWIG_From_int((int)(0)));
+ SWIG_Octave_SetConstant(module_ns,"CV_TEST_ERROR",SWIG_From_int((int)(1)));
+ SWIG_Octave_SetConstant(module_ns,"CvParamGrid_SVM_C",SWIG_From_int((int)(CvParamGrid::SVM_C)));
+ SWIG_Octave_SetConstant(module_ns,"CvParamGrid_SVM_GAMMA",SWIG_From_int((int)(CvParamGrid::SVM_GAMMA)));
+ SWIG_Octave_SetConstant(module_ns,"CvParamGrid_SVM_P",SWIG_From_int((int)(CvParamGrid::SVM_P)));
+ SWIG_Octave_SetConstant(module_ns,"CvParamGrid_SVM_NU",SWIG_From_int((int)(CvParamGrid::SVM_NU)));
+ SWIG_Octave_SetConstant(module_ns,"CvParamGrid_SVM_COEF",SWIG_From_int((int)(CvParamGrid::SVM_COEF)));
+ SWIG_Octave_SetConstant(module_ns,"CvParamGrid_SVM_DEGREE",SWIG_From_int((int)(CvParamGrid::SVM_DEGREE)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_C_SVC",SWIG_From_int((int)(CvSVM::C_SVC)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_NU_SVC",SWIG_From_int((int)(CvSVM::NU_SVC)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_ONE_CLASS",SWIG_From_int((int)(CvSVM::ONE_CLASS)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_EPS_SVR",SWIG_From_int((int)(CvSVM::EPS_SVR)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_NU_SVR",SWIG_From_int((int)(CvSVM::NU_SVR)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_LINEAR",SWIG_From_int((int)(CvSVM::LINEAR)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_POLY",SWIG_From_int((int)(CvSVM::POLY)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_RBF",SWIG_From_int((int)(CvSVM::RBF)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_SIGMOID",SWIG_From_int((int)(CvSVM::SIGMOID)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_C",SWIG_From_int((int)(CvSVM::C)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_GAMMA",SWIG_From_int((int)(CvSVM::GAMMA)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_P",SWIG_From_int((int)(CvSVM::P)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_NU",SWIG_From_int((int)(CvSVM::NU)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_COEF",SWIG_From_int((int)(CvSVM::COEF)));
+ SWIG_Octave_SetConstant(module_ns,"CvSVM_DEGREE",SWIG_From_int((int)(CvSVM::DEGREE)));
+ SWIG_Octave_SetConstant(module_ns,"CvEM_COV_MAT_SPHERICAL",SWIG_From_int((int)(CvEM::COV_MAT_SPHERICAL)));
+ SWIG_Octave_SetConstant(module_ns,"CvEM_COV_MAT_DIAGONAL",SWIG_From_int((int)(CvEM::COV_MAT_DIAGONAL)));
+ SWIG_Octave_SetConstant(module_ns,"CvEM_COV_MAT_GENERIC",SWIG_From_int((int)(CvEM::COV_MAT_GENERIC)));
+ SWIG_Octave_SetConstant(module_ns,"CvEM_START_E_STEP",SWIG_From_int((int)(CvEM::START_E_STEP)));
+ SWIG_Octave_SetConstant(module_ns,"CvEM_START_M_STEP",SWIG_From_int((int)(CvEM::START_M_STEP)));
+ SWIG_Octave_SetConstant(module_ns,"CvEM_START_AUTO_STEP",SWIG_From_int((int)(CvEM::START_AUTO_STEP)));
+ SWIG_Octave_SetConstant(module_ns,"CvBoost_DISCRETE",SWIG_From_int((int)(CvBoost::DISCRETE)));
+ SWIG_Octave_SetConstant(module_ns,"CvBoost_REAL",SWIG_From_int((int)(CvBoost::REAL)));
+ SWIG_Octave_SetConstant(module_ns,"CvBoost_LOGIT",SWIG_From_int((int)(CvBoost::LOGIT)));
+ SWIG_Octave_SetConstant(module_ns,"CvBoost_GENTLE",SWIG_From_int((int)(CvBoost::GENTLE)));
+ SWIG_Octave_SetConstant(module_ns,"CvBoost_DEFAULT",SWIG_From_int((int)(CvBoost::DEFAULT)));
+ SWIG_Octave_SetConstant(module_ns,"CvBoost_GINI",SWIG_From_int((int)(CvBoost::GINI)));
+ SWIG_Octave_SetConstant(module_ns,"CvBoost_MISCLASS",SWIG_From_int((int)(CvBoost::MISCLASS)));
+ SWIG_Octave_SetConstant(module_ns,"CvBoost_SQERR",SWIG_From_int((int)(CvBoost::SQERR)));
+ SWIG_Octave_SetConstant(module_ns,"CvANN_MLP_TrainParams_BACKPROP",SWIG_From_int((int)(CvANN_MLP_TrainParams::BACKPROP)));
+ SWIG_Octave_SetConstant(module_ns,"CvANN_MLP_TrainParams_RPROP",SWIG_From_int((int)(CvANN_MLP_TrainParams::RPROP)));
+ SWIG_Octave_SetConstant(module_ns,"CvANN_MLP_IDENTITY",SWIG_From_int((int)(CvANN_MLP::IDENTITY)));
+ SWIG_Octave_SetConstant(module_ns,"CvANN_MLP_SIGMOID_SYM",SWIG_From_int((int)(CvANN_MLP::SIGMOID_SYM)));
+ SWIG_Octave_SetConstant(module_ns,"CvANN_MLP_GAUSSIAN",SWIG_From_int((int)(CvANN_MLP::GAUSSIAN)));
+ SWIG_Octave_SetConstant(module_ns,"CvANN_MLP_UPDATE_WEIGHTS",SWIG_From_int((int)(CvANN_MLP::UPDATE_WEIGHTS)));
+ SWIG_Octave_SetConstant(module_ns,"CvANN_MLP_NO_INPUT_SCALE",SWIG_From_int((int)(CvANN_MLP::NO_INPUT_SCALE)));
+ SWIG_Octave_SetConstant(module_ns,"CvANN_MLP_NO_OUTPUT_SCALE",SWIG_From_int((int)(CvANN_MLP::NO_OUTPUT_SCALE)));
+ SWIG_Octave_SetConstant(module_ns,"CV_TS_CONCENTRIC_SPHERES",SWIG_From_int((int)(0)));
+ SWIG_Octave_SetConstant(module_ns,"CV_COUNT",SWIG_From_int((int)(0)));
+ SWIG_Octave_SetConstant(module_ns,"CV_PORTION",SWIG_From_int((int)(1)));
+}
+
projects / opencv / blobdiff