X-Git-Url: https://vcs.maemo.org/git/?a=blobdiff_plain;f=interfaces%2Fswig%2Foctave%2Fcv_wrap.cpp;fp=interfaces%2Fswig%2Foctave%2Fcv_wrap.cpp;h=078c48755ec9292f55c5573ce5ddf461503978ef;hb=e4c14cdbdf2fe805e79cd96ded236f57e7b89060;hp=0000000000000000000000000000000000000000;hpb=454138ff8a20f6edb9b65a910101403d8b520643;p=opencv diff --git a/interfaces/swig/octave/cv_wrap.cpp b/interfaces/swig/octave/cv_wrap.cpp new file mode 100644 index 0000000..078c487 --- /dev/null +++ b/interfaces/swig/octave/cv_wrap.cpp @@ -0,0 +1,106279 @@ +/* ---------------------------------------------------------------------------- + * 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 "cv" +#define SWIG_name cv +#define OCTAVE_API_VERSION_OPTION 0 + + +#ifdef __cplusplus +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigMovePointer { + T *ptr; + SwigMovePointer(T *p) : ptr(p) { } + ~SwigMovePointer() { delete ptr; } + SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } + operator T&() const { return *pointer.ptr; } + T *operator&() { return pointer.ptr; } +}; + +template T SwigValueInit() { + return T(); +} +#endif + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + + + +#include +#include +#include +#include +#include + +/* ----------------------------------------------------------------------------- + * 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 () { + if () { + *ptr = ; + return SWIG_NEWOBJ; + } else { + *ptr = ; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + SWIG errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows to return the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() +*/ + +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporal objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *, int *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store information on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (int)((l1 - f1) - (l2 - f2)); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if 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 ||... + 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 +#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 +#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 +#include +#include + +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(""); + 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_p_Cv32suf swig_types[0] +#define SWIGTYPE_p_Cv64suf swig_types[1] +#define SWIGTYPE_p_CvAttrList swig_types[2] +#define SWIGTYPE_p_CvAvgComp swig_types[3] +#define SWIGTYPE_p_CvBox2D swig_types[4] +#define SWIGTYPE_p_CvChain swig_types[5] +#define SWIGTYPE_p_CvChainPtReader swig_types[6] +#define SWIGTYPE_p_CvConDensation swig_types[7] +#define SWIGTYPE_p_CvConnectedComp swig_types[8] +#define SWIGTYPE_p_CvContour swig_types[9] +#define SWIGTYPE_p_CvContourTree swig_types[10] +#define SWIGTYPE_p_CvConvexityDefect swig_types[11] +#define SWIGTYPE_p_CvFeatureTree swig_types[12] +#define SWIGTYPE_p_CvFileNode swig_types[13] +#define SWIGTYPE_p_CvFileNode_data swig_types[14] +#define SWIGTYPE_p_CvFileStorage swig_types[15] +#define SWIGTYPE_p_CvFilter swig_types[16] +#define SWIGTYPE_p_CvFont swig_types[17] +#define SWIGTYPE_p_CvGenericHash swig_types[18] +#define SWIGTYPE_p_CvGraph swig_types[19] +#define SWIGTYPE_p_CvGraphEdge swig_types[20] +#define SWIGTYPE_p_CvGraphScanner swig_types[21] +#define SWIGTYPE_p_CvGraphVtx swig_types[22] +#define SWIGTYPE_p_CvGraphVtx2D swig_types[23] +#define SWIGTYPE_p_CvHaarClassifier swig_types[24] +#define SWIGTYPE_p_CvHaarClassifierCascade swig_types[25] +#define SWIGTYPE_p_CvHaarFeature swig_types[26] +#define SWIGTYPE_p_CvHaarFeature_rect swig_types[27] +#define SWIGTYPE_p_CvHaarStageClassifier swig_types[28] +#define SWIGTYPE_p_CvHidHaarClassifierCascade swig_types[29] +#define SWIGTYPE_p_CvHistogram swig_types[30] +#define SWIGTYPE_p_CvHuMoments swig_types[31] +#define SWIGTYPE_p_CvImage swig_types[32] +#define SWIGTYPE_p_CvKalman swig_types[33] +#define SWIGTYPE_p_CvLSH swig_types[34] +#define SWIGTYPE_p_CvLSHOperations swig_types[35] +#define SWIGTYPE_p_CvLineIterator swig_types[36] +#define SWIGTYPE_p_CvMSERParams swig_types[37] +#define SWIGTYPE_p_CvMat swig_types[38] +#define SWIGTYPE_p_CvMatND swig_types[39] +#define SWIGTYPE_p_CvMatND_data swig_types[40] +#define SWIGTYPE_p_CvMatND_dim swig_types[41] +#define SWIGTYPE_p_CvMat_data swig_types[42] +#define SWIGTYPE_p_CvMatrix swig_types[43] +#define SWIGTYPE_p_CvMatrix3 swig_types[44] +#define SWIGTYPE_p_CvMemBlock swig_types[45] +#define SWIGTYPE_p_CvMemStorage swig_types[46] +#define SWIGTYPE_p_CvMemStoragePos swig_types[47] +#define SWIGTYPE_p_CvModule swig_types[48] +#define SWIGTYPE_p_CvModuleInfo swig_types[49] +#define SWIGTYPE_p_CvMoments swig_types[50] +#define SWIGTYPE_p_CvNArrayIterator swig_types[51] +#define SWIGTYPE_p_CvNextEdgeType swig_types[52] +#define SWIGTYPE_p_CvPOSITObject swig_types[53] +#define SWIGTYPE_p_CvPluginFuncInfo swig_types[54] +#define SWIGTYPE_p_CvPoint swig_types[55] +#define SWIGTYPE_p_CvPoint2D32f swig_types[56] +#define SWIGTYPE_p_CvPoint2D64f swig_types[57] +#define SWIGTYPE_p_CvPoint3D32f swig_types[58] +#define SWIGTYPE_p_CvPoint3D64f swig_types[59] +#define SWIGTYPE_p_CvQuadEdge2D swig_types[60] +#define SWIGTYPE_p_CvRNG_Wrapper swig_types[61] +#define SWIGTYPE_p_CvRandState swig_types[62] +#define SWIGTYPE_p_CvRect swig_types[63] +#define SWIGTYPE_p_CvSURFParams swig_types[64] +#define SWIGTYPE_p_CvSURFPoint swig_types[65] +#define SWIGTYPE_p_CvScalar swig_types[66] +#define SWIGTYPE_p_CvSeq swig_types[67] +#define SWIGTYPE_p_CvSeqBlock swig_types[68] +#define SWIGTYPE_p_CvSeqReader swig_types[69] +#define SWIGTYPE_p_CvSeqWriter swig_types[70] +#define SWIGTYPE_p_CvSet swig_types[71] +#define SWIGTYPE_p_CvSetElem swig_types[72] +#define SWIGTYPE_p_CvSize swig_types[73] +#define SWIGTYPE_p_CvSize2D32f swig_types[74] +#define SWIGTYPE_p_CvSlice swig_types[75] +#define SWIGTYPE_p_CvSparseMat swig_types[76] +#define SWIGTYPE_p_CvSparseMatIterator swig_types[77] +#define SWIGTYPE_p_CvSparseNode swig_types[78] +#define SWIGTYPE_p_CvStarDetectorParams swig_types[79] +#define SWIGTYPE_p_CvStarKeypoint swig_types[80] +#define SWIGTYPE_p_CvStereoBMState swig_types[81] +#define SWIGTYPE_p_CvStereoGCState swig_types[82] +#define SWIGTYPE_p_CvString swig_types[83] +#define SWIGTYPE_p_CvStringHashNode swig_types[84] +#define SWIGTYPE_p_CvSubdiv2D swig_types[85] +#define SWIGTYPE_p_CvSubdiv2DEdge_Wrapper swig_types[86] +#define SWIGTYPE_p_CvSubdiv2DPoint swig_types[87] +#define SWIGTYPE_p_CvSubdiv2DPointLocation swig_types[88] +#define SWIGTYPE_p_CvTermCriteria swig_types[89] +#define SWIGTYPE_p_CvTreeNodeIterator swig_types[90] +#define SWIGTYPE_p_CvTupleT_CvPoint_2_t swig_types[91] +#define SWIGTYPE_p_CvTupleT_float_2_t swig_types[92] +#define SWIGTYPE_p_CvTupleT_float_3_t swig_types[93] +#define SWIGTYPE_p_CvType swig_types[94] +#define SWIGTYPE_p_CvTypeInfo swig_types[95] +#define SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t swig_types[96] +#define SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t swig_types[97] +#define SWIGTYPE_p_CvTypedSeqT_CvPoint_t swig_types[98] +#define SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t swig_types[99] +#define SWIGTYPE_p_CvTypedSeqT_CvRect_t swig_types[100] +#define SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t swig_types[101] +#define SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t swig_types[102] +#define SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t swig_types[103] +#define SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t swig_types[104] +#define SWIGTYPE_p__CvContourScanner swig_types[105] +#define SWIGTYPE_p__IplConvKernel swig_types[106] +#define SWIGTYPE_p__IplConvKernelFP swig_types[107] +#define SWIGTYPE_p__IplImage swig_types[108] +#define SWIGTYPE_p__IplROI swig_types[109] +#define SWIGTYPE_p__IplTileInfo swig_types[110] +#define SWIGTYPE_p_a_2__float swig_types[111] +#define SWIGTYPE_p_a_2__signed_char swig_types[112] +#define SWIGTYPE_p_a_3__float swig_types[113] +#define SWIGTYPE_p_allocator_type swig_types[114] +#define SWIGTYPE_p_char swig_types[115] +#define SWIGTYPE_p_difference_type swig_types[116] +#define SWIGTYPE_p_double swig_types[117] +#define SWIGTYPE_p_f_int_int_int_int_int__p__IplROI swig_types[118] +#define SWIGTYPE_p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage swig_types[119] +#define SWIGTYPE_p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int swig_types[120] +#define SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void swig_types[121] +#define SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void swig_types[122] +#define SWIGTYPE_p_f_p__IplImage_int__void swig_types[123] +#define SWIGTYPE_p_f_p__IplImage_int_int__void swig_types[124] +#define SWIGTYPE_p_f_p_p_void__void swig_types[125] +#define SWIGTYPE_p_f_p_q_const__IplImage__p__IplImage swig_types[126] +#define SWIGTYPE_p_f_p_q_const__char_int__p_CvMat swig_types[127] +#define SWIGTYPE_p_f_p_q_const__char_int__p__IplImage swig_types[128] +#define SWIGTYPE_p_f_p_q_const__char_p_q_const__void__void swig_types[129] +#define SWIGTYPE_p_f_p_q_const__char_p_q_const__void_p_q_const__int__int swig_types[130] +#define SWIGTYPE_p_f_p_q_const__float_p_q_const__float_p_void__float swig_types[131] +#define SWIGTYPE_p_f_p_q_const__void__int swig_types[132] +#define SWIGTYPE_p_f_p_q_const__void__p_void swig_types[133] +#define SWIGTYPE_p_f_p_q_const__void_p_q_const__void_p_void__int swig_types[134] +#define SWIGTYPE_p_f_p_void_p_void__int swig_types[135] +#define SWIGTYPE_p_f_size_t_p_void__p_void swig_types[136] +#define SWIGTYPE_p_float swig_types[137] +#define SWIGTYPE_p_int swig_types[138] +#define SWIGTYPE_p_int64_t swig_types[139] +#define SWIGTYPE_p_p_CvConDensation swig_types[140] +#define SWIGTYPE_p_p_CvFileStorage swig_types[141] +#define SWIGTYPE_p_p_CvGraphEdge swig_types[142] +#define SWIGTYPE_p_p_CvGraphScanner swig_types[143] +#define SWIGTYPE_p_p_CvGraphVtx swig_types[144] +#define SWIGTYPE_p_p_CvHaarClassifierCascade swig_types[145] +#define SWIGTYPE_p_p_CvHistogram swig_types[146] +#define SWIGTYPE_p_p_CvKalman swig_types[147] +#define SWIGTYPE_p_p_CvLSH swig_types[148] +#define SWIGTYPE_p_p_CvMat swig_types[149] +#define SWIGTYPE_p_p_CvMatND swig_types[150] +#define SWIGTYPE_p_p_CvMemStorage swig_types[151] +#define SWIGTYPE_p_p_CvPOSITObject swig_types[152] +#define SWIGTYPE_p_p_CvPoint swig_types[153] +#define SWIGTYPE_p_p_CvSeq swig_types[154] +#define SWIGTYPE_p_p_CvSeqBlock swig_types[155] +#define SWIGTYPE_p_p_CvSetElem swig_types[156] +#define SWIGTYPE_p_p_CvSparseMat swig_types[157] +#define SWIGTYPE_p_p_CvStereoBMState swig_types[158] +#define SWIGTYPE_p_p_CvStereoGCState swig_types[159] +#define SWIGTYPE_p_p_CvSubdiv2DPoint swig_types[160] +#define SWIGTYPE_p_p_CvTypedSeqT_CvConnectedComp_t swig_types[161] +#define SWIGTYPE_p_p_CvTypedSeqT_CvPoint2D32f_t swig_types[162] +#define SWIGTYPE_p_p_CvTypedSeqT_CvPoint_t swig_types[163] +#define SWIGTYPE_p_p_CvTypedSeqT_CvQuadEdge2D_t swig_types[164] +#define SWIGTYPE_p_p_CvTypedSeqT_CvRect_t swig_types[165] +#define SWIGTYPE_p_p_CvTypedSeqT_CvSeq_p_t swig_types[166] +#define SWIGTYPE_p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t swig_types[167] +#define SWIGTYPE_p_p_CvTypedSeqT_CvTupleT_float_2_t_t swig_types[168] +#define SWIGTYPE_p_p_CvTypedSeqT_CvTupleT_float_3_t_t swig_types[169] +#define SWIGTYPE_p_p__CvContourScanner swig_types[170] +#define SWIGTYPE_p_p__IplConvKernel swig_types[171] +#define SWIGTYPE_p_p__IplImage swig_types[172] +#define SWIGTYPE_p_p_char swig_types[173] +#define SWIGTYPE_p_p_float swig_types[174] +#define SWIGTYPE_p_p_p_CvMat swig_types[175] +#define SWIGTYPE_p_p_unsigned_char swig_types[176] +#define SWIGTYPE_p_p_void swig_types[177] +#define SWIGTYPE_p_short swig_types[178] +#define SWIGTYPE_p_signed_char swig_types[179] +#define SWIGTYPE_p_size_t swig_types[180] +#define SWIGTYPE_p_size_type swig_types[181] +#define SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t swig_types[182] +#define SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type swig_types[183] +#define SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type swig_types[184] +#define SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t swig_types[185] +#define SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type swig_types[186] +#define SWIGTYPE_p_swig__OctSwigIterator swig_types[187] +#define SWIGTYPE_p_uint64_t swig_types[188] +#define SWIGTYPE_p_unsigned_char swig_types[189] +#define SWIGTYPE_p_unsigned_int swig_types[190] +#define SWIGTYPE_p_unsigned_short swig_types[191] +#define SWIGTYPE_p_value_type swig_types[192] +#define SWIGTYPE_p_void swig_types[193] +static swig_type_info *swig_types[195]; +static swig_module_info swig_module = {swig_types, 194, 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 + + +#include "octhelpers.h" +#include "octcvseq.hpp" +#include "octerror.h" + + + + + 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; irows!=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; irows*mat->cols); \ + if( mat->rows != len ){ \ + error("OctObject_As*Array: CvArr rows or cols must equal length" ); \ + return -1; \ + } \ + for(int i=0; ival[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 1 ){ + // double check size + assert((OctTuple_Check(rowobj) || OctList_Check(rowobj)) && + OctSequence_Size(rowobj) == dims[1]); + + for(int j=0; j 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; +} + + +#include "cvshadow.h" + + +#include + + +#if defined(__GNUC__) +# if __GNUC__ == 2 && __GNUC_MINOR <= 96 +# define SWIG_STD_NOMODERN_STL +# endif +#endif + + +#include +#include + + +#include + + +#include + + +namespace swig { + struct stop_iteration { + }; + + struct OctSwigIterator { + private: + octave_value _seq; + + protected: + OctSwigIterator(octave_value seq) : _seq(seq) + { + } + + public: + virtual ~OctSwigIterator() {} + + virtual octave_value value() const = 0; + + virtual OctSwigIterator *incr(size_t n = 1) = 0; + + virtual OctSwigIterator *decr(size_t n = 1) + { + throw stop_iteration(); + } + + virtual ptrdiff_t distance(const OctSwigIterator &x) const + { + throw std::invalid_argument("operation not supported"); + } + + virtual bool equal (const OctSwigIterator &x) const + { + throw std::invalid_argument("operation not supported"); + } + + virtual OctSwigIterator *copy() const = 0; + + octave_value next() + { + octave_value obj = value(); + incr(); + return obj; + } + + octave_value previous() + { + decr(); + return value(); + } + + OctSwigIterator *advance(ptrdiff_t n) + { + return (n > 0) ? incr(n) : decr(-n); + } + + bool operator == (const OctSwigIterator& x) const + { + return equal(x); + } + + bool operator != (const OctSwigIterator& x) const + { + return ! operator==(x); + } + + OctSwigIterator* operator ++ () { + incr(); + return this; + } + + OctSwigIterator* operator -- () { + decr(); + return this; + } + + OctSwigIterator* operator + (ptrdiff_t n) const + { + return copy()->advance(n); + } + + OctSwigIterator* operator - (ptrdiff_t n) const + { + return copy()->advance(-n); + } + + ptrdiff_t operator - (const OctSwigIterator& x) const + { + return x.distance(*this); + } + + static swig_type_info* descriptor() { + static int init = 0; + static swig_type_info* desc = 0; + if (!init) { + desc = SWIG_TypeQuery("swig::OctSwigIterator *"); + init = 1; + } + return desc; + } + }; +} + + + SWIGINTERNINLINE octave_value SWIG_From_long (long value) + { + return octave_value(value); + } + + +SWIGINTERNINLINE octave_value +SWIG_From_ptrdiff_t (ptrdiff_t value) +{ + return SWIG_From_long ((long)(value)); +} + + + 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; + } + + +SWIGINTERNINLINE int +SWIG_AsVal_ptrdiff_t (octave_value obj, ptrdiff_t *val) +{ + long v; + int res = SWIG_AsVal_long (obj, val ? &v : 0); + if (SWIG_IsOK(res) && val) *val = (ptrdiff_t)(v); + return res; +} + + +#include + + +#include + + +#include + + +#include + + +#include +#include +#include + + +namespace swig { + template + struct noconst_traits { + typedef Type noconst_type; + }; + + template + struct noconst_traits { + typedef Type noconst_type; + }; + + /* + type categories + */ + struct pointer_category { }; + struct value_category { }; + + /* + General traits that provides type_name and type_info + */ + template struct traits { }; + + template + inline const char* type_name() { + return traits::noconst_type >::type_name(); + } + + template + struct traits_info { + static swig_type_info *type_query(std::string name) { + name += " *"; + return SWIG_TypeQuery(name.c_str()); + } + static swig_type_info *type_info() { + static swig_type_info *info = type_query(type_name()); + return info; + } + }; + + template + inline swig_type_info *type_info() { + return traits_info::type_info(); + } + + /* + Partial specialization for pointers + */ + template struct traits { + typedef pointer_category category; + static std::string make_ptr_name(const char* name) { + std::string ptrname = name; + ptrname += " *"; + return ptrname; + } + static const char* type_name() { + static std::string name = make_ptr_name(swig::type_name()); + return name.c_str(); + } + }; + + template + struct traits_as { }; + + template + struct traits_check { }; + +} + + +namespace swig { +// Traits that provides the from method + template struct traits_from_ptr { + static octave_value from(Type *val, int owner = 0) { + return SWIG_NewPointerObj(val, type_info(), owner); + } + }; + + template struct traits_from { + static octave_value from(const Type& val) { + return traits_from_ptr::from(new Type(val), 1); + } + }; + + template struct traits_from { + static octave_value from(Type* val) { + return traits_from_ptr::from(val, 0); + } + }; + + template struct traits_from { + static octave_value from(const Type* val) { + return traits_from_ptr::from(const_cast(val), 0); + } + }; + + + template + inline octave_value from(const Type& val) { + return traits_from::from(val); + } + + template + inline octave_value from_ptr(Type* val, int owner) { + return traits_from_ptr::from(val, owner); + } + + // Traits that provides the asval/as/check method + template + struct traits_asptr { + static int asptr(const octave_value& obj, Type **val) { + Type *p; + int res = SWIG_ConvertPtr(obj, (void**)&p, type_info(), 0); + if (SWIG_IsOK(res)) { + if (val) *val = p; + } + return res; + } + }; + + template + inline int asptr(const octave_value& obj, Type **vptr) { + return traits_asptr::asptr(obj, vptr); + } + + template + struct traits_asval { + static int asval(const octave_value& obj, Type *val) { + if (val) { + Type *p = 0; + int res = traits_asptr::asptr(obj, &p); + if (!SWIG_IsOK(res)) return res; + if (p) { + typedef typename noconst_traits::noconst_type noconst_type; + *(const_cast(val)) = *p; + if (SWIG_IsNewObj(res)){ + delete p; + res = SWIG_DelNewMask(res); + } + return res; + } else { + return SWIG_ERROR; + } + } else { + return traits_asptr::asptr(obj, (Type **)(0)); + } + } + }; + + template struct traits_asval { + static int asval(const octave_value& obj, Type **val) { + if (val) { + typedef typename noconst_traits::noconst_type noconst_type; + noconst_type *p = 0; + int res = traits_asptr::asptr(obj, &p); + if (SWIG_IsOK(res)) { + *(const_cast(val)) = p; + } + return res; + } else { + return traits_asptr::asptr(obj, (Type **)(0)); + } + } + }; + + template + inline int asval(const octave_value& obj, Type *val) { + return traits_asval::asval(obj, val); + } + + template + struct traits_as { + static Type as(const octave_value& obj, bool throw_error) { + Type v; + int res = asval(obj, &v); + if (!obj.is_defined() || !SWIG_IsOK(res)) { + if (!Octave_Error_Occurred()) { + SWIG_Error(SWIG_TypeError, swig::type_name()); + } + if (throw_error) throw std::invalid_argument("bad type"); + } + return v; + } + }; + + template + struct traits_as { + static Type as(const octave_value& obj, bool throw_error) { + Type *v = 0; + int res = traits_asptr::asptr(obj, &v); + if (SWIG_IsOK(res) && v) { + if (SWIG_IsNewObj(res)) { + Type r(*v); + delete v; + return r; + } else { + return *v; + } + } else { + // Uninitialized return value, no Type() constructor required. + static Type *v_def = (Type*) malloc(sizeof(Type)); + if (!Octave_Error_Occurred()) { + SWIG_Error(SWIG_TypeError, swig::type_name()); + } + if (throw_error) throw std::invalid_argument("bad type"); + memset(v_def,0,sizeof(Type)); + return *v_def; + } + } + }; + + template + struct traits_as { + static Type* as(const octave_value& obj, bool throw_error) { + Type *v = 0; + int res = traits_asptr::asptr(obj, &v); + if (SWIG_IsOK(res)) { + return v; + } else { + if (!Octave_Error_Occurred()) { + SWIG_Error(SWIG_TypeError, swig::type_name()); + } + if (throw_error) throw std::invalid_argument("bad type"); + return 0; + } + } + }; + + template + inline Type as(const octave_value& obj, bool te = false) { + return traits_as::category>::as(obj, te); + } + + template + struct traits_check { + static bool check(const octave_value& obj) { + int res = asval(obj, (Type *)(0)); + return SWIG_IsOK(res) ? true : false; + } + }; + + template + struct traits_check { + static bool check(const octave_value& obj) { + int res = asptr(obj, (Type **)(0)); + return SWIG_IsOK(res) ? true : false; + } + }; + + template + inline bool check(const octave_value& obj) { + return traits_check::category>::check(obj); + } +} + + +#include + +namespace std { + template <> + struct less : public binary_function + { + bool + operator()(const octave_value& v, const octave_value& w) const + { + octave_value res = do_binary_op(octave_value::op_le,v,w); + return res.is_true(); + } + }; +} + +namespace swig { + inline size_t + check_index(ptrdiff_t i, size_t size, bool insert = false) { + if ( i < 0 ) { + if ((size_t) (-i) <= size) + return (size_t) (i + size); + } else if ( (size_t) i < size ) { + return (size_t) i; + } else if (insert && ((size_t) i == size)) { + return size; + } + + throw std::out_of_range("index out of range"); + } + + inline size_t + slice_index(ptrdiff_t i, size_t size) { + if ( i < 0 ) { + if ((size_t) (-i) <= size) { + return (size_t) (i + size); + } else { + throw std::out_of_range("index out of range"); + } + } else { + return ( (size_t) i < size ) ? ((size_t) i) : size; + } + } + + template + inline typename Sequence::iterator + getpos(Sequence* self, Difference i) { + typename Sequence::iterator pos = self->begin(); + std::advance(pos, check_index(i,self->size())); + return pos; + } + + template + inline typename Sequence::const_iterator + cgetpos(const Sequence* self, Difference i) { + typename Sequence::const_iterator pos = self->begin(); + std::advance(pos, check_index(i,self->size())); + return pos; + } + + template + inline Sequence* + getslice(const Sequence* self, Difference i, Difference j) { + typename Sequence::size_type size = self->size(); + typename Sequence::size_type ii = swig::check_index(i, size); + typename Sequence::size_type jj = swig::slice_index(j, size); + + if (jj > ii) { + typename Sequence::const_iterator vb = self->begin(); + typename Sequence::const_iterator ve = self->begin(); + std::advance(vb,ii); + std::advance(ve,jj); + return new Sequence(vb, ve); + } else { + return new Sequence(); + } + } + + template + inline void + setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) { + typename Sequence::size_type size = self->size(); + typename Sequence::size_type ii = swig::check_index(i, size, true); + typename Sequence::size_type jj = swig::slice_index(j, size); + if (jj < ii) jj = ii; + size_t ssize = jj - ii; + if (ssize <= v.size()) { + typename Sequence::iterator sb = self->begin(); + typename InputSeq::const_iterator vmid = v.begin(); + std::advance(sb,ii); + std::advance(vmid, jj - ii); + self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end()); + } else { + typename Sequence::iterator sb = self->begin(); + typename Sequence::iterator se = self->begin(); + std::advance(sb,ii); + std::advance(se,jj); + self->erase(sb,se); + self->insert(sb, v.begin(), v.end()); + } + } + + template + inline void + delslice(Sequence* self, Difference i, Difference j) { + typename Sequence::size_type size = self->size(); + typename Sequence::size_type ii = swig::check_index(i, size, true); + typename Sequence::size_type jj = swig::slice_index(j, size); + if (jj > ii) { + typename Sequence::iterator sb = self->begin(); + typename Sequence::iterator se = self->begin(); + std::advance(sb,ii); + std::advance(se,jj); + self->erase(sb,se); + } + } +} + + +#if defined(__SUNPRO_CC) && defined(_RWSTD_VER) +# if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL) +# define SWIG_STD_NOITERATOR_TRAITS_STL +# endif +#endif + +#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL) +#include +#else +namespace std { + template + struct iterator_traits { + typedef ptrdiff_t difference_type; + typedef typename Iterator::value_type value_type; + }; + + template + struct iterator_traits<__reverse_bi_iterator > { + typedef Distance difference_type; + typedef T value_type; + }; + + template + struct iterator_traits { + typedef T value_type; + typedef ptrdiff_t difference_type; + }; + + template + inline typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) { + ++__first; ++__n; + } + return __n; + } +} +#endif + + +namespace swig { + template + class OctSwigIterator_T : public OctSwigIterator + { + public: + typedef OutIterator out_iterator; + typedef typename std::iterator_traits::value_type value_type; + typedef OctSwigIterator_T self_type; + + OctSwigIterator_T(out_iterator curr, octave_value seq) + : OctSwigIterator(seq), current(curr) + { + } + + const out_iterator& get_current() const + { + return current; + } + + + bool equal (const OctSwigIterator &iter) const + { + const self_type *iters = dynamic_cast(&iter); + if (iters) { + return (current == iters->get_current()); + } else { + throw std::invalid_argument("bad iterator type"); + } + } + + ptrdiff_t distance(const OctSwigIterator &iter) const + { + const self_type *iters = dynamic_cast(&iter); + if (iters) { + return std::distance(current, iters->get_current()); + } else { + throw std::invalid_argument("bad iterator type"); + } + } + + protected: + out_iterator current; + }; + + template + struct from_oper + { + typedef const ValueType& argument_type; + typedef octave_value result_type; + result_type operator()(argument_type v) const + { + return swig::from(v); + } + }; + + template::value_type, + typename FromOper = from_oper > + class OctSwigIteratorOpen_T : public OctSwigIterator_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef OctSwigIterator_T base; + typedef OctSwigIteratorOpen_T self_type; + + OctSwigIteratorOpen_T(out_iterator curr, octave_value seq) + : OctSwigIterator_T(curr, seq) + { + } + + octave_value value() const { + return from(static_cast(*(base::current))); + } + + OctSwigIterator *copy() const + { + return new self_type(*this); + } + + OctSwigIterator *incr(size_t n = 1) + { + while (n--) { + ++base::current; + } + return this; + } + + OctSwigIterator *decr(size_t n = 1) + { + while (n--) { + --base::current; + } + return this; + } + }; + + template::value_type, + typename FromOper = from_oper > + class OctSwigIteratorClosed_T : public OctSwigIterator_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef OctSwigIterator_T base; + typedef OctSwigIteratorClosed_T self_type; + + OctSwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, octave_value seq) + : OctSwigIterator_T(curr, seq), begin(first), end(last) + { + } + + octave_value value() const { + if (base::current == end) { + throw stop_iteration(); + } else { + return from(static_cast(*(base::current))); + } + } + + OctSwigIterator *copy() const + { + return new self_type(*this); + } + + OctSwigIterator *incr(size_t n = 1) + { + while (n--) { + if (base::current == end) { + throw stop_iteration(); + } else { + ++base::current; + } + } + return this; + } + + OctSwigIterator *decr(size_t n = 1) + { + while (n--) { + if (base::current == begin) { + throw stop_iteration(); + } else { + --base::current; + } + } + return this; + } + + private: + out_iterator begin; + out_iterator end; + }; + + template + inline OctSwigIterator* + make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, octave_value seq = octave_value()) + { + return new OctSwigIteratorClosed_T(current, begin, end, seq); + } + + template + inline OctSwigIterator* + make_output_iterator(const OutIter& current, octave_value seq = octave_value()) + { + return new OctSwigIteratorOpen_T(current, seq); + } +} + + +namespace swig +{ + template + struct OctSequence_Ref // * octave can't support these, because of how assignment works + { + OctSequence_Ref(const octave_value& seq, int index) + : _seq(seq), _index(index) + { + } + + operator T () const + { + // swig::SwigVar_PyObject item = OctSequence_GetItem(_seq, _index); + octave_value item; // * todo + try { + return swig::as(item, true); + } catch (std::exception& e) { + char msg[1024]; + sprintf(msg, "in sequence element %d ", _index); + if (!Octave_Error_Occurred()) { + SWIG_Error(SWIG_TypeError, swig::type_name()); + } + SWIG_Octave_AddErrorMsg(msg); + SWIG_Octave_AddErrorMsg(e.what()); + throw; + } + } + + OctSequence_Ref& operator=(const T& v) + { + // OctSequence_SetItem(_seq, _index, swig::from(v)); + // * todo + return *this; + } + + private: + octave_value _seq; + int _index; + }; + + template + struct OctSequence_ArrowProxy + { + OctSequence_ArrowProxy(const T& x): m_value(x) {} + const T* operator->() const { return &m_value; } + operator const T*() const { return &m_value; } + T m_value; + }; + + template + struct OctSequence_InputIterator + { + typedef OctSequence_InputIterator self; + + typedef std::random_access_iterator_tag iterator_category; + typedef Reference reference; + typedef T value_type; + typedef T* pointer; + typedef int difference_type; + + OctSequence_InputIterator() + { + } + + OctSequence_InputIterator(const octave_value& seq, int index) + : _seq(seq), _index(index) + { + } + + reference operator*() const + { + return reference(_seq, _index); + } + + OctSequence_ArrowProxy + operator->() const { + return OctSequence_ArrowProxy(operator*()); + } + + bool operator==(const self& ri) const + { + return (_index == ri._index); + } + + bool operator!=(const self& ri) const + { + return !(operator==(ri)); + } + + self& operator ++ () + { + ++_index; + return *this; + } + + self& operator -- () + { + --_index; + return *this; + } + + self& operator += (difference_type n) + { + _index += n; + return *this; + } + + self operator +(difference_type n) const + { + return self(_seq, _index + n); + } + + self& operator -= (difference_type n) + { + _index -= n; + return *this; + } + + self operator -(difference_type n) const + { + return self(_seq, _index - n); + } + + difference_type operator - (const self& ri) const + { + return _index - ri._index; + } + + bool operator < (const self& ri) const + { + return _index < ri._index; + } + + reference + operator[](difference_type n) const + { + return reference(_seq, _index + n); + } + + private: + octave_value _seq; + difference_type _index; + }; + + template + struct OctSequence_Cont + { + typedef OctSequence_Ref reference; + typedef const OctSequence_Ref const_reference; + typedef T value_type; + typedef T* pointer; + typedef int difference_type; + typedef int size_type; + typedef const pointer const_pointer; + typedef OctSequence_InputIterator iterator; + typedef OctSequence_InputIterator const_iterator; + + OctSequence_Cont(const octave_value& seq) : _seq(seq) + { + // * assert that we have map type etc. + /* + if (!OctSequence_Check(seq)) { + throw std::invalid_argument("a sequence is expected"); + } + _seq = seq; + Py_INCREF(_seq); + */ + } + + ~OctSequence_Cont() + { + } + + size_type size() const + { + // return static_cast(OctSequence_Size(_seq)); + return 0; // * todo + } + + bool empty() const + { + return size() == 0; + } + + iterator begin() + { + return iterator(_seq, 0); + } + + const_iterator begin() const + { + return const_iterator(_seq, 0); + } + + iterator end() + { + return iterator(_seq, size()); + } + + const_iterator end() const + { + return const_iterator(_seq, size()); + } + + reference operator[](difference_type n) + { + return reference(_seq, n); + } + + const_reference operator[](difference_type n) const + { + return const_reference(_seq, n); + } + + bool check(bool set_err = true) const + { + int s = size(); + for (int i = 0; i < s; ++i) { + // swig::SwigVar_PyObject item = OctSequence_GetItem(_seq, i); + octave_value item; // * todo + if (!swig::check(item)) { + if (set_err) { + char msg[1024]; + sprintf(msg, "in sequence element %d", i); + SWIG_Error(SWIG_RuntimeError, msg); + } + return false; + } + } + return true; + } + + private: + octave_value _seq; + }; + +} + + +#include + + + 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; + } + + +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; +} + + + SWIGINTERNINLINE octave_value SWIG_From_double (double value) + { + return octave_value(value); + } + + +SWIGINTERNINLINE octave_value +SWIG_From_float (float value) +{ + return SWIG_From_double (value); +} + + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return"float"; } + }; + template <> struct traits_asval { + typedef float value_type; + static int asval(octave_value obj, value_type *val) { + return SWIG_AsVal_float (obj, val); + } + }; + template <> struct traits_from { + typedef float value_type; + static octave_value from(const value_type& val) { + return SWIG_From_float (val); + } + }; +} + + +namespace swig { + template + inline void + assign(const OctSeq& octseq, Seq* seq) { +#ifdef SWIG_STD_NOASSIGN_STL + typedef typename OctSeq::value_type value_type; + typename OctSeq::const_iterator it = octseq.begin(); + for (;it != octseq.end(); ++it) { + seq->insert(seq->end(),(value_type)(*it)); + } +#else + seq->assign(octseq.begin(), octseq.end()); +#endif + } + + template + struct traits_asptr_stdseq { + typedef Seq sequence; + typedef T value_type; + + static int asptr(const octave_value& obj, sequence **seq) { + if (!obj.is_defined() || Swig::swig_value_deref(obj)) { + sequence *p; + if (SWIG_ConvertPtr(obj,(void**)&p, + swig::type_info(),0) == SWIG_OK) { + if (seq) *seq = p; + return SWIG_OLDOBJ; + } + } else if (obj.is_cell()) { + try { + OctSequence_Cont octseq(obj); + if (seq) { + sequence *pseq = new sequence(); + assign(octseq, pseq); + *seq = pseq; + return SWIG_NEWOBJ; + } else { + return octseq.check() ? SWIG_OK : SWIG_ERROR; + } + } catch (std::exception& e) { + if (seq&&!error_state) + error("swig type error: %s",e.what()); + return SWIG_ERROR; + } + } + return SWIG_ERROR; + } + }; + + template + struct traits_from_stdseq { + typedef Seq sequence; + typedef T value_type; + typedef typename Seq::size_type size_type; + typedef typename sequence::const_iterator const_iterator; + + static octave_value from(const sequence& seq) { + + + + + + + size_type size = seq.size(); + if (size <= (size_type)INT_MAX) { + Cell c(size,1); + int i = 0; + for (const_iterator it = seq.begin(); + it != seq.end(); ++it, ++i) { + c(i) = swig::from(*it); + } + return c; + } else { + error("swig overflow error: sequence size not valid in octave"); + return octave_value(); + } + return octave_value(); + } + }; +} + + + namespace swig { + template + struct traits_asptr > { + static int asptr(const octave_value& obj, std::vector **vec) { + return traits_asptr_stdseq >::asptr(obj, vec); + } + }; + + template + struct traits_from > { + static octave_value from(const std::vector& vec) { + return traits_from_stdseq >::from(vec); + } + }; + } + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "float" "," "std::allocator< float >" " >"; + } + }; + } + +SWIGINTERN std::vector< float >::value_type std_vector_Sl_float_Sg__pop(std::vector< float > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN std::vector< float >::value_type std_vector_Sl_float_Sg____paren__(std::vector< float > *self,std::vector< float >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_float_Sg____paren_asgn__(std::vector< float > *self,std::vector< float >::difference_type i,std::vector< float >::value_type x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN void std_vector_Sl_float_Sg__append(std::vector< float > *self,std::vector< float >::value_type x){ + self->push_back(x); + } + + SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long (unsigned long value) + { + return octave_value(value); + } + + +SWIGINTERNINLINE octave_value +SWIG_From_size_t (size_t value) +{ + return SWIG_From_unsigned_SS_long ((unsigned long)(value)); +} + + + namespace swig { + template <> struct traits { + typedef pointer_category category; + static const char* type_name() { return"CvPoint"; } + }; + } + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "CvPoint" "," "std::allocator< CvPoint >" " >"; + } + }; + } + +SWIGINTERN std::vector< CvPoint >::value_type std_vector_Sl_CvPoint_Sg__pop(std::vector< CvPoint > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN std::vector< CvPoint >::value_type std_vector_Sl_CvPoint_Sg____paren__(std::vector< CvPoint > *self,std::vector< CvPoint >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_CvPoint_Sg____paren_asgn__(std::vector< CvPoint > *self,std::vector< CvPoint >::difference_type i,std::vector< CvPoint >::value_type x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN void std_vector_Sl_CvPoint_Sg__append(std::vector< CvPoint > *self,std::vector< CvPoint >::value_type x){ + self->push_back(x); + } + +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +SWIGINTERN int +SWIG_AsVal_int (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; +} + + +#include "cxtypes.h" +#include "cxcore.h" +#include "cvtypes.h" +#include "cv.h" + + +SWIGINTERNINLINE octave_value +SWIG_From_int (int value) +{ + return SWIG_From_long (value); +} + + +#include + + +CvMat * cvCreateImageMat( CvSize size, int depth, int channels ){ + static const signed char icvDepthToType[]= + { + -1, -1, CV_8U, CV_8S, CV_16U, CV_16S, -1, -1, + CV_32F, CV_32S, -1, -1, -1, -1, -1, -1, CV_64F, -1 + }; + + depth = icvDepthToType[((depth & 255) >> 2) + (depth < 0)]; + return cvCreateMat( size.height, size.width, CV_MAKE_TYPE(depth, channels)); +} +#define cvCloneImageMat( mat ) cvCloneMat( mat ) + +#ifdef WIN32 + +CvModuleInfo *CvModule::first=0; +CvModuleInfo *CvModule::last=0; +CvTypeInfo *CvType::first=0; +CvTypeInfo *CvType::last=0; + +#endif + + + +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_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val) +{ + unsigned long v; + int res = SWIG_AsVal_unsigned_SS_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v > UINT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = (unsigned int)(v); + } + } + return res; +} + + +SWIGINTERNINLINE octave_value +SWIG_From_unsigned_SS_int (unsigned int value) +{ + return SWIG_From_unsigned_SS_long (value); +} + +SWIGINTERN void delete_IplImage(IplImage *self){ IplImage * dummy = self; cvReleaseImage (& dummy); } +SWIGINTERN IplImage *IplImage_operator_Sa___SWIG_0(IplImage *self,CvArr *src){ + IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvAdd(self, src, res); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sm___SWIG_0(IplImage *self,CvArr *src){ + IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvMul(self, src, res); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Ss___SWIG_0(IplImage *self,CvArr *src){ + IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvSub(self, src, res); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sd___SWIG_0(IplImage *self,CvArr *src){ + IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvDiv(self, src, res); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sx___SWIG_0(IplImage *self,CvArr *src){ + IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvXor(self, src, res); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sa___SWIG_1(IplImage *self,CvScalar val){ + IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvAddS(self, val, res); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sx___SWIG_1(IplImage *self,CvScalar val){ + IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvXorS(self, val, res); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Ss___SWIG_1(IplImage *self,CvScalar val){ + IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvSubS(self, val, res); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sg__Se___SWIG_0(IplImage *self,CvArr *src){ + IplImage * res = cvCreateImage(cvGetSize(self), 8, 1); + cvCmp(self, src, res, 2); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sg__Se___SWIG_1(IplImage *self,double val){ + IplImage * res = cvCreateImage(cvGetSize(self), 8, 1); + cvCmpS(self, val, res, 2); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Se__Se___SWIG_0(IplImage *self,CvArr *src){ + IplImage * res = cvCreateImage(cvGetSize(self), 8, 1); + cvCmp(self, src, res, 0); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Se__Se___SWIG_1(IplImage *self,double val){ + IplImage * res = cvCreateImage(cvGetSize(self), 8, 1); + cvCmpS(self, val, res, 0); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sl__Se___SWIG_0(IplImage *self,CvArr *src){ + IplImage * res = cvCreateImage(cvGetSize(self), 8, 1); + cvCmp(self, src, res, 4); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sl__Se___SWIG_1(IplImage *self,double val){ + IplImage * res = cvCreateImage(cvGetSize(self), 8, 1); + cvCmpS(self, val, res, 4); + return res; + } +SWIGINTERN IplImage *IplImage_operator_SN__Se___SWIG_0(IplImage *self,CvArr *src){ + IplImage * res = cvCreateImage(cvGetSize(self), 8, 1); + cvCmp(self, src, res, 5); + return res; + } +SWIGINTERN IplImage *IplImage_operator_SN__Se___SWIG_1(IplImage *self,double val){ + IplImage * res = cvCreateImage(cvGetSize(self), 8, 1); + cvCmpS(self, val, res, 5); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sl___SWIG_0(IplImage *self,CvArr *src){ + IplImage * res = cvCreateImage(cvGetSize(self), 8, 1); + cvCmp(self, src, res, 3); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sl___SWIG_1(IplImage *self,double val){ + IplImage * res = cvCreateImage(cvGetSize(self), 8, 1); + cvCmpS(self, val, res, 3); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sg___SWIG_0(IplImage *self,CvArr *src){ + IplImage * res = cvCreateImage(cvGetSize(self), 8, 1); + cvCmp(self, src, res, 1); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sg___SWIG_1(IplImage *self,double val){ + IplImage * res = cvCreateImage(cvGetSize(self), 8, 1); + cvCmpS(self, val, res, 1); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sm___SWIG_1(IplImage *self,double val){ + IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvConvertScale(self, res, val); + return res; + } +SWIGINTERN IplImage *IplImage_operator_Sd___SWIG_1(IplImage *self,double val){ + IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvConvertScale(self, res, 1.0/val); + return res; + } +SWIGINTERN IplImage *IplImage___radd____SWIG_0(IplImage *self,CvArr *arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvAdd(self, arg, retarg); + return retarg; + } +SWIGINTERN IplImage *IplImage___rsub____SWIG_0(IplImage *self,CvArr *arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvSub(arg, self, retarg); + return retarg; + } +SWIGINTERN IplImage *IplImage___rdiv____SWIG_0(IplImage *self,CvArr *arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvDiv(arg, self, retarg); + return retarg; + } +SWIGINTERN IplImage *IplImage___rmul____SWIG_0(IplImage *self,CvArr *arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvMatMul(arg, self, retarg); + return retarg; + } +SWIGINTERN IplImage *IplImage___radd____SWIG_1(IplImage *self,CvScalar arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvAddS(self, arg, retarg); + return retarg; + } +SWIGINTERN IplImage *IplImage___radd____SWIG_2(IplImage *self,double arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvAddS(self, cvScalar(arg), retarg); + return retarg; + } +SWIGINTERN IplImage *IplImage___rsub____SWIG_1(IplImage *self,CvScalar arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvSubRS(self, arg, retarg); + return retarg; + } +SWIGINTERN IplImage *IplImage___rsub____SWIG_2(IplImage *self,double arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvSubRS(self, cvScalar(arg), retarg); + return retarg; + } +SWIGINTERN CvArr *IplImage___rmul____SWIG_1(IplImage *self,double arg){ + CvArr * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvConvertScale(self, retarg, arg); + return retarg; + } +SWIGINTERN CvArr *IplImage___rdiv____SWIG_1(IplImage *self,double arg){ + CvArr * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvConvertScale(self, retarg, 1.0/arg); + return retarg; + } +SWIGINTERN IplImage *IplImage___ror____SWIG_0(IplImage *self,CvScalar arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvOrS(self, arg, retarg); + return retarg; + } +SWIGINTERN IplImage *IplImage___ror____SWIG_1(IplImage *self,double arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvOrS(self, cvScalar(arg), retarg); + return retarg; + } +SWIGINTERN IplImage *IplImage___rand____SWIG_0(IplImage *self,CvScalar arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvAndS(self, arg, retarg); + return retarg; + } +SWIGINTERN IplImage *IplImage___rand____SWIG_1(IplImage *self,double arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvAndS(self, cvScalar(arg), retarg); + return retarg; + } +SWIGINTERN IplImage *IplImage___rxor____SWIG_0(IplImage *self,CvScalar arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvXorS(self, arg, retarg); + return retarg; + } +SWIGINTERN IplImage *IplImage___rxor____SWIG_1(IplImage *self,double arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvXorS(self, cvScalar(arg), retarg); + return retarg; + } +SWIGINTERN CvArr *IplImage___req__(IplImage *self,double arg){ + CvArr * retarg = cvCreateImage(cvGetSize(self), 8, 1); + cvCmpS(self, arg, retarg, 0); + return retarg; + } +SWIGINTERN CvArr *IplImage___rgt__(IplImage *self,double arg){ + CvArr * retarg = cvCreateImage(cvGetSize(self), 8, 1); + cvCmpS(self, arg, retarg, 1); + return retarg; + } +SWIGINTERN CvArr *IplImage___rge__(IplImage *self,double arg){ + CvArr * retarg = cvCreateImage(cvGetSize(self), 8, 1); + cvCmpS(self, arg, retarg, 2); + return retarg; + } +SWIGINTERN CvArr *IplImage___rlt__(IplImage *self,double arg){ + CvArr * retarg = cvCreateImage(cvGetSize(self), 8, 1); + cvCmpS(self, arg, retarg, 3); + return retarg; + } +SWIGINTERN CvArr *IplImage___rle__(IplImage *self,double arg){ + CvArr * retarg = cvCreateImage(cvGetSize(self), 8, 1); + cvCmpS(self, arg, retarg, 4); + return retarg; + } +SWIGINTERN CvArr *IplImage___rne__(IplImage *self,double arg){ + CvArr * retarg = cvCreateImage(cvGetSize(self), 8, 1); + cvCmpS(self, arg, retarg, 5); + return retarg; + } +SWIGINTERN IplImage *IplImage___pow__(IplImage *self,double arg){ + IplImage * retarg = cvCreateImage(cvGetSize(self), self->depth, self->nChannels); + cvPow(self, retarg, arg); + return retarg; + } +SWIGINTERN char *IplImage___str(IplImage *self){ + static char str[8]; + cvArrPrint( self ); + str[0]=0; + return str; + return ""; + } +SWIGINTERN void IplImage___paren_asgn__SWIG_0(IplImage *self,octave_value object,double val){ + CvMat tmp; + CvRect subrect = OctSlice_to_CvRect( self, object ); + cvGetSubRect(self, &tmp, subrect); + cvSet(&tmp, cvScalarAll(val)); + } +SWIGINTERN void IplImage___paren_asgn__SWIG_1(IplImage *self,octave_value object,CvPoint val){ + CvMat tmp; + CvRect subrect = OctSlice_to_CvRect( self, object ); + cvGetSubRect(self, &tmp, subrect); + cvSet(&tmp, cvScalar(val.x, val.y)); + } +SWIGINTERN void IplImage___paren_asgn__SWIG_2(IplImage *self,octave_value object,CvPoint2D32f val){ + CvMat tmp; + CvRect subrect = OctSlice_to_CvRect( self, object ); + cvGetSubRect(self, &tmp, subrect); + cvSet(&tmp, cvScalar(val.x, val.y)); + } +SWIGINTERN void IplImage___paren_asgn__SWIG_3(IplImage *self,octave_value object,CvScalar val){ + CvMat tmp; + CvRect subrect = OctSlice_to_CvRect( self, object ); + cvGetSubRect(self, &tmp, subrect); + cvSet(&tmp, val); + } +SWIGINTERN void IplImage___paren_asgn__SWIG_4(IplImage *self,octave_value object,CvArr *arr){ + CvMat tmp; + CvRect subrect = OctSlice_to_CvRect( self, object ); + cvGetSubRect(self, &tmp, subrect); + cvConvert(arr, &tmp); + } +SWIGINTERN octave_value IplImage___paren(IplImage *self,octave_value object){ + CvMat mat; + IplImage * im; + CvRect subrect = OctSlice_to_CvRect( self, object ); + + // return scalar if single element + if(subrect.width==1 && subrect.height==1){ + CvScalar * s; + int type = cvGetElemType( self ); + if(CV_MAT_CN(type) > 1){ + s = new CvScalar; + *s = cvGet2D( self, subrect.y, subrect.x ); + return SWIG_NewPointerObj( s, SWIGTYPE_p_CvScalar, 1 ); + } + switch(((type) & ((1 << 3) - 1))){ + case 0: + return OctLong_FromUnsignedLong( CV_IMAGE_ELEM(self, uchar, subrect.y, subrect.x ) ); + case 1: + return OctLong_FromLong( CV_IMAGE_ELEM(self, char, subrect.y, subrect.x ) ); + case 2: + return OctLong_FromUnsignedLong( CV_IMAGE_ELEM(self, ushort, subrect.y, subrect.x ) ); + case 3: + return OctLong_FromLong( CV_IMAGE_ELEM(self, short, subrect.y, subrect.x ) ); + case 4: + return OctLong_FromLong( CV_IMAGE_ELEM(self, int, subrect.y, subrect.x ) ); + case 5: + return OctFloat_FromDouble( CV_IMAGE_ELEM(self, float, subrect.y, subrect.x) ); + case 6: + return OctFloat_FromDouble( CV_IMAGE_ELEM(self, double, subrect.y, subrect.x) ); + } + } + + // otherwise return array + im = (IplImage *) cvAlloc(sizeof(IplImage)); + cvGetSubRect(self, &mat, subrect); + im = cvGetImage(&mat, im); + return SWIG_NewPointerObj( im, SWIGTYPE_p__IplImage, 1 ); + } +SWIGINTERN void delete_IplConvKernel(IplConvKernel *self){ IplConvKernel * dummy = self; cvReleaseStructuringElement (& dummy); } + +typedef union { + uchar* ptr; + short* s; + int* i; + float* fl; + double* db; + } CvMat_data; + + +SWIGINTERN void delete_CvMat(CvMat *self){ CvMat * dummy = self; cvReleaseMat (& dummy); } +SWIGINTERN CvMat *CvMat_operator_Sa___SWIG_0(CvMat *self,CvArr *src){ + CvMat * res = cvCreateMat(self->rows, self->cols, self->type); + cvAdd(self, src, res); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sm___SWIG_0(CvMat *self,CvArr *src){ + CvMat * res = cvCreateMat(self->rows, self->cols, self->type); + cvMul(self, src, res); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Ss___SWIG_0(CvMat *self,CvArr *src){ + CvMat * res = cvCreateMat(self->rows, self->cols, self->type); + cvSub(self, src, res); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sd___SWIG_0(CvMat *self,CvArr *src){ + CvMat * res = cvCreateMat(self->rows, self->cols, self->type); + cvDiv(self, src, res); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sx___SWIG_0(CvMat *self,CvArr *src){ + CvMat * res = cvCreateMat(self->rows, self->cols, self->type); + cvXor(self, src, res); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sa___SWIG_1(CvMat *self,CvScalar val){ + CvMat * res = cvCreateMat(self->rows, self->cols, self->type); + cvAddS(self, val, res); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sx___SWIG_1(CvMat *self,CvScalar val){ + CvMat * res = cvCreateMat(self->rows, self->cols, self->type); + cvXorS(self, val, res); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Ss___SWIG_1(CvMat *self,CvScalar val){ + CvMat * res = cvCreateMat(self->rows, self->cols, self->type); + cvSubS(self, val, res); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sg__Se___SWIG_0(CvMat *self,CvArr *src){ + CvMat * res = cvCreateMat(self->rows, self->cols, 0); + cvCmp(self, src, res, 2); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sg__Se___SWIG_1(CvMat *self,double val){ + CvMat * res = cvCreateMat(self->rows, self->cols, 0); + cvCmpS(self, val, res, 2); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Se__Se___SWIG_0(CvMat *self,CvArr *src){ + CvMat * res = cvCreateMat(self->rows, self->cols, 0); + cvCmp(self, src, res, 0); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Se__Se___SWIG_1(CvMat *self,double val){ + CvMat * res = cvCreateMat(self->rows, self->cols, 0); + cvCmpS(self, val, res, 0); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sl__Se___SWIG_0(CvMat *self,CvArr *src){ + CvMat * res = cvCreateMat(self->rows, self->cols, 0); + cvCmp(self, src, res, 4); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sl__Se___SWIG_1(CvMat *self,double val){ + CvMat * res = cvCreateMat(self->rows, self->cols, 0); + cvCmpS(self, val, res, 4); + return res; + } +SWIGINTERN CvMat *CvMat_operator_SN__Se___SWIG_0(CvMat *self,CvArr *src){ + CvMat * res = cvCreateMat(self->rows, self->cols, 0); + cvCmp(self, src, res, 5); + return res; + } +SWIGINTERN CvMat *CvMat_operator_SN__Se___SWIG_1(CvMat *self,double val){ + CvMat * res = cvCreateMat(self->rows, self->cols, 0); + cvCmpS(self, val, res, 5); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sl___SWIG_0(CvMat *self,CvArr *src){ + CvMat * res = cvCreateMat(self->rows, self->cols, 0); + cvCmp(self, src, res, 3); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sl___SWIG_1(CvMat *self,double val){ + CvMat * res = cvCreateMat(self->rows, self->cols, 0); + cvCmpS(self, val, res, 3); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sg___SWIG_0(CvMat *self,CvArr *src){ + CvMat * res = cvCreateMat(self->rows, self->cols, 0); + cvCmp(self, src, res, 1); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sg___SWIG_1(CvMat *self,double val){ + CvMat * res = cvCreateMat(self->rows, self->cols, 0); + cvCmpS(self, val, res, 1); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sm___SWIG_1(CvMat *self,double val){ + CvMat * res = cvCreateMat(self->rows, self->cols, self->type); + cvConvertScale(self, res, val); + return res; + } +SWIGINTERN CvMat *CvMat_operator_Sd___SWIG_1(CvMat *self,double val){ + CvMat * res = cvCreateMat(self->rows, self->cols, self->type); + cvConvertScale(self, res, 1.0/val); + return res; + } +SWIGINTERN CvMat *CvMat___radd____SWIG_0(CvMat *self,CvArr *arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvAdd(self, arg, retarg); + return retarg; + } +SWIGINTERN CvMat *CvMat___rsub____SWIG_0(CvMat *self,CvArr *arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvSub(arg, self, retarg); + return retarg; + } +SWIGINTERN CvMat *CvMat___rdiv____SWIG_0(CvMat *self,CvArr *arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvDiv(arg, self, retarg); + return retarg; + } +SWIGINTERN CvMat *CvMat___rmul____SWIG_0(CvMat *self,CvArr *arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvMatMul(arg, self, retarg); + return retarg; + } +SWIGINTERN CvMat *CvMat___radd____SWIG_1(CvMat *self,CvScalar arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvAddS(self, arg, retarg); + return retarg; + } +SWIGINTERN CvMat *CvMat___radd____SWIG_2(CvMat *self,double arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvAddS(self, cvScalar(arg), retarg); + return retarg; + } +SWIGINTERN CvMat *CvMat___rsub____SWIG_1(CvMat *self,CvScalar arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvSubRS(self, arg, retarg); + return retarg; + } +SWIGINTERN CvMat *CvMat___rsub____SWIG_2(CvMat *self,double arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvSubRS(self, cvScalar(arg), retarg); + return retarg; + } +SWIGINTERN CvArr *CvMat___rmul____SWIG_1(CvMat *self,double arg){ + CvArr * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvConvertScale(self, retarg, arg); + return retarg; + } +SWIGINTERN CvArr *CvMat___rdiv____SWIG_1(CvMat *self,double arg){ + CvArr * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvConvertScale(self, retarg, 1.0/arg); + return retarg; + } +SWIGINTERN CvMat *CvMat___ror____SWIG_0(CvMat *self,CvScalar arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvOrS(self, arg, retarg); + return retarg; + } +SWIGINTERN CvMat *CvMat___ror____SWIG_1(CvMat *self,double arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvOrS(self, cvScalar(arg), retarg); + return retarg; + } +SWIGINTERN CvMat *CvMat___rand____SWIG_0(CvMat *self,CvScalar arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvAndS(self, arg, retarg); + return retarg; + } +SWIGINTERN CvMat *CvMat___rand____SWIG_1(CvMat *self,double arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvAndS(self, cvScalar(arg), retarg); + return retarg; + } +SWIGINTERN CvMat *CvMat___rxor____SWIG_0(CvMat *self,CvScalar arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvXorS(self, arg, retarg); + return retarg; + } +SWIGINTERN CvMat *CvMat___rxor____SWIG_1(CvMat *self,double arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvXorS(self, cvScalar(arg), retarg); + return retarg; + } +SWIGINTERN CvArr *CvMat___req__(CvMat *self,double arg){ + CvArr * retarg = cvCreateMat(self->rows, self->cols, 0); + cvCmpS(self, arg, retarg, 0); + return retarg; + } +SWIGINTERN CvArr *CvMat___rgt__(CvMat *self,double arg){ + CvArr * retarg = cvCreateMat(self->rows, self->cols, 0); + cvCmpS(self, arg, retarg, 1); + return retarg; + } +SWIGINTERN CvArr *CvMat___rge__(CvMat *self,double arg){ + CvArr * retarg = cvCreateMat(self->rows, self->cols, 0); + cvCmpS(self, arg, retarg, 2); + return retarg; + } +SWIGINTERN CvArr *CvMat___rlt__(CvMat *self,double arg){ + CvArr * retarg = cvCreateMat(self->rows, self->cols, 0); + cvCmpS(self, arg, retarg, 3); + return retarg; + } +SWIGINTERN CvArr *CvMat___rle__(CvMat *self,double arg){ + CvArr * retarg = cvCreateMat(self->rows, self->cols, 0); + cvCmpS(self, arg, retarg, 4); + return retarg; + } +SWIGINTERN CvArr *CvMat___rne__(CvMat *self,double arg){ + CvArr * retarg = cvCreateMat(self->rows, self->cols, 0); + cvCmpS(self, arg, retarg, 5); + return retarg; + } +SWIGINTERN CvMat *CvMat___pow__(CvMat *self,double arg){ + CvMat * retarg = cvCreateMat(self->rows, self->cols, self->type); + cvPow(self, retarg, arg); + return retarg; + } +SWIGINTERN char *CvMat___str(CvMat *self){ + static char str[8]; + cvArrPrint( self ); + str[0]=0; + return str; + return ""; + } +SWIGINTERN void CvMat___paren_asgn__SWIG_0(CvMat *self,octave_value object,double val){ + CvMat tmp; + CvRect subrect = OctSlice_to_CvRect( self, object ); + /*@SWIG:./cvarr.i,206,CHECK_SLICE_BOUNDS@*/ + //printf("__setitem__ slice(%d:%d, %d:%d) array(%d,%d)", subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows); + if(subrect.width<=0 || subrect.height<=0 || + subrect.width>self->cols || subrect.height>self->rows || + subrect.x<0 || subrect.y<0 || + subrect.x>= self->cols || subrect.y >=self->rows){ + char errstr[256]; + // previous function already set error string + if(subrect.width==0 && subrect.height==0 && subrect.x==0 && subrect.y==0) return ; + sprintf(errstr, "Requested slice [ %d:%d %d:%d ] oversteps array sized [ %d %d ]", + subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows); + error(errstr); + return ; + } +else{} +/*@SWIG@*/; + cvGetSubRect(self, &tmp, subrect); + cvSet(&tmp, cvScalarAll(val)); + } +SWIGINTERN void CvMat___paren_asgn__SWIG_1(CvMat *self,octave_value object,CvPoint val){ + CvMat tmp; + CvRect subrect = OctSlice_to_CvRect( self, object ); + /*@SWIG:./cvarr.i,206,CHECK_SLICE_BOUNDS@*/ + //printf("__setitem__ slice(%d:%d, %d:%d) array(%d,%d)", subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows); + if(subrect.width<=0 || subrect.height<=0 || + subrect.width>self->cols || subrect.height>self->rows || + subrect.x<0 || subrect.y<0 || + subrect.x>= self->cols || subrect.y >=self->rows){ + char errstr[256]; + // previous function already set error string + if(subrect.width==0 && subrect.height==0 && subrect.x==0 && subrect.y==0) return ; + sprintf(errstr, "Requested slice [ %d:%d %d:%d ] oversteps array sized [ %d %d ]", + subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows); + error(errstr); + return ; + } +else{} +/*@SWIG@*/; + cvGetSubRect(self, &tmp, subrect); + cvSet(&tmp, cvScalar(val.x, val.y)); + } +SWIGINTERN void CvMat___paren_asgn__SWIG_2(CvMat *self,octave_value object,CvPoint2D32f val){ + CvMat tmp; + CvRect subrect = OctSlice_to_CvRect( self, object ); + cvGetSubRect(self, &tmp, subrect); + /*@SWIG:./cvarr.i,206,CHECK_SLICE_BOUNDS@*/ + //printf("__setitem__ slice(%d:%d, %d:%d) array(%d,%d)", subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows); + if(subrect.width<=0 || subrect.height<=0 || + subrect.width>self->cols || subrect.height>self->rows || + subrect.x<0 || subrect.y<0 || + subrect.x>= self->cols || subrect.y >=self->rows){ + char errstr[256]; + // previous function already set error string + if(subrect.width==0 && subrect.height==0 && subrect.x==0 && subrect.y==0) return ; + sprintf(errstr, "Requested slice [ %d:%d %d:%d ] oversteps array sized [ %d %d ]", + subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows); + error(errstr); + return ; + } +else{} +/*@SWIG@*/; + cvSet(&tmp, cvScalar(val.x, val.y)); + } +SWIGINTERN void CvMat___paren_asgn__SWIG_3(CvMat *self,octave_value object,CvScalar val){ + CvMat tmp; + CvRect subrect = OctSlice_to_CvRect( self, object ); + cvGetSubRect(self, &tmp, subrect); + /*@SWIG:./cvarr.i,206,CHECK_SLICE_BOUNDS@*/ + //printf("__setitem__ slice(%d:%d, %d:%d) array(%d,%d)", subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows); + if(subrect.width<=0 || subrect.height<=0 || + subrect.width>self->cols || subrect.height>self->rows || + subrect.x<0 || subrect.y<0 || + subrect.x>= self->cols || subrect.y >=self->rows){ + char errstr[256]; + // previous function already set error string + if(subrect.width==0 && subrect.height==0 && subrect.x==0 && subrect.y==0) return ; + sprintf(errstr, "Requested slice [ %d:%d %d:%d ] oversteps array sized [ %d %d ]", + subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows); + error(errstr); + return ; + } +else{} +/*@SWIG@*/; + cvSet(&tmp, val); + } +SWIGINTERN void CvMat___paren_asgn__SWIG_4(CvMat *self,octave_value object,CvArr *arr){ + CvMat tmp, src_stub, *src; + CvRect subrect = OctSlice_to_CvRect( self, object ); + /*@SWIG:./cvarr.i,206,CHECK_SLICE_BOUNDS@*/ + //printf("__setitem__ slice(%d:%d, %d:%d) array(%d,%d)", subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows); + if(subrect.width<=0 || subrect.height<=0 || + subrect.width>self->cols || subrect.height>self->rows || + subrect.x<0 || subrect.y<0 || + subrect.x>= self->cols || subrect.y >=self->rows){ + char errstr[256]; + // previous function already set error string + if(subrect.width==0 && subrect.height==0 && subrect.x==0 && subrect.y==0) return ; + sprintf(errstr, "Requested slice [ %d:%d %d:%d ] oversteps array sized [ %d %d ]", + subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows); + error(errstr); + return ; + } +else{} +/*@SWIG@*/; + cvGetSubRect(self, &tmp, subrect); + + // Reshape source array to fit destination + // This will be used a lot for small arrays b/c + // OctObject_to_CvArr tries to compress a 2-D octave + // array with 1-4 columns into a multichannel vector + src=cvReshape(arr, &src_stub, CV_MAT_CN(tmp.type), tmp.rows); + + cvConvert(src, &tmp); + } +SWIGINTERN octave_value CvMat___paren(CvMat *self,octave_value object){ + CvMat * mat; + CvRect subrect = OctSlice_to_CvRect( self, object ); + /*@SWIG:./cvarr.i,206,CHECK_SLICE_BOUNDS@*/ + //printf("__setitem__ slice(%d:%d, %d:%d) array(%d,%d)", subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows); + if(subrect.width<=0 || subrect.height<=0 || + subrect.width>self->cols || subrect.height>self->rows || + subrect.x<0 || subrect.y<0 || + subrect.x>= self->cols || subrect.y >=self->rows){ + char errstr[256]; + // previous function already set error string + if(subrect.width==0 && subrect.height==0 && subrect.x==0 && subrect.y==0) return octave_value(); + sprintf(errstr, "Requested slice [ %d:%d %d:%d ] oversteps array sized [ %d %d ]", + subrect.x, subrect.y, subrect.x+subrect.width, subrect.y+subrect.height, self->cols, self->rows); + error(errstr); + return octave_value(); + } +else{} +/*@SWIG@*/; + if(subrect.width==1 && subrect.height==1){ + CvScalar * s; + int type = cvGetElemType( self ); + if(CV_MAT_CN(type) > 1){ + s = new CvScalar; + *s = cvGet2D( self, subrect.y, subrect.x ); + return SWIG_NewPointerObj( s, SWIGTYPE_p_CvScalar, 1 ); + } + switch(((type) & ((1 << 3) - 1))){ + case 0: + return OctLong_FromUnsignedLong( CV_MAT_ELEM(*self, uchar, subrect.y, subrect.x ) ); + case 1: + return OctLong_FromLong( CV_MAT_ELEM(*self, char, subrect.y, subrect.x ) ); + case 2: + return OctLong_FromUnsignedLong( CV_MAT_ELEM(*self, ushort, subrect.y, subrect.x ) ); + case 3: + return OctLong_FromLong( CV_MAT_ELEM(*self, short, subrect.y, subrect.x ) ); + case 4: + return OctLong_FromLong( CV_MAT_ELEM(*self, int, subrect.y, subrect.x ) ); + case 5: + return OctFloat_FromDouble( CV_MAT_ELEM(*self, float, subrect.y, subrect.x) ); + case 6: + return OctFloat_FromDouble( CV_MAT_ELEM(*self, double, subrect.y, subrect.x) ); + } + } + mat = (CvMat *) cvAlloc(sizeof(CvMat)); + cvGetSubRect(self, mat, subrect); + + // cvGetSubRect doesn't do this since it assumes mat lives on the stack + mat->hdr_refcount = self->hdr_refcount; + mat->refcount = self->refcount; + cvIncRefData(mat); + + return SWIG_NewPointerObj( mat, SWIGTYPE_p_CvMat, 1 ); + } + +typedef struct { + int size; + int step; + } CvMatND_dim; + + + +typedef union { + uchar* ptr; + float* fl; + double* db; + int* i; + short* s; + } CvMatND_data; + + +SWIGINTERN void delete_CvMatND(CvMatND *self){ CvMatND * dummy = self; cvReleaseMatND (& dummy); } +SWIGINTERN void delete_CvSparseMat(CvSparseMat *self){ CvSparseMat * dummy = self; cvReleaseSparseMat (& dummy); } +SWIGINTERN void delete_CvHistogram(CvHistogram *self){ CvHistogram * dummy = self; cvReleaseHist (& dummy); } +SWIGINTERN char const *CvPoint___str__(CvPoint *self){ + static char str[64]; + snprintf(str, 64, "[%d %d]", self->x, self->y); + return str; + } +SWIGINTERN char const *CvPoint___repr__(CvPoint *self){ + static char str[64]; + snprintf(str, 64, "cvPoint(%d,%d)", self->x, self->y); + return str; + } +SWIGINTERN char const *CvPoint2D32f___str__(CvPoint2D32f *self){ + static char str[64]; + snprintf(str, 64, "[%f %f]", self->x, self->y); + return str; + } +SWIGINTERN char const *CvPoint2D32f___repr__(CvPoint2D32f *self){ + static char str[64]; + snprintf(str, 64, "cvPoint2D32f(%f,%f)", self->x, self->y); + return str; + } +SWIGINTERN char const *CvScalar___str__(CvScalar *self){ + static char str[256]; + snprintf(str, 256, "[%f, %f, %f, %f]", self->val[0], self->val[1], self->val[2], self->val[3]); + return str; + } +SWIGINTERN char const *CvScalar___repr__(CvScalar *self){ + static char str[256]; + snprintf(str, 256, "cvScalar(%f, %f, %f, %f)", self->val[0], self->val[1], self->val[2], self->val[3]); + return str; + } +SWIGINTERN double const CvScalar___getitem__(CvScalar *self,int index){ + if (index >= 4) { + + + + error("indice must be lower than 4"); + + return 0; + } + if (index < -4) { + + + + error("indice must be bigger or egal to -4"); + + return 0; + } + if (index < 0) { + /* negative index means from the end in python */ + index = 4 - index; + } + return self->val [index]; + } +SWIGINTERN void CvScalar___setitem__(CvScalar *self,int index,double value){ + if (index >= 4) { + + + + error("indice must be lower than 4"); + + return; + } + if (index < -4) { + + + + error("indice must be bigger or egal to -4"); + + return; + } + if (index < 0) { + /* negative index means from the end in python */ + index = 4 - index; + } + self->val [index] = value; + } +SWIGINTERN void delete_CvMemStorage(CvMemStorage *self){ CvMemStorage * dummy = self; cvReleaseMemStorage (& dummy); } + +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; +} + + + + + +typedef union { + double f; + int i; + CvString str; + CvSeq* seq; + CvFileNodeHash* map; + } CvFileNode_data; + + +SWIGINTERN void delete_CvGraphScanner(CvGraphScanner *self){ CvGraphScanner * dummy = self; cvReleaseGraphScanner (& dummy); } + +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; +} + + +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); +} + +SWIGINTERN CvTypedSeq< CvQuadEdge2D > *CvSubdiv2D_typed_edges_get(CvSubdiv2D *self){ + return (CvTypedSeq *) self->edges; + } +SWIGINTERN void CvSubdiv2D_typed_edges_set(CvSubdiv2D *self,CvTypedSeq< CvQuadEdge2D > *){ + } +SWIGINTERN void delete_CvConDensation(CvConDensation *self){ CvConDensation * dummy = self; cvReleaseConDensation (& dummy); } +SWIGINTERN void delete_CvKalman(CvKalman *self){ CvKalman * dummy = self; cvReleaseKalman (& dummy); } + +typedef struct { + CvRect r; + float weight; + } CvHaarFeature_rect; + + +SWIGINTERN void delete_CvHaarClassifierCascade(CvHaarClassifierCascade *self){ CvHaarClassifierCascade * dummy = self; cvReleaseHaarClassifierCascade (& dummy); } +SWIGINTERN void delete_CvLSH(CvLSH *self){ CvLSH * dummy = self; cvReleaseLSH (& dummy); } + +int CvMat_cols_get(CvMat * m){ + return m->cols; +} +void CvMat_cols_set(CvMat * m, int cols){ + m->cols = cols; +} +int CvMat_rows_get(CvMat *m){ + return m->rows; +} +void CvMat_rows_set(CvMat *m, int rows){ + m->rows = rows; +} +int CvMat_width_get(CvMat * m){ + return m->cols; +} +void CvMat_width_set(CvMat * m, int width){ + m->cols = width; +} +int CvMat_height_get(CvMat *m){ + return m->rows; +} +void CvMat_height_set(CvMat * m, int height){ + m->rows = height; +} +int CvMat_depth_get(CvMat * m){ + return cvIplDepth(m->type); +} +void CvMat_depth_set(CvMat *m, int depth){ + cvError(CV_StsNotImplemented, "CvMat_depth_set", "Not Implemented", __FILE__, __LINE__); +} +int CvMat_nChannels_get(CvMat * m){ + return CV_MAT_CN(m->type); +} +void CvMat_nChannels_set(CvMat *m, int nChannels){ + int depth = CV_MAT_DEPTH(m->type); + m->type = CV_MAKETYPE(depth, nChannels); +} +int CvMat_origin_get(CvMat * m){ + /* Always 0 - top-left origin */ + return 0; +} +void CvMat_origin_set(CvMat * m, int origin){ + cvError(CV_StsNotImplemented, "CvMat_origin_get", "IplImage is replaced by CvMat in Python, so its fields are read-only", __FILE__, __LINE__); +} +int CvMat_dataOrder_get(CvMat * m){ + cvError(CV_StsNotImplemented, "CvMat_dataOrder_get", "Not Implemented", __FILE__, __LINE__); + return 0; +} +void CvMat_dataOrder_set(CvMat * m, int dataOrder){ + cvError(CV_StsNotImplemented, "CvMat_dataOrder_get", "IplImage is replaced by CvMat in Python, so its fields are read-only", __FILE__, __LINE__); +} +int CvMat_imageSize_get(CvMat * m){ + int step = m->step ? m->step : CV_ELEM_SIZE(m->type) * m->cols; + return step*m->rows; +} +void CvMat_imageSize_set(CvMat * m, int imageSize){ + cvError(CV_StsNotImplemented, "CvMat_imageSize_set", "IplImage is not implemented in Python, so origin is read-only", __FILE__, __LINE__); +} +int CvMat_widthStep_get(CvMat * m){ + return m->step; +} +void CvMat_widthStep_set(CvMat *m, int widthStep){ + m->step = widthStep; +} + + + +/// Accessor to convert a Octave string into the imageData. +void CvMat_imageData_set(CvMat * self, octave_value object) +{ + /* + char* oct_string = OctString_AsString(object); + int depth = CV_MAT_DEPTH(self->type); + int cn = CV_MAT_CN(self->type); + + if (depth == CV_8U && cn==3){ + // RGB case + // The data is reordered beause OpenCV uses BGR instead of RGB + + for (long line = 0; line < self->rows; ++line) + for (long pixel = 0; pixel < self->cols; ++pixel) + { + // In OpenCV the beginning of the lines are aligned + // to 4 Bytes. So use step instead of cols. + long position = line*self->step + pixel*3; + long sourcepos = line*self->cols*3 + pixel*3; + self->data.ptr[position ] = oct_string[sourcepos+2]; + self->data.ptr[position+1] = oct_string[sourcepos+1]; + self->data.ptr[position+2] = oct_string[sourcepos ]; + } + } + else if (depth == CV_8U && cn==1) + { + // Grayscale 8bit case + + for (long line = 0; line < self->rows; ++line) + { + // In OpenCV the beginning of the lines are aligned + // to 4 Bytes. So use step instead of cols. + memcpy + ( + self->data.ptr + line*self->step, + oct_string + line*self->cols, + self->step + ); + } + } + else if ( depth == CV_32F ) + { + // float (32bit) case + for (long line = 0; line < self->rows; ++line) + { + // here we don not have to care about alignment as the Floats are + // as long as the alignment + memcpy + ( + self->data.ptr + line*self->step, + oct_string + line*self->cols*sizeof(float), + self->step + ); + } + } + else if ( depth == CV_64F ) + { + // double (64bit) case + for (long line = 0; line < self->rows; ++line) + { + // here we don not have to care about alignment as the Floats are + // as long as the alignment + memcpy + ( + self->data.ptr + line*self->step, + oct_string + line*self->cols*sizeof(double), + self->step + ); + } + } + else + { + // make some noise + SendErrorToOctave (SWIG_TypeError, + "CvMat_imageData_set", + "cannot convert string data to this image format", + __FILE__, __LINE__, NULL); + } + */ +} + +/// Accessor to convert the imageData into a Octave string. +octave_value CvMat_imageData_get(CvMat * self) +{ + /* + if (!self->data.ptr) + { + OctErr_SetString(OctExc_TypeError, "Data pointer of CvMat is NULL"); + return NULL; + } + return OctString_FromStringAndSize((const char *)self->data.ptr, self->rows*self->step); + */ + return octave_value(); +} + + +const char* _wrap_cvGetDimSize_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetDimSize (@var{arr}, @var{index})\n\ +@var{arr} is of type CvArr. @var{index} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCalcImageHist_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcHist (@var{image}, @var{hist}, @var{accumulate} = 0, @var{mask} = nil)\n\ +@var{image} is of type . @var{hist} is of type CvHistogram. @var{accumulate} is of type int. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_create_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} create (@var{self}, @var{rows}, @var{cols}, @var{type})\n\ +@var{self} is of type CvMatrix. @var{rows} is of type int. @var{cols} is of type int. @var{type} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvImage_create_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} create (@var{self}, @var{size}, @var{depth}, @var{channels})\n\ +@var{self} is of type CvImage. @var{size} is of type CvSize. @var{depth} is of type int. @var{channels} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvROIToRect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvROIToRect (@var{roi})\n\ +@var{roi} is of type . @var{retval} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_CvImage_height_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = height (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_SEQ_KIND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_SEQ_KIND (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSolve_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSolve (@var{src1}, @var{src2}, @var{dst}, @var{method} = 0)\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. @var{method} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvBoundingRect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvBoundingRect (@var{points}, @var{update} = 0)\n\ +@var{points} is of type CvArr. @var{update} is of type int. @var{retval} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_CV_MAT_ELEM_PTR_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_MAT_ELEM_PTR (@var{mat}, @var{row}, @var{col})\n\ +@var{mat} is of type CvMat. @var{row} is of type int. @var{col} is of type int. @var{retval} is of type void. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_front_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = front (@var{self})\n\ +@var{self} is of type CvPointVector. @var{retval} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_front_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = front (@var{self})\n\ +@var{self} is of type FloatVector. @var{retval} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_depth_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = depth (@var{self})\n\ +@var{self} is of type CvMatrix. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseImageHeader_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseImageHeader (@var{image})\n\ +@var{image} is of type . \n\ +@end deftypefn"; +const char* _wrap_cvClearND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvClearND (@var{arr}, @var{idx})\n\ +@var{arr} is of type CvArr. @var{idx} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSetHistBinRanges_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetHistBinRanges (@var{hist}, @var{ranges}, @var{uniform} = 1)\n\ +@var{hist} is of type CvHistogram. @var{ranges} is of type float. @var{uniform} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSubS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSubS (@var{src}, @var{value}, @var{dst}, @var{mask} = nil)\n\ +@var{src} is of type CvArr. @var{value} is of type CvScalar. @var{dst} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvMorphologyEx_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMorphologyEx (@var{src}, @var{dst}, @var{temp}, @var{element}, @var{operation}, @var{iterations} = 1)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{temp} is of type CvArr. @var{element} is of type . @var{operation} is of type int. @var{iterations} is of type int. \n\ +@end deftypefn"; +const char* _wrap_new_CvHaarFeature_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvHaarFeature::CvHaarFeature ()\n\ +@var{retval} is of type CvHaarFeature. \n\ +@end deftypefn"; +const char* _wrap_delete_CvHaarFeature_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvHaarFeature::~CvHaarFeature (@var{self})\n\ +@var{self} is of type CvHaarFeature. \n\ +@end deftypefn"; +const char* _wrap_cvReshape_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvReshape (@var{arr}, @var{header}, @var{new_cn}, @var{new_rows} = 0)\n\ +@var{arr} is of type CvArr. @var{header} is of type CvMat. @var{new_cn} is of type int. @var{new_rows} is of type int. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvConvertScale_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvConvertScale (@var{src}, @var{dst}, @var{scale} = 1, @var{shift} = 0)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{scale} is of type double. @var{shift} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvSquareAcc_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSquareAcc (@var{image}, @var{sqsum}, @var{mask} = nil)\n\ +@var{image} is of type CvArr. @var{sqsum} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvMaxS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMaxS (@var{src}, @var{value}, @var{dst})\n\ +@var{src} is of type CvArr. @var{value} is of type double. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvMatchContourTrees_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvMatchContourTrees (@var{tree1}, @var{tree2}, @var{method}, @var{threshold})\n\ +@var{tree1} is of type CvContourTree. @var{tree2} is of type CvContourTree. @var{method} is of type int. @var{threshold} is of type double. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_CV_MAT_ELEM_PTR_FAST_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_MAT_ELEM_PTR_FAST (@var{mat}, @var{row}, @var{col}, @var{pix_size})\n\ +@var{mat} is of type CvMat. @var{row} is of type int. @var{col} is of type int. @var{pix_size} is of type int. @var{retval} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvLUT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvLUT (@var{src}, @var{dst}, @var{lut})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{lut} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvSeqPopFront_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSeqPopFront (@var{seq}, @var{element} = nil)\n\ +@var{seq} is of type CvSeq. @var{element} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvReshapeMatND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvReshapeMatND (@var{arr}, @var{sizeof_header}, @var{header}, @var{new_cn}, @var{new_dims}, @var{new_sizes})\n\ +@var{arr} is of type CvArr. @var{sizeof_header} is of type int. @var{header} is of type CvArr. @var{new_cn} is of type int. @var{new_dims} is of type int. @var{new_sizes} is of type int. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvCloneMatND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCloneMatND (@var{mat})\n\ +@var{mat} is of type CvMatND. @var{retval} is of type CvMatND. \n\ +@end deftypefn"; +const char* _wrap_cvCreateMatND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateMatND (@var{dims}, @var{type})\n\ +@var{dims} is of type int. @var{type} is of type int. @var{retval} is of type CvMatND. \n\ +@end deftypefn"; +const char* _wrap_cvMatMul_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMatMul (@var{src1}, @var{src2}, @var{dst})\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvRQDecomp3x3_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvRQDecomp3x3 (@var{matrixM}, @var{matrixR}, @var{matrixQ}, @var{matrixQx} = nil, @var{matrixQy} = nil, @var{matrixQz} = nil, @var{eulerAngles} = nil)\n\ +@var{matrixM} is of type CvMat. @var{matrixR} is of type CvMat. @var{matrixQ} is of type CvMat. @var{matrixQx} is of type CvMat. @var{matrixQy} is of type CvMat. @var{matrixQz} is of type CvMat. @var{eulerAngles} is of type CvPoint3D64f. \n\ +@end deftypefn"; +const char* _wrap_cvGetErrInfo_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetErrInfo (@var{errcode_desc}, @var{description}, @var{filename}, @var{line})\n\ +@var{errcode_desc} is of type char. @var{description} is of type char. @var{filename} is of type char. @var{line} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetRectSubPix_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvGetRectSubPix (@var{src}, @var{dst}, @var{center})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{center} is of type CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_cvFindCornerSubPix_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFindCornerSubPix (@var{image}, @var{corners}, @var{win}, @var{zero_zone}, @var{criteria})\n\ +@var{image} is of type CvArr. @var{corners} is of type CvPoint2D32f. @var{win} is of type CvSize. @var{zero_zone} is of type CvSize. @var{criteria} is of type CvTermCriteria. \n\ +@end deftypefn"; +const char* _wrap_cvSeqPushFront_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSeqPushFront (@var{seq}, @var{element} = nil)\n\ +@var{seq} is of type CvSeq. @var{element} is of type void. @var{retval} is of type schar. \n\ +@end deftypefn"; +const char* _wrap_cvSmooth_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSmooth (@var{src}, @var{dst}, @var{smoothtype} = 2, @var{size1} = 3, @var{size2} = 0, @var{sigma1} = 0, @var{sigma2} = 0)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{smoothtype} is of type int. @var{size1} is of type int. @var{size2} is of type int. @var{sigma1} is of type double. @var{sigma2} is of type double. \n\ +@end deftypefn"; +const char* _wrap_new_CvSubdiv2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSubdiv2D::CvSubdiv2D ()\n\ +@var{retval} is of type CvSubdiv2D. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSubdiv2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSubdiv2D::~CvSubdiv2D (@var{self})\n\ +@var{self} is of type CvSubdiv2D. \n\ +@end deftypefn"; +const char* _wrap_cvCreateSubdiv2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateSubdiv2D (@var{subdiv_type}, @var{header_size}, @var{vtx_size}, @var{quadedge_size}, @var{storage})\n\ +@var{subdiv_type} is of type int. @var{header_size} is of type int. @var{vtx_size} is of type int. @var{quadedge_size} is of type int. @var{storage} is of type CvMemStorage. @var{retval} is of type CvSubdiv2D. \n\ +@end deftypefn"; +const char* _wrap_cvSetErrMode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSetErrMode (@var{mode})\n\ +@var{mode} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetErrMode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetErrMode ()\n\ +@var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGraphVtxDegree_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGraphVtxDegree (@var{graph}, @var{vtx_idx})\n\ +@var{graph} is of type CvGraph. @var{vtx_idx} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_IplImage___rle___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rle__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvMat___rle___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rle__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvPrevTreeNode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPrevTreeNode (@var{tree_iterator})\n\ +@var{tree_iterator} is of type CvTreeNodeIterator. @var{retval} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvNextTreeNode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvNextTreeNode (@var{tree_iterator})\n\ +@var{tree_iterator} is of type CvTreeNodeIterator. @var{retval} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvKMeans2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvKMeans2 (@var{samples}, @var{cluster_count}, @var{labels}, @var{termcrit}, @var{attempts} = 1, @var{rng} = 0, @var{flags} = 0, @var{_centers} = 0, @var{compactness} = 0)\n\ +@var{samples} is of type CvArr. @var{cluster_count} is of type int. @var{labels} is of type CvArr. @var{termcrit} is of type CvTermCriteria. @var{attempts} is of type int. @var{rng} is of type CvRNG. @var{flags} is of type int. @var{_centers} is of type CvArr. @var{compactness} is of type double. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvImage_step_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = step (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_LSHSize_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = LSHSize (@var{lsh})\n\ +@var{lsh} is of type CvLSH. @var{retval} is of type unsigned int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_INDEX_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_INDEX (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvRemap_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvRemap (@var{src}, @var{dst}, @var{mapx}, @var{mapy}, @var{flags} = 1+8, @var{fillval} = cvScalarAll(0))\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{mapx} is of type CvArr. @var{mapy} is of type CvArr. @var{flags} is of type int. @var{fillval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_CvImage_depth_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = depth (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSub_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSub (@var{src1}, @var{src2}, @var{dst}, @var{mask} = nil)\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvInitMatNDHeader_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvInitMatNDHeader (@var{mat}, @var{dims}, @var{type}, @var{data} = nil)\n\ +@var{mat} is of type CvMatND. @var{dims} is of type int. @var{type} is of type int. @var{data} is of type void. @var{retval} is of type CvMatND. \n\ +@end deftypefn"; +const char* _wrap_cvCreateMatNDHeader_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateMatNDHeader (@var{dims}, @var{type})\n\ +@var{dims} is of type int. @var{type} is of type int. @var{retval} is of type CvMatND. \n\ +@end deftypefn"; +const char* _wrap_cvInitMatHeader_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvInitMatHeader (@var{mat}, @var{rows}, @var{cols}, @var{type}, @var{data} = nil, @var{step} = 0x7fffffff)\n\ +@var{mat} is of type CvMat. @var{rows} is of type int. @var{cols} is of type int. @var{type} is of type int. @var{data} is of type void. @var{step} is of type int. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvCreateMatHeader_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateMatHeader (@var{rows}, @var{cols}, @var{type})\n\ +@var{rows} is of type int. @var{cols} is of type int. @var{type} is of type int. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_IplImage___ror___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __ror__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMat___ror___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __ror__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvFindFeatures_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFindFeatures (@var{tr}, @var{query_points}, @var{indices}, @var{dist}, @var{k}, @var{emax} = 20)\n\ +@var{tr} is of type CvFeatureTree. @var{query_points} is of type CvMat. @var{indices} is of type CvMat. @var{dist} is of type CvMat. @var{k} is of type int. @var{emax} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint2D32f_cast_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvPoint2D32f)>::cast (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type CvSeq_CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator_next_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = next (@var{self})\n\ +@var{self} is of type OctSwigIterator. @var{retval} is of type octave_value. \n\ +@end deftypefn"; +const char* _wrap_CvPoint___repr___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __repr__ (@var{self})\n\ +@var{self} is of type CvPoint. @var{retval} is of type char. \n\ +@end deftypefn"; +const char* _wrap_CvPoint2D32f___repr___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __repr__ (@var{self})\n\ +@var{self} is of type CvPoint2D32f. @var{retval} is of type char. \n\ +@end deftypefn"; +const char* _wrap_CvScalar___repr___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __repr__ (@var{self})\n\ +@var{self} is of type CvScalar. @var{retval} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvSum_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSum (@var{arr})\n\ +@var{arr} is of type CvArr. @var{retval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_new_CvSlice_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSlice::CvSlice ()\n\ +@var{retval} is of type CvSlice. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSlice_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSlice::~CvSlice (@var{self})\n\ +@var{self} is of type CvSlice. \n\ +@end deftypefn"; +const char* _wrap_cvSlice_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSlice (@var{start}, @var{end})\n\ +@var{start} is of type int. @var{end} is of type int. @var{retval} is of type CvSlice. \n\ +@end deftypefn"; +const char* _wrap_cvSetIPLAllocators_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetIPLAllocators (@var{create_header}, @var{allocate_data}, @var{deallocate}, @var{create_roi}, @var{clone_image})\n\ +@var{create_header} is of type Cv_iplCreateImageHeader. @var{allocate_data} is of type Cv_iplAllocateImageData. @var{deallocate} is of type Cv_iplDeallocate. @var{create_roi} is of type Cv_iplCreateROI. @var{clone_image} is of type Cv_iplCloneImage. \n\ +@end deftypefn"; +const char* _wrap_CV_WRITE_SEQ_ELEM_VAR_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CV_WRITE_SEQ_ELEM_VAR (@var{elem_ptr}, @var{writer})\n\ +@var{elem_ptr} is of type void. @var{writer} is of type CvSeqWriter. \n\ +@end deftypefn"; +const char* _wrap_cvSeqRemove_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSeqRemove (@var{seq}, @var{index})\n\ +@var{seq} is of type CvSeq. @var{index} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseFeatureTree_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseFeatureTree (@var{tr})\n\ +@var{tr} is of type CvFeatureTree. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_SEQ_IS_SIMPLE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_SEQ_IS_SIMPLE (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_SIMPLE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_SIMPLE (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_empty_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = empty (@var{self})\n\ +@var{self} is of type CvPointVector. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_empty_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = empty (@var{self})\n\ +@var{self} is of type FloatVector. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_cvSubRS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSubRS (@var{src}, @var{value}, @var{dst}, @var{mask} = nil)\n\ +@var{src} is of type CvArr. @var{value} is of type CvScalar. @var{dst} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CV_16SC_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_16SC (@var{n})\n\ +@var{n} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_MATND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_MATND (@var{mat})\n\ +@var{mat} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvPyrSegmentationUntyped_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvPyrSegmentation (@var{src}, @var{dst}, @var{storage}, @var{comp}, @var{level}, @var{threshold1}, @var{threshold2})\n\ +@var{src} is of type . @var{dst} is of type . @var{storage} is of type CvMemStorage. @var{comp} is of type CvSeq. @var{level} is of type int. @var{threshold1} is of type double. @var{threshold2} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvFindContoursUntyped_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFindContours (@var{image}, @var{storage}, @var{first_contour}, @var{header_size} = sizeof(CvContour), @var{mode} = 1, @var{method} = 2, @var{offset} = cvPoint(0,0))\n\ +@var{image} is of type CvArr. @var{storage} is of type CvMemStorage. @var{first_contour} is of type CvSeq. @var{header_size} is of type int. @var{mode} is of type int. @var{method} is of type int. @var{offset} is of type CvPoint. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvApproxChainsUntyped_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvApproxChains (@var{src_seq}, @var{storage}, @var{method} = 2, @var{parameter} = 0, @var{minimal_perimeter} = 0, @var{recursive} = 0)\n\ +@var{src_seq} is of type CvSeq. @var{storage} is of type CvMemStorage. @var{method} is of type int. @var{parameter} is of type double. @var{minimal_perimeter} is of type int. @var{recursive} is of type int. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvContourFromContourTreeUntyped_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvContourFromContourTree (@var{tree}, @var{storage}, @var{criteria})\n\ +@var{tree} is of type CvContourTree. @var{storage} is of type CvMemStorage. @var{criteria} is of type CvTermCriteria. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvConvexityDefectsUntyped_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvConvexityDefects (@var{contour}, @var{convexhull}, @var{storage} = nil)\n\ +@var{contour} is of type CvArr. @var{convexhull} is of type CvArr. @var{storage} is of type CvMemStorage. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvHoughLinesUntyped_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvHoughLines2 (@var{image}, @var{line_storage}, @var{method}, @var{rho}, @var{theta}, @var{threshold}, @var{param1} = 0, @var{param2} = 0)\n\ +@var{image} is of type CvArr. @var{line_storage} is of type void. @var{method} is of type int. @var{rho} is of type double. @var{theta} is of type double. @var{threshold} is of type int. @var{param1} is of type double. @var{param2} is of type double. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvHoughCirclesUntyped_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvHoughCircles (@var{image}, @var{circle_storage}, @var{method}, @var{dp}, @var{min_dist}, @var{param1} = 100, @var{param2} = 100, @var{min_radius} = 0, @var{max_radius} = 0)\n\ +@var{image} is of type CvArr. @var{circle_storage} is of type void. @var{method} is of type int. @var{dp} is of type double. @var{min_dist} is of type double. @var{param1} is of type double. @var{param2} is of type double. @var{min_radius} is of type int. @var{max_radius} is of type int. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvAbs_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvAbs (@var{src}, @var{dst})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvSobel_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSobel (@var{src}, @var{dst}, @var{xorder}, @var{yorder}, @var{aperture_size} = 3)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{xorder} is of type int. @var{yorder} is of type int. @var{aperture_size} is of type int. \n\ +@end deftypefn"; +const char* _wrap_IplImage___eq___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator == (@var{self}, @var{val})\n\ +@var{self} is of type . @var{val} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvSubdiv2DEdge_Wrapper___eq___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator == (@var{self}, @var{x})\n\ +@var{self} is of type CvSubdiv2DEdge_Wrapper. @var{x} is of type CvSubdiv2DEdge_Wrapper. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_CvRNG_Wrapper___eq___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator == (@var{self}, @var{x})\n\ +@var{self} is of type CvRNG_Wrapper. @var{x} is of type CvRNG_Wrapper. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator___eq___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator == (@var{self}, @var{x})\n\ +@var{self} is of type OctSwigIterator. @var{x} is of type OctSwigIterator. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_CvMat___eq___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator == (@var{self}, @var{val})\n\ +@var{self} is of type CvMat. @var{val} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvFloor_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFloor (@var{value})\n\ +@var{value} is of type double. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvMat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvMat (@var{rows}, @var{cols}, @var{type})\n\ +@var{rows} is of type int. @var{cols} is of type int. @var{type} is of type int. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_CV_SWAP_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CV_SWAP (@var{a}, @var{b}, @var{t})\n\ +@var{a} is of type int. @var{b} is of type int. @var{t} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_begin_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = begin (@var{self})\n\ +@var{self} is of type CvPointVector. @var{retval} is of type const_iterator. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_begin_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = begin (@var{self})\n\ +@var{self} is of type FloatVector. @var{retval} is of type const_iterator. \n\ +@end deftypefn"; +const char* _wrap_cvMax_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMax (@var{src1}, @var{src2}, @var{dst})\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseMatND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseMatND (@var{mat})\n\ +@var{mat} is of type CvMatND. \n\ +@end deftypefn"; +const char* _wrap_cvAcc_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvAcc (@var{image}, @var{sum}, @var{mask} = nil)\n\ +@var{image} is of type CvArr. @var{sum} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator_previous_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = previous (@var{self})\n\ +@var{self} is of type OctSwigIterator. @var{retval} is of type octave_value. \n\ +@end deftypefn"; +const char* _wrap_IplImage___rdiv___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rdiv__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvMat___rdiv___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rdiv__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint2D32f_pop_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = pop (@var{self})\n\ +@var{self} is of type CvSeq_CvPoint2D32f. @var{retval} is of type CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint_2_cast_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvTuple<(CvPoint,2)>)>::cast (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type CvSeq_CvPoint_2. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_2_cast_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvTuple<(float,2)>)>::cast (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type CvSeq_float_2. \n\ +@end deftypefn"; +const char* _wrap_cvCmpS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCmpS (@var{src}, @var{value}, @var{dst}, @var{cmp_op})\n\ +@var{src} is of type CvArr. @var{value} is of type double. @var{dst} is of type CvArr. @var{cmp_op} is of type int. \n\ +@end deftypefn"; +const char* _wrap_new_CvConvexityDefect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvConvexityDefect::CvConvexityDefect ()\n\ +@var{retval} is of type CvConvexityDefect. \n\ +@end deftypefn"; +const char* _wrap_delete_CvConvexityDefect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvConvexityDefect::~CvConvexityDefect (@var{self})\n\ +@var{self} is of type CvConvexityDefect. \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator_advance_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = advance (@var{self}, @var{n})\n\ +@var{self} is of type OctSwigIterator. @var{n} is of type ptrdiff_t. @var{retval} is of type OctSwigIterator. \n\ +@end deftypefn"; +const char* _wrap_cvUnregisterType_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvUnregisterType (@var{type_name})\n\ +@var{type_name} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvRegisterType_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvRegisterType (@var{info})\n\ +@var{info} is of type CvTypeInfo. \n\ +@end deftypefn"; +const char* _wrap_cvCheckArr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCheckArr (@var{arr}, @var{flags} = 0, @var{min_val} = 0, @var{max_val} = 0)\n\ +@var{arr} is of type CvArr. @var{flags} is of type int. @var{min_val} is of type double. @var{max_val} is of type double. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvFindExtrinsicCameraParams2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFindExtrinsicCameraParams2 (@var{object_points}, @var{image_points}, @var{camera_matrix}, @var{distortion_coeffs}, @var{rotation_vector}, @var{translation_vector}, @var{use_extrinsic_guess} = 0)\n\ +@var{object_points} is of type CvMat. @var{image_points} is of type CvMat. @var{camera_matrix} is of type CvMat. @var{distortion_coeffs} is of type CvMat. @var{rotation_vector} is of type CvMat. @var{translation_vector} is of type CvMat. @var{use_extrinsic_guess} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvWarpAffine_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvWarpAffine (@var{src}, @var{dst}, @var{map_matrix}, @var{flags} = 1+8, @var{fillval} = cvScalarAll(0))\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{map_matrix} is of type CvMat. @var{flags} is of type int. @var{fillval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_IplImage___add___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator + (@var{self}, @var{val})\n\ +@var{self} is of type . @var{val} is of type CvScalar. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator___add___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator + (@var{self}, @var{n})\n\ +@var{self} is of type OctSwigIterator. @var{n} is of type ptrdiff_t. @var{retval} is of type OctSwigIterator. \n\ +@end deftypefn"; +const char* _wrap_CvMat___add___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator + (@var{self}, @var{val})\n\ +@var{self} is of type CvMat. @var{val} is of type CvScalar. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_HAAR_CLASSIFIER_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_HAAR_CLASSIFIER (@var{haar})\n\ +@var{haar} is of type void. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvAdd_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvAdd (@var{src1}, @var{src2}, @var{dst}, @var{mask} = nil)\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvPutText_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvPutText (@var{img}, @var{text}, @var{org}, @var{font}, @var{color})\n\ +@var{img} is of type CvArr. @var{text} is of type char. @var{org} is of type CvPoint. @var{font} is of type CvFont. @var{color} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_delete_IplConvKernelFP_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} IplConvKernelFP::~IplConvKernelFP (@var{self})\n\ +@var{self} is of type . \n\ +@end deftypefn"; +const char* _wrap_new_IplConvKernelFP_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = IplConvKernelFP::IplConvKernelFP ()\n\ +@var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CV_16UC_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_16UC (@var{n})\n\ +@var{n} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_rend_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = rend (@var{self})\n\ +@var{self} is of type CvPointVector. @var{retval} is of type const_reverse_iterator. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_rend_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = rend (@var{self})\n\ +@var{self} is of type FloatVector. @var{retval} is of type const_reverse_iterator. \n\ +@end deftypefn"; +const char* _wrap_cvMatchTemplate_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMatchTemplate (@var{image}, @var{templ}, @var{result}, @var{method})\n\ +@var{image} is of type CvArr. @var{templ} is of type CvArr. @var{result} is of type CvArr. @var{method} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSetRemove_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetRemove (@var{set_header}, @var{index})\n\ +@var{set_header} is of type CvSet. @var{index} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvLSHRemove_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvLSHRemove (@var{lsh}, @var{indices})\n\ +@var{lsh} is of type CvLSH. @var{indices} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_get_allocator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = get_allocator (@var{self})\n\ +@var{self} is of type CvPointVector. @var{retval} is of type allocator_type. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_get_allocator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = get_allocator (@var{self})\n\ +@var{self} is of type FloatVector. @var{retval} is of type allocator_type. \n\ +@end deftypefn"; +const char* _wrap_cvTriangleArea_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvTriangleArea (@var{a}, @var{b}, @var{c})\n\ +@var{a} is of type CvPoint2D32f. @var{b} is of type CvPoint2D32f. @var{c} is of type CvPoint2D32f. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvEllipse_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvEllipse (@var{img}, @var{center}, @var{axes}, @var{angle}, @var{start_angle}, @var{end_angle}, @var{color}, @var{thickness} = 1, @var{line_type} = 8, @var{shift} = 0)\n\ +@var{img} is of type CvArr. @var{center} is of type CvPoint. @var{axes} is of type CvSize. @var{angle} is of type double. @var{start_angle} is of type double. @var{end_angle} is of type double. @var{color} is of type CvScalar. @var{thickness} is of type int. @var{line_type} is of type int. @var{shift} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_erase_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = erase (@var{self}, @var{first}, @var{last})\n\ +@var{self} is of type CvPointVector. @var{first} is of type iterator. @var{last} is of type iterator. @var{retval} is of type iterator. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_erase_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = erase (@var{self}, @var{first}, @var{last})\n\ +@var{self} is of type FloatVector. @var{first} is of type iterator. @var{last} is of type iterator. @var{retval} is of type iterator. \n\ +@end deftypefn"; +const char* _wrap_cvCopyHist_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCopyHist (@var{src}, @var{dst})\n\ +@var{src} is of type CvHistogram. @var{dst} is of type CvHistogram. \n\ +@end deftypefn"; +const char* _wrap_cvInitUndistortRectifyMap_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvInitUndistortRectifyMap (@var{camera_matrix}, @var{dist_coeffs}, @var{R}, @var{new_camera_matrix}, @var{mapx}, @var{mapy})\n\ +@var{camera_matrix} is of type CvMat. @var{dist_coeffs} is of type CvMat. @var{R} is of type CvMat. @var{new_camera_matrix} is of type CvMat. @var{mapx} is of type CvArr. @var{mapy} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvImage_coi_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = coi (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_IS_STRING_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_IS_STRING (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_ARE_TYPES_EQ_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_ARE_TYPES_EQ (@var{mat1}, @var{mat2})\n\ +@var{mat1} is of type CvMat. @var{mat2} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvInvSqrt_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvInvSqrt (@var{value})\n\ +@var{value} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvRound_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRound (@var{value})\n\ +@var{value} is of type double. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvWriteInt_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvWriteInt (@var{fs}, @var{name}, @var{value})\n\ +@var{fs} is of type CvFileStorage. @var{name} is of type char. @var{value} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCanny_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCanny (@var{image}, @var{edges}, @var{threshold1}, @var{threshold2}, @var{aperture_size} = 3)\n\ +@var{image} is of type CvArr. @var{edges} is of type CvArr. @var{threshold1} is of type double. @var{threshold2} is of type double. @var{aperture_size} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvImage_attach_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} attach (@var{self}, @var{img})\n\ +@var{self} is of type CvImage. @var{img} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_pop_back_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} pop_back (@var{self})\n\ +@var{self} is of type CvPointVector. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_pop_back_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} pop_back (@var{self})\n\ +@var{self} is of type FloatVector. \n\ +@end deftypefn"; +const char* _wrap_cvGetCols_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetCols (@var{arr}, @var{submat}, @var{start_col}, @var{end_col})\n\ +@var{arr} is of type CvArr. @var{submat} is of type CvMat. @var{start_col} is of type int. @var{end_col} is of type int. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_CvImage_roi_row_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = roi_row (@var{self}, @var{y})\n\ +@var{self} is of type CvImage. @var{y} is of type int. @var{retval} is of type uchar. \n\ +@end deftypefn"; +const char* _wrap_cvReadRawData_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReadRawData (@var{fs}, @var{src}, @var{dst}, @var{dt})\n\ +@var{fs} is of type CvFileStorage. @var{src} is of type CvFileNode. @var{dst} is of type void. @var{dt} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvStartReadRawData_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvStartReadRawData (@var{fs}, @var{src}, @var{reader})\n\ +@var{fs} is of type CvFileStorage. @var{src} is of type CvFileNode. @var{reader} is of type CvSeqReader. \n\ +@end deftypefn"; +const char* _wrap_cvWriteRawData_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvWriteRawData (@var{fs}, @var{src}, @var{len}, @var{dt})\n\ +@var{fs} is of type CvFileStorage. @var{src} is of type void. @var{len} is of type int. @var{dt} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvGetRawData_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvGetRawData (@var{arr}, @var{data}, @var{step} = nil, @var{roi_size} = nil)\n\ +@var{arr} is of type CvArr. @var{data} is of type uchar. @var{step} is of type int. @var{roi_size} is of type CvSize. \n\ +@end deftypefn"; +const char* _wrap_cvScalarToRawData_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvScalarToRawData (@var{scalar}, @var{data}, @var{type}, @var{extend_to_12} = 0)\n\ +@var{scalar} is of type CvScalar. @var{data} is of type void. @var{type} is of type int. @var{extend_to_12} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvImage_save_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} save (@var{self}, @var{filename}, @var{imgname})\n\ +@var{self} is of type CvImage. @var{filename} is of type char. @var{imgname} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvContourArea_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvContourArea (@var{contour}, @var{slice} = cvSlice(0, 0x3fffffff))\n\ +@var{contour} is of type CvArr. @var{slice} is of type CvSlice. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_push_back_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} push_back (@var{self}, @var{x})\n\ +@var{self} is of type CvPointVector. @var{x} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_push_back_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} push_back (@var{self}, @var{x})\n\ +@var{self} is of type FloatVector. @var{x} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_cvMatchShapes_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvMatchShapes (@var{object1}, @var{object2}, @var{method}, @var{parameter} = 0)\n\ +@var{object1} is of type void. @var{object2} is of type void. @var{method} is of type int. @var{parameter} is of type double. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvComposeRT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvComposeRT (@var{_rvec1}, @var{_tvec1}, @var{_rvec2}, @var{_tvec2}, @var{_rvec3}, @var{_tvec3}, @var{dr3dr1} = 0, @var{dr3dt1} = 0, @var{dr3dr2} = 0, @var{dr3dt2} = 0, @var{dt3dr1} = 0, @var{dt3dt1} = 0, @var{dt3dr2} = 0, @var{dt3dt2} = 0)\n\ +@var{_rvec1} is of type CvMat. @var{_tvec1} is of type CvMat. @var{_rvec2} is of type CvMat. @var{_tvec2} is of type CvMat. @var{_rvec3} is of type CvMat. @var{_tvec3} is of type CvMat. @var{dr3dr1} is of type CvMat. @var{dr3dt1} is of type CvMat. @var{dr3dr2} is of type CvMat. @var{dr3dt2} is of type CvMat. @var{dt3dr1} is of type CvMat. @var{dt3dt1} is of type CvMat. @var{dt3dr2} is of type CvMat. @var{dt3dt2} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvFindType_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFindType (@var{type_name})\n\ +@var{type_name} is of type char. @var{retval} is of type CvTypeInfo. \n\ +@end deftypefn"; +const char* _wrap_cvContourPerimeter_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvContourPerimeter_Shadow (@var{arr})\n\ +@var{arr} is of type CvArr. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvAbsDiffS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvAbsDiffS (@var{src}, @var{dst}, @var{value})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{value} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvCorrectMatches_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCorrectMatches (@var{F}, @var{points1}, @var{points2}, @var{new_points1}, @var{new_points2})\n\ +@var{F} is of type CvMat. @var{points1} is of type CvMat. @var{points2} is of type CvMat. @var{new_points1} is of type CvMat. @var{new_points2} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_POLYLINE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_POLYLINE (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_resize_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} resize (@var{self}, @var{new_size}, @var{x})\n\ +@var{self} is of type CvPointVector. @var{new_size} is of type size_type. @var{x} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_resize_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} resize (@var{self}, @var{new_size}, @var{x})\n\ +@var{self} is of type FloatVector. @var{new_size} is of type size_type. @var{x} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_cvResize_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvResize (@var{src}, @var{dst}, @var{interpolation} = 1)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{interpolation} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGoodFeaturesToTrack_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvGoodFeaturesToTrack (@var{image}, @var{eig_image}, @var{temp_image}, @var{corners}, @var{quality_level}, @var{min_distance}, @var{mask} = nil, @var{block_size} = 3, @var{use_harris} = 0, @var{k} = 0.04)\n\ +@var{image} is of type CvArr. @var{eig_image} is of type CvArr. @var{temp_image} is of type CvArr. @var{corners} is of type CvPoint2D32f. @var{quality_level} is of type double. @var{min_distance} is of type double. @var{mask} is of type CvArr. @var{block_size} is of type int. @var{use_harris} is of type int. @var{k} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvFitEllipse2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFitEllipse2 (@var{points})\n\ +@var{points} is of type CvArr. @var{retval} is of type CvBox2D. \n\ +@end deftypefn"; +const char* _wrap_CV_PREV_POINT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_PREV_POINT (@var{reader})\n\ +@var{reader} is of type CvSeqReader. @var{retval} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CV_CURRENT_POINT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_CURRENT_POINT (@var{reader})\n\ +@var{reader} is of type CvSeqReader. @var{retval} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CV_READ_CHAIN_POINT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CV_READ_CHAIN_POINT (@var{_pt}, @var{reader})\n\ +@var{_pt} is of type CvPoint. @var{reader} is of type CvChainPtReader. \n\ +@end deftypefn"; +const char* _wrap_cvFlushSeqWriter_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFlushSeqWriter (@var{writer})\n\ +@var{writer} is of type CvSeqWriter. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSeqWriter_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSeqWriter::~CvSeqWriter (@var{self})\n\ +@var{self} is of type CvSeqWriter. \n\ +@end deftypefn"; +const char* _wrap_new_CvSeqWriter_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSeqWriter::CvSeqWriter ()\n\ +@var{retval} is of type CvSeqWriter. \n\ +@end deftypefn"; +const char* _wrap_cvNot_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvNot (@var{src}, @var{dst})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvGetOptimalDFTSize_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetOptimalDFTSize (@var{size0})\n\ +@var{size0} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetSize_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetSize (@var{arr})\n\ +@var{arr} is of type CvArr. @var{retval} is of type CvSize. \n\ +@end deftypefn"; +const char* _wrap_cvSeqSort_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSeqSort (@var{seq}, @var{func}, @var{userdata} = nil)\n\ +@var{seq} is of type CvSeq. @var{func} is of type CvCmpFunc. @var{userdata} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvCvtColor_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCvtColor (@var{src}, @var{dst}, @var{code})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{code} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCornerMinEigenVal_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCornerMinEigenVal (@var{image}, @var{eigenval}, @var{block_size}, @var{aperture_size} = 3)\n\ +@var{image} is of type CvArr. @var{eigenval} is of type CvArr. @var{block_size} is of type int. @var{aperture_size} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint_2_pop_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = pop (@var{self})\n\ +@var{self} is of type CvSeq_CvPoint_2. @var{retval} is of type CvTuple_CvPoint_2. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_2_pop_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = pop (@var{self})\n\ +@var{self} is of type CvSeq_float_2. @var{retval} is of type CvTuple_float_2. \n\ +@end deftypefn"; +const char* _wrap_cvPyrUp_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvPyrUp (@var{src}, @var{dst}, @var{filter} = CV_GAUSSIAN_5x5)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{filter} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCalcOpticalFlowPyrLK_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcOpticalFlowPyrLK (@var{prev}, @var{curr}, @var{prev_pyr}, @var{curr_pyr}, @var{prev_features}, @var{curr_features}, @var{win_size}, @var{level}, @var{status}, @var{track_error}, @var{criteria}, @var{flags})\n\ +@var{prev} is of type CvArr. @var{curr} is of type CvArr. @var{prev_pyr} is of type CvArr. @var{curr_pyr} is of type CvArr. @var{prev_features} is of type CvPoint2D32f. @var{curr_features} is of type CvPoint2D32f. @var{win_size} is of type CvSize. @var{level} is of type int. @var{status} is of type char. @var{track_error} is of type float. @var{criteria} is of type CvTermCriteria. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCalcAffineFlowPyrLK_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcAffineFlowPyrLK (@var{prev}, @var{curr}, @var{prev_pyr}, @var{curr_pyr}, @var{prev_features}, @var{curr_features}, @var{matrices}, @var{count}, @var{win_size}, @var{level}, @var{status}, @var{track_error}, @var{criteria}, @var{flags})\n\ +@var{prev} is of type CvArr. @var{curr} is of type CvArr. @var{prev_pyr} is of type CvArr. @var{curr_pyr} is of type CvArr. @var{prev_features} is of type CvPoint2D32f. @var{curr_features} is of type CvPoint2D32f. @var{matrices} is of type float. @var{count} is of type int. @var{win_size} is of type CvSize. @var{level} is of type int. @var{status} is of type char. @var{track_error} is of type float. @var{criteria} is of type CvTermCriteria. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_channels_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = channels (@var{self})\n\ +@var{self} is of type CvMatrix. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvImage_channels_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = channels (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvMixChannels_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMixChannels (@var{src}, @var{src_count}, @var{dst}, @var{dst_count}, @var{from_to}, @var{pair_count})\n\ +@var{src} is of type CvArr. @var{src_count} is of type int. @var{dst} is of type CvArr. @var{dst_count} is of type int. @var{from_to} is of type int. @var{pair_count} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvLinearPolar_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvLinearPolar (@var{src}, @var{dst}, @var{center}, @var{maxRadius}, @var{flags} = 1+8)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{center} is of type CvPoint2D32f. @var{maxRadius} is of type double. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_write_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} write (@var{self}, @var{fs}, @var{matname})\n\ +@var{self} is of type CvMatrix. @var{fs} is of type CvFileStorage. @var{matname} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvCalcOpticalFlowBM_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcOpticalFlowBM (@var{prev}, @var{curr}, @var{block_size}, @var{shift_size}, @var{max_range}, @var{use_previous}, @var{velx}, @var{vely})\n\ +@var{prev} is of type CvArr. @var{curr} is of type CvArr. @var{block_size} is of type CvSize. @var{shift_size} is of type CvSize. @var{max_range} is of type CvSize. @var{use_previous} is of type int. @var{velx} is of type CvArr. @var{vely} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvCloneGraph_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCloneGraph (@var{graph}, @var{storage})\n\ +@var{graph} is of type CvGraph. @var{storage} is of type CvMemStorage. @var{retval} is of type CvGraph. \n\ +@end deftypefn"; +const char* _wrap_cvCreateGraph_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateGraph (@var{graph_flags}, @var{header_size}, @var{vtx_size}, @var{edge_size}, @var{storage})\n\ +@var{graph_flags} is of type int. @var{header_size} is of type int. @var{vtx_size} is of type int. @var{edge_size} is of type int. @var{storage} is of type CvMemStorage. @var{retval} is of type CvGraph. \n\ +@end deftypefn"; +const char* _wrap_cvAttrValue_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvAttrValue (@var{attr}, @var{attr_name})\n\ +@var{attr} is of type CvAttrList. @var{attr_name} is of type char. @var{retval} is of type char. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_clone_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = clone (@var{self})\n\ +@var{self} is of type CvMatrix. @var{retval} is of type CvMatrix. \n\ +@end deftypefn"; +const char* _wrap_cvSeqPop_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSeqPop (@var{seq}, @var{element} = nil)\n\ +@var{seq} is of type CvSeq. @var{element} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvSegmentMotion_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSegmentMotion_Shadow (@var{mhi}, @var{seg_mask}, @var{storage}, @var{timestamp}, @var{seg_thresh})\n\ +@var{mhi} is of type CvArr. @var{seg_mask} is of type CvArr. @var{storage} is of type CvMemStorage. @var{timestamp} is of type double. @var{seg_thresh} is of type double. @var{retval} is of type CvSeq_CvConnectedComp. \n\ +@end deftypefn"; +const char* _wrap_cvFastArctan_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFastArctan (@var{y}, @var{x})\n\ +@var{y} is of type float. @var{x} is of type float. @var{retval} is of type float. \n\ +@end deftypefn"; +const char* _wrap_IplImage___rne___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rne__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvMat___rne___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rne__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_VAL_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_VAL (@var{mat}, @var{node})\n\ +@var{mat} is of type CvSparseMat. @var{node} is of type CvSparseNode. @var{retval} is of type void. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_MASK_ARR_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_MASK_ARR (@var{mat})\n\ +@var{mat} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCornerHarris_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCornerHarris (@var{image}, @var{harris_responce}, @var{block_size}, @var{aperture_size} = 3, @var{k} = 0.04)\n\ +@var{image} is of type CvArr. @var{harris_responce} is of type CvArr. @var{block_size} is of type int. @var{aperture_size} is of type int. @var{k} is of type double. \n\ +@end deftypefn"; +const char* _wrap_CvImage_detach_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} detach (@var{self})\n\ +@var{self} is of type CvImage. \n\ +@end deftypefn"; +const char* _wrap_cvGetTickFrequency_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetTickFrequency ()\n\ +@var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_IplImage___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{object}, @var{arr})\n\ +@var{self} is of type . @var{object} is of type octave_value. @var{arr} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvMat___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{object}, @var{arr})\n\ +@var{self} is of type CvMat. @var{object} is of type octave_value. @var{arr} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvTuple_CvPoint_2___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvTuple_CvPoint_2. @var{i} is of type int. @var{obj} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CvTuple_float_2___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvTuple_float_2. @var{i} is of type int. @var{obj} is of type float. \n\ +@end deftypefn"; +const char* _wrap_CvTuple_float_3___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvTuple_float_3. @var{i} is of type int. @var{obj} is of type float. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvPoint. @var{i} is of type int. @var{obj} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint2D32f___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvPoint2D32f. @var{i} is of type int. @var{obj} is of type CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvRect___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvRect. @var{i} is of type int. @var{obj} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvSeq___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvSeq. @var{i} is of type int. @var{obj} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvQuadEdge2D___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvQuadEdge2D. @var{i} is of type int. @var{obj} is of type CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvConnectedComp___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvConnectedComp. @var{i} is of type int. @var{obj} is of type CvConnectedComp. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint_2___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvPoint_2. @var{i} is of type int. @var{obj} is of type CvTuple_CvPoint_2. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_2___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_float_2. @var{i} is of type int. @var{obj} is of type CvTuple_float_2. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_3___paren_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_float_3. @var{i} is of type int. @var{obj} is of type CvTuple_float_3. \n\ +@end deftypefn"; +const char* _wrap_IplImage___ge___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator >= (@var{self}, @var{val})\n\ +@var{self} is of type . @var{val} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMat___ge___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator >= (@var{self}, @var{val})\n\ +@var{self} is of type CvMat. @var{val} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_POINT_SET_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_POINT_SET (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_IS_INT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_IS_INT (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvFloodFill_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFloodFill (@var{image}, @var{seed_point}, @var{new_val}, @var{lo_diff} = cvScalarAll(0), @var{up_diff} = cvScalarAll(0), @var{comp} = nil, @var{flags} = 4, @var{mask} = nil)\n\ +@var{image} is of type CvArr. @var{seed_point} is of type CvPoint. @var{new_val} is of type CvScalar. @var{lo_diff} is of type CvScalar. @var{up_diff} is of type CvScalar. @var{comp} is of type CvConnectedComp. @var{flags} is of type int. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_CONVEX_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_CONVEX (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSeqPartition_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSeqPartition (@var{seq}, @var{storage}, @var{labels}, @var{is_equal}, @var{userdata})\n\ +@var{seq} is of type CvSeq. @var{storage} is of type CvMemStorage. @var{labels} is of type CvSeq. @var{is_equal} is of type CvCmpFunc. @var{userdata} is of type void. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SPARSE_MAT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SPARSE_MAT (@var{mat})\n\ +@var{mat} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSeqSearch_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSeqSearch (@var{seq}, @var{elem}, @var{func}, @var{is_sorted}, @var{elem_idx}, @var{userdata} = nil)\n\ +@var{seq} is of type CvSeq. @var{elem} is of type void. @var{func} is of type CvCmpFunc. @var{is_sorted} is of type int. @var{elem_idx} is of type int. @var{userdata} is of type void. @var{retval} is of type schar. \n\ +@end deftypefn"; +const char* _wrap_CV_32SC_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_32SC (@var{n})\n\ +@var{n} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_NEXT_LINE_POINT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CV_NEXT_LINE_POINT (@var{line_iterator})\n\ +@var{line_iterator} is of type CvLineIterator. \n\ +@end deftypefn"; +const char* _wrap_cvCreateHist_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateHist (@var{dims}, @var{type}, @var{ranges} = nil, @var{uniform} = 1)\n\ +@var{dims} is of type int. @var{type} is of type int. @var{ranges} is of type float. @var{uniform} is of type int. @var{retval} is of type CvHistogram. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SUBDIV2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SUBDIV2D (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_new_CvStarKeypoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvStarKeypoint::CvStarKeypoint ()\n\ +@var{retval} is of type CvStarKeypoint. \n\ +@end deftypefn"; +const char* _wrap_delete_CvStarKeypoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvStarKeypoint::~CvStarKeypoint (@var{self})\n\ +@var{self} is of type CvStarKeypoint. \n\ +@end deftypefn"; +const char* _wrap_cvStarKeypoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvStarKeypoint (@var{pt}, @var{size}, @var{response})\n\ +@var{pt} is of type CvPoint. @var{size} is of type int. @var{response} is of type float. @var{retval} is of type CvStarKeypoint. \n\ +@end deftypefn"; +const char* _wrap_cvPreCornerDetect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvPreCornerDetect (@var{image}, @var{corners}, @var{aperture_size} = 3)\n\ +@var{image} is of type CvArr. @var{corners} is of type CvArr. @var{aperture_size} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvRandShuffle_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvRandShuffle (@var{mat}, @var{rng}, @var{iter_factor} = 1.)\n\ +@var{mat} is of type CvArr. @var{rng} is of type CvRNG. @var{iter_factor} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvSolveCubic_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSolveCubic (@var{coeffs}, @var{roots})\n\ +@var{coeffs} is of type CvMat. @var{roots} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvImage_asIplImage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator IplImage* (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_delete_IplImage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} IplImage (@var{self})\n\ +@var{self} is of type . \n\ +@end deftypefn"; +const char* _wrap_new_CvPoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvPoint::CvPoint ()\n\ +@var{retval} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_delete_CvPoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvPoint::~CvPoint (@var{self})\n\ +@var{self} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_cvPoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPoint (@var{x}, @var{y})\n\ +@var{x} is of type int. @var{y} is of type int. @var{retval} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_new_CvSeq_CvPoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvPoint)>::CvTypedSeq<(CvPoint)> ()\n\ +@var{retval} is of type CvSeq_CvPoint. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSeq_CvPoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTypedSeq<(CvPoint)>::~CvTypedSeq<(CvPoint)> (@var{self})\n\ +@var{self} is of type CvSeq_CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_HOLE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_HOLE (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvWriteComment_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvWriteComment (@var{fs}, @var{comment}, @var{eol_comment})\n\ +@var{fs} is of type CvFileStorage. @var{comment} is of type char. @var{eol_comment} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvImage_write_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} write (@var{self}, @var{fs}, @var{imgname})\n\ +@var{self} is of type CvImage. @var{fs} is of type CvFileStorage. @var{imgname} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvEllipseBox_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvEllipseBox (@var{img}, @var{box}, @var{color}, @var{thickness} = 1, @var{line_type} = 8, @var{shift} = 0)\n\ +@var{img} is of type CvArr. @var{box} is of type CvBox2D. @var{color} is of type CvScalar. @var{thickness} is of type int. @var{line_type} is of type int. @var{shift} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvReadChainPoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvReadChainPoint (@var{reader})\n\ +@var{reader} is of type CvChainPtReader. @var{retval} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_cvMinEnclosingCircle_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvMinEnclosingCircle (@var{points}, @var{center})\n\ +@var{points} is of type CvArr. @var{center} is of type CvPoint2D32f. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGraphGetEdgeCount_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGraphGetEdgeCount (@var{graph})\n\ +@var{graph} is of type CvGraph. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvPolarToCart_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvPolarToCart (@var{magnitude}, @var{angle}, @var{x}, @var{y}, @var{angle_in_degrees} = 0)\n\ +@var{magnitude} is of type CvArr. @var{angle} is of type CvArr. @var{x} is of type CvArr. @var{y} is of type CvArr. @var{angle_in_degrees} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvPyrMeanShiftFiltering_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvPyrMeanShiftFiltering (@var{src}, @var{dst}, @var{sp}, @var{sr}, @var{max_level} = 1, @var{termcrit} = cvTermCriteria(1 +2,5,1))\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{sp} is of type double. @var{sr} is of type double. @var{max_level} is of type int. @var{termcrit} is of type CvTermCriteria. \n\ +@end deftypefn"; +const char* _wrap_CvImage_clone_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = clone (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type CvImage. \n\ +@end deftypefn"; +const char* _wrap_CV_INIT_3X3_DELTAS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CV_INIT_3X3_DELTAS (@var{deltas}, @var{step}, @var{nch})\n\ +@var{deltas} is of type double. @var{step} is of type int. @var{nch} is of type int. \n\ +@end deftypefn"; +const char* _wrap_IplImage___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{object})\n\ +@var{self} is of type . @var{object} is of type octave_value. @var{retval} is of type octave_value. \n\ +@end deftypefn"; +const char* _wrap_CvMat___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{object})\n\ +@var{self} is of type CvMat. @var{object} is of type octave_value. @var{retval} is of type octave_value. \n\ +@end deftypefn"; +const char* _wrap_CvTuple_CvPoint_2___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{i})\n\ +@var{self} is of type CvTuple_CvPoint_2. @var{i} is of type int. @var{retval} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CvTuple_float_2___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{i})\n\ +@var{self} is of type CvTuple_float_2. @var{i} is of type int. @var{retval} is of type float. \n\ +@end deftypefn"; +const char* _wrap_CvTuple_float_3___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{i})\n\ +@var{self} is of type CvTuple_float_3. @var{i} is of type int. @var{retval} is of type float. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvPoint. @var{i} is of type int. @var{retval} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint2D32f___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvPoint2D32f. @var{i} is of type int. @var{retval} is of type CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvRect___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvRect. @var{i} is of type int. @var{retval} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvSeq___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvSeq. @var{i} is of type int. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvQuadEdge2D___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvQuadEdge2D. @var{i} is of type int. @var{retval} is of type CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvConnectedComp___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvConnectedComp. @var{i} is of type int. @var{retval} is of type CvConnectedComp. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint_2___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvPoint_2. @var{i} is of type int. @var{retval} is of type CvTuple_CvPoint_2. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_2___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_float_2. @var{i} is of type int. @var{retval} is of type CvTuple_float_2. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_3___paren_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_float_3. @var{i} is of type int. @var{retval} is of type CvTuple_float_3. \n\ +@end deftypefn"; +const char* _wrap_cvSeqPopMulti_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSeqPopMulti (@var{seq}, @var{elements}, @var{count}, @var{in_front} = 0)\n\ +@var{seq} is of type CvSeq. @var{elements} is of type void. @var{count} is of type int. @var{in_front} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvMakeSeqHeaderForArray_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvMakeSeqHeaderForArray (@var{seq_type}, @var{header_size}, @var{elem_size}, @var{elements}, @var{total}, @var{seq}, @var{block})\n\ +@var{seq_type} is of type int. @var{header_size} is of type int. @var{elem_size} is of type int. @var{elements} is of type void. @var{total} is of type int. @var{seq} is of type CvSeq. @var{block} is of type CvSeqBlock. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvMakeHistHeaderForArray_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvMakeHistHeaderForArray (@var{dims}, @var{hist}, @var{data}, @var{ranges} = nil, @var{uniform} = 1)\n\ +@var{dims} is of type int. @var{hist} is of type CvHistogram. @var{data} is of type float. @var{ranges} is of type float. @var{uniform} is of type int. @var{retval} is of type CvHistogram. \n\ +@end deftypefn"; +const char* _wrap_new_CvSURFPoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSURFPoint::CvSURFPoint ()\n\ +@var{retval} is of type CvSURFPoint. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSURFPoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSURFPoint::~CvSURFPoint (@var{self})\n\ +@var{self} is of type CvSURFPoint. \n\ +@end deftypefn"; +const char* _wrap_cvSURFPoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSURFPoint (@var{pt}, @var{laplacian}, @var{size}, @var{dir} = 0, @var{hessian} = 0)\n\ +@var{pt} is of type CvPoint2D32f. @var{laplacian} is of type int. @var{size} is of type int. @var{dir} is of type float. @var{hessian} is of type float. @var{retval} is of type CvSURFPoint. \n\ +@end deftypefn"; +const char* _wrap_CvImage_roi_size_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = roi_size (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type CvSize. \n\ +@end deftypefn"; +const char* _wrap_cvXorS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvXorS (@var{src}, @var{value}, @var{dst}, @var{mask} = nil)\n\ +@var{src} is of type CvArr. @var{value} is of type CvScalar. @var{dst} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_MAT_CONST_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_MAT_CONST (@var{mat})\n\ +@var{mat} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_new_CvSize2D32f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSize2D32f::CvSize2D32f ()\n\ +@var{retval} is of type CvSize2D32f. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSize2D32f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSize2D32f::~CvSize2D32f (@var{self})\n\ +@var{self} is of type CvSize2D32f. \n\ +@end deftypefn"; +const char* _wrap_cvSize2D32f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSize2D32f (@var{width}, @var{height})\n\ +@var{width} is of type double. @var{height} is of type double. @var{retval} is of type CvSize2D32f. \n\ +@end deftypefn"; +const char* _wrap_cvAttrList_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvAttrList ()\n\ +@var{retval} is of type CvAttrList. \n\ +@end deftypefn"; +const char* _wrap_delete_CvAttrList_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvAttrList::~CvAttrList (@var{self})\n\ +@var{self} is of type CvAttrList. \n\ +@end deftypefn"; +const char* _wrap_new_CvAttrList_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvAttrList::CvAttrList ()\n\ +@var{retval} is of type CvAttrList. \n\ +@end deftypefn"; +const char* _wrap_CvImage_size_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = size (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type CvSize. \n\ +@end deftypefn"; +const char* _wrap_cvGet1D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGet1D (@var{arr}, @var{idx0})\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{retval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_CvImage_show_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} show (@var{self}, @var{window_name})\n\ +@var{self} is of type CvImage. @var{window_name} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvCloneSeq_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCloneSeq (@var{seq}, @var{storage} = nil)\n\ +@var{seq} is of type CvSeq. @var{storage} is of type CvMemStorage. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvSeqPushMulti_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSeqPushMulti (@var{seq}, @var{elements}, @var{count}, @var{in_front} = 0)\n\ +@var{seq} is of type CvSeq. @var{elements} is of type void. @var{count} is of type int. @var{in_front} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCopyMakeBorder_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCopyMakeBorder (@var{src}, @var{dst}, @var{offset}, @var{bordertype}, @var{value} = cvScalarAll(0))\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{offset} is of type CvPoint. @var{bordertype} is of type int. @var{value} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvMin_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMin (@var{src1}, @var{src2}, @var{dst})\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvGuiBoxReport_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGuiBoxReport (@var{status}, @var{func_name}, @var{err_msg}, @var{file_name}, @var{line}, @var{userdata})\n\ +@var{status} is of type int. @var{func_name} is of type char. @var{err_msg} is of type char. @var{file_name} is of type char. @var{line} is of type int. @var{userdata} is of type void. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvStdErrReport_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvStdErrReport (@var{status}, @var{func_name}, @var{err_msg}, @var{file_name}, @var{line}, @var{userdata})\n\ +@var{status} is of type int. @var{func_name} is of type char. @var{err_msg} is of type char. @var{file_name} is of type char. @var{line} is of type int. @var{userdata} is of type void. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvNulDevReport_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvNulDevReport (@var{status}, @var{func_name}, @var{err_msg}, @var{file_name}, @var{line}, @var{userdata})\n\ +@var{status} is of type int. @var{func_name} is of type char. @var{err_msg} is of type char. @var{file_name} is of type char. @var{line} is of type int. @var{userdata} is of type void. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCountNonZero_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCountNonZero (@var{arr})\n\ +@var{arr} is of type CvArr. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvSubdiv2DEdge_Wrapper_ptr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = ptr (@var{self})\n\ +@var{self} is of type CvSubdiv2DEdge_Wrapper. @var{retval} is of type CvSubdiv2DEdge. \n\ +@end deftypefn"; +const char* _wrap_CvRNG_Wrapper_ptr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = ptr (@var{self})\n\ +@var{self} is of type CvRNG_Wrapper. @var{retval} is of type CvRNG. \n\ +@end deftypefn"; +const char* _wrap_cvFindGraphEdge_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFindGraphEdge (@var{graph}, @var{start_idx}, @var{end_idx})\n\ +@var{graph} is of type CvGraph. @var{start_idx} is of type int. @var{end_idx} is of type int. @var{retval} is of type CvGraphEdge. \n\ +@end deftypefn"; +const char* _wrap_delete_CvGraphEdge_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvGraphEdge::~CvGraphEdge (@var{self})\n\ +@var{self} is of type CvGraphEdge. \n\ +@end deftypefn"; +const char* _wrap_new_CvGraphEdge_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvGraphEdge::CvGraphEdge ()\n\ +@var{retval} is of type CvGraphEdge. \n\ +@end deftypefn"; +const char* _wrap_cvConvertPointsHomogeneous_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvConvertPointsHomogeneous (@var{src}, @var{dst})\n\ +@var{src} is of type CvMat. @var{dst} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_new_CvStereoGCState_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvStereoGCState::CvStereoGCState ()\n\ +@var{retval} is of type CvStereoGCState. \n\ +@end deftypefn"; +const char* _wrap_delete_CvStereoGCState_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvStereoGCState::~CvStereoGCState (@var{self})\n\ +@var{self} is of type CvStereoGCState. \n\ +@end deftypefn"; +const char* _wrap_cvCreateStereoGCState_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateStereoGCState (@var{numberOfDisparities}, @var{maxIters})\n\ +@var{numberOfDisparities} is of type int. @var{maxIters} is of type int. @var{retval} is of type CvStereoGCState. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseStereoGCState_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseStereoGCState (@var{state})\n\ +@var{state} is of type CvStereoGCState. \n\ +@end deftypefn"; +const char* _wrap_cvGet2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGet2D (@var{arr}, @var{idx0}, @var{idx1})\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{idx1} is of type int. @var{retval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvSetND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetND (@var{arr}, @var{idx}, @var{value})\n\ +@var{arr} is of type CvArr. @var{idx} is of type int. @var{value} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_new_CvPoint2D64f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvPoint2D64f::CvPoint2D64f ()\n\ +@var{retval} is of type CvPoint2D64f. \n\ +@end deftypefn"; +const char* _wrap_delete_CvPoint2D64f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvPoint2D64f::~CvPoint2D64f (@var{self})\n\ +@var{self} is of type CvPoint2D64f. \n\ +@end deftypefn"; +const char* _wrap_cvPoint2D64f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPoint2D64f (@var{x}, @var{y})\n\ +@var{x} is of type double. @var{y} is of type double. @var{retval} is of type CvPoint2D64f. \n\ +@end deftypefn"; +const char* _wrap_cvClearHist_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvClearHist (@var{hist})\n\ +@var{hist} is of type CvHistogram. \n\ +@end deftypefn"; +const char* _wrap_cvFitLine_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFitLine (@var{points}, @var{dist_type}, @var{param}, @var{reps}, @var{aeps}, @var{line})\n\ +@var{points} is of type CvArr. @var{dist_type} is of type int. @var{param} is of type double. @var{reps} is of type double. @var{aeps} is of type double. @var{line} is of type float. \n\ +@end deftypefn"; +const char* _wrap_cvCalcMatMulDeriv_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcMatMulDeriv (@var{A}, @var{B}, @var{dABdA}, @var{dABdB})\n\ +@var{A} is of type CvMat. @var{B} is of type CvMat. @var{dABdA} is of type CvMat. @var{dABdB} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvCircle_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCircle (@var{img}, @var{center}, @var{radius}, @var{color}, @var{thickness} = 1, @var{line_type} = 8, @var{shift} = 0)\n\ +@var{img} is of type CvArr. @var{center} is of type CvPoint. @var{radius} is of type int. @var{color} is of type CvScalar. @var{thickness} is of type int. @var{line_type} is of type int. @var{shift} is of type int. \n\ +@end deftypefn"; +const char* _wrap_new_CvTuple_float_2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTuple<(float,2)>::CvTuple<(float,2)> ()\n\ +@var{retval} is of type CvTuple_float_2. \n\ +@end deftypefn"; +const char* _wrap_delete_CvTuple_float_2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTuple<(float,2)>::~CvTuple<(float,2)> (@var{self})\n\ +@var{self} is of type CvTuple_float_2. \n\ +@end deftypefn"; +const char* _wrap_new_CvSeq_float_2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvTuple<(float,2)>)>::CvTypedSeq<(CvTuple<(float,2)>)> ()\n\ +@var{retval} is of type CvSeq_float_2. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSeq_float_2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTypedSeq<(CvTuple<(float,2)>)>::~CvTypedSeq<(CvTuple<(float,2)>)> (@var{self})\n\ +@var{self} is of type CvSeq_float_2. \n\ +@end deftypefn"; +const char* _wrap_new_CvTuple_float_3_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTuple<(float,3)>::CvTuple<(float,3)> ()\n\ +@var{retval} is of type CvTuple_float_3. \n\ +@end deftypefn"; +const char* _wrap_delete_CvTuple_float_3_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTuple<(float,3)>::~CvTuple<(float,3)> (@var{self})\n\ +@var{self} is of type CvTuple_float_3. \n\ +@end deftypefn"; +const char* _wrap_new_CvSeq_float_3_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvTuple<(float,3)>)>::CvTypedSeq<(CvTuple<(float,3)>)> ()\n\ +@var{retval} is of type CvSeq_float_3. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSeq_float_3_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTypedSeq<(CvTuple<(float,3)>)>::~CvTypedSeq<(CvTuple<(float,3)>)> (@var{self})\n\ +@var{self} is of type CvSeq_float_3. \n\ +@end deftypefn"; +const char* _wrap_cvStereoCalibrate_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvStereoCalibrate (@var{object_points}, @var{image_points1}, @var{image_points2}, @var{npoints}, @var{camera_matrix1}, @var{dist_coeffs1}, @var{camera_matrix2}, @var{dist_coeffs2}, @var{image_size}, @var{R}, @var{T}, @var{E} = 0, @var{F} = 0, @var{term_crit} = cvTermCriteria( 1 +2,30,1e-6), @var{flags} = 256)\n\ +@var{object_points} is of type CvMat. @var{image_points1} is of type CvMat. @var{image_points2} is of type CvMat. @var{npoints} is of type CvMat. @var{camera_matrix1} is of type CvMat. @var{dist_coeffs1} is of type CvMat. @var{camera_matrix2} is of type CvMat. @var{dist_coeffs2} is of type CvMat. @var{image_size} is of type CvSize. @var{R} is of type CvMat. @var{T} is of type CvMat. @var{E} is of type CvMat. @var{F} is of type CvMat. @var{term_crit} is of type CvTermCriteria. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSetReal1D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetReal1D (@var{arr}, @var{idx0}, @var{value})\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{value} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvGetReal1D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetReal1D (@var{arr}, @var{idx0})\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvSVD_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSVD (@var{A}, @var{W}, @var{U} = nil, @var{V} = nil, @var{flags} = 0)\n\ +@var{A} is of type CvArr. @var{W} is of type CvArr. @var{U} is of type CvArr. @var{V} is of type CvArr. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_read_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = read (@var{self}, @var{fs}, @var{seqname}, @var{idx})\n\ +@var{self} is of type CvMatrix. @var{fs} is of type CvFileStorage. @var{seqname} is of type char. @var{idx} is of type int. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvConnectedComp_pop_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = pop (@var{self})\n\ +@var{self} is of type CvSeq_CvConnectedComp. @var{retval} is of type CvConnectedComp. \n\ +@end deftypefn"; +const char* _wrap_cvThreshHist_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvThreshHist (@var{hist}, @var{threshold})\n\ +@var{hist} is of type CvHistogram. @var{threshold} is of type double. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_CONTOUR_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_CONTOUR (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_CHAIN_CONTOUR_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_CHAIN_CONTOUR (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGet3D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGet3D (@var{arr}, @var{idx0}, @var{idx1}, @var{idx2})\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{idx1} is of type int. @var{idx2} is of type int. @var{retval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_delete_CvMatND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvMatND (@var{self})\n\ +@var{self} is of type CvMatND. \n\ +@end deftypefn"; +const char* _wrap_cvFindFeaturesBoxed_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFindFeaturesBoxed (@var{tr}, @var{bounds_min}, @var{bounds_max}, @var{out_indices})\n\ +@var{tr} is of type CvFeatureTree. @var{bounds_min} is of type CvMat. @var{bounds_max} is of type CvMat. @var{out_indices} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvImage_set_coi_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} set_coi (@var{self}, @var{coi})\n\ +@var{self} is of type CvImage. @var{coi} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvFillPoly_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFillPoly (@var{img}, @var{pts}, @var{npts}, @var{contours}, @var{color}, @var{line_type} = 8, @var{shift} = 0)\n\ +@var{img} is of type CvArr. @var{pts} is of type CvPoint. @var{npts} is of type int. @var{contours} is of type int. @var{color} is of type CvScalar. @var{line_type} is of type int. @var{shift} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvTypeOf_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvTypeOf (@var{struct_ptr})\n\ +@var{struct_ptr} is of type void. @var{retval} is of type CvTypeInfo. \n\ +@end deftypefn"; +const char* _wrap_cvPolyLine_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvPolyLine (@var{img}, @var{pts}, @var{npts}, @var{contours}, @var{is_closed}, @var{color}, @var{thickness} = 1, @var{line_type} = 8, @var{shift} = 0)\n\ +@var{img} is of type CvArr. @var{pts} is of type CvPoint. @var{npts} is of type int. @var{contours} is of type int. @var{is_closed} is of type int. @var{color} is of type CvScalar. @var{thickness} is of type int. @var{line_type} is of type int. @var{shift} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_append_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} append (@var{self}, @var{x})\n\ +@var{self} is of type CvPointVector. @var{x} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_append_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} append (@var{self}, @var{x})\n\ +@var{self} is of type FloatVector. @var{x} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint_append_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} append (@var{self}, @var{obj})\n\ +@var{self} is of type CvSeq_CvPoint. @var{obj} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint2D32f_append_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} append (@var{self}, @var{obj})\n\ +@var{self} is of type CvSeq_CvPoint2D32f. @var{obj} is of type CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvRect_append_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} append (@var{self}, @var{obj})\n\ +@var{self} is of type CvSeq_CvRect. @var{obj} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvSeq_append_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} append (@var{self}, @var{obj})\n\ +@var{self} is of type CvSeq_CvSeq. @var{obj} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvQuadEdge2D_append_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} append (@var{self}, @var{obj})\n\ +@var{self} is of type CvSeq_CvQuadEdge2D. @var{obj} is of type CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvConnectedComp_append_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} append (@var{self}, @var{obj})\n\ +@var{self} is of type CvSeq_CvConnectedComp. @var{obj} is of type CvConnectedComp. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint_2_append_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} append (@var{self}, @var{obj})\n\ +@var{self} is of type CvSeq_CvPoint_2. @var{obj} is of type CvTuple_CvPoint_2. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_2_append_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} append (@var{self}, @var{obj})\n\ +@var{self} is of type CvSeq_float_2. @var{obj} is of type CvTuple_float_2. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_3_append_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} append (@var{self}, @var{obj})\n\ +@var{self} is of type CvSeq_float_3. @var{obj} is of type CvTuple_float_3. \n\ +@end deftypefn"; +const char* _wrap_cvInitTreeNodeIterator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvInitTreeNodeIterator (@var{tree_iterator}, @var{first}, @var{max_level})\n\ +@var{tree_iterator} is of type CvTreeNodeIterator. @var{first} is of type void. @var{max_level} is of type int. \n\ +@end deftypefn"; +const char* _wrap_delete_CvTreeNodeIterator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTreeNodeIterator::~CvTreeNodeIterator (@var{self})\n\ +@var{self} is of type CvTreeNodeIterator. \n\ +@end deftypefn"; +const char* _wrap_new_CvTreeNodeIterator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTreeNodeIterator::CvTreeNodeIterator ()\n\ +@var{retval} is of type CvTreeNodeIterator. \n\ +@end deftypefn"; +const char* _wrap_cvInitLineIterator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvInitLineIterator (@var{image}, @var{pt1}, @var{pt2}, @var{line_iterator}, @var{connectivity} = 8, @var{left_to_right} = 0)\n\ +@var{image} is of type CvArr. @var{pt1} is of type CvPoint. @var{pt2} is of type CvPoint. @var{line_iterator} is of type CvLineIterator. @var{connectivity} is of type int. @var{left_to_right} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvInitNArrayIterator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvInitNArrayIterator (@var{count}, @var{arrs}, @var{mask}, @var{stubs}, @var{array_iterator}, @var{flags} = 0)\n\ +@var{count} is of type int. @var{arrs} is of type CvArr. @var{mask} is of type CvArr. @var{stubs} is of type CvMatND. @var{array_iterator} is of type CvNArrayIterator. @var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_delete_CvNArrayIterator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvNArrayIterator::~CvNArrayIterator (@var{self})\n\ +@var{self} is of type CvNArrayIterator. \n\ +@end deftypefn"; +const char* _wrap_new_CvNArrayIterator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvNArrayIterator::CvNArrayIterator ()\n\ +@var{retval} is of type CvNArrayIterator. \n\ +@end deftypefn"; +const char* _wrap_cvInitSparseMatIterator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvInitSparseMatIterator (@var{mat}, @var{mat_iterator})\n\ +@var{mat} is of type CvSparseMat. @var{mat_iterator} is of type CvSparseMatIterator. @var{retval} is of type CvSparseNode. \n\ +@end deftypefn"; +const char* _wrap_delete_OctSwigIterator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} swig::~OctSwigIterator (@var{self})\n\ +@var{self} is of type OctSwigIterator. \n\ +@end deftypefn"; +const char* _wrap_new_CvSparseMatIterator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSparseMatIterator::CvSparseMatIterator ()\n\ +@var{retval} is of type CvSparseMatIterator. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSparseMatIterator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSparseMatIterator::~CvSparseMatIterator (@var{self})\n\ +@var{self} is of type CvSparseMatIterator. \n\ +@end deftypefn"; +const char* _wrap_new_CvLineIterator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvLineIterator::CvLineIterator ()\n\ +@var{retval} is of type CvLineIterator. \n\ +@end deftypefn"; +const char* _wrap_delete_CvLineIterator_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvLineIterator::~CvLineIterator (@var{self})\n\ +@var{self} is of type CvLineIterator. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_IS_COLLECTION_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_IS_COLLECTION (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvFindStereoCorrespondenceBM_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFindStereoCorrespondenceBM (@var{left}, @var{right}, @var{disparity}, @var{state})\n\ +@var{left} is of type CvArr. @var{right} is of type CvArr. @var{disparity} is of type CvArr. @var{state} is of type CvStereoBMState. \n\ +@end deftypefn"; +const char* _wrap_cvFindNearestPoint2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFindNearestPoint2D (@var{subdiv}, @var{pt})\n\ +@var{subdiv} is of type CvSubdiv2D. @var{pt} is of type CvPoint2D32f. @var{retval} is of type CvSubdiv2DPoint. \n\ +@end deftypefn"; +const char* _wrap_cvSetReal2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetReal2D (@var{arr}, @var{idx0}, @var{idx1}, @var{value})\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{idx1} is of type int. @var{value} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvGetReal2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetReal2D (@var{arr}, @var{idx0}, @var{idx1})\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{idx1} is of type int. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvIsInf_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvIsInf (@var{value})\n\ +@var{value} is of type double. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_SEQ_ELTYPE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_SEQ_ELTYPE (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_end_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = end (@var{self})\n\ +@var{self} is of type CvPointVector. @var{retval} is of type const_iterator. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_end_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = end (@var{self})\n\ +@var{self} is of type FloatVector. @var{retval} is of type const_iterator. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_row_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = row (@var{self}, @var{i})\n\ +@var{self} is of type CvMatrix. @var{i} is of type int. @var{retval} is of type uchar. \n\ +@end deftypefn"; +const char* _wrap_delete_Cv32suf_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} Cv32suf::~Cv32suf (@var{self})\n\ +@var{self} is of type Cv32suf. \n\ +@end deftypefn"; +const char* _wrap_new_Cv32suf_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = Cv32suf::Cv32suf ()\n\ +@var{retval} is of type Cv32suf. \n\ +@end deftypefn"; +const char* _wrap_IplImage___rlt___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rlt__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvMat___rlt___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rlt__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvCalcBackProject_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcBackProject (@var{image}, @var{dst}, @var{hist})\n\ +@var{image} is of type . @var{dst} is of type CvArr. @var{hist} is of type CvHistogram. \n\ +@end deftypefn"; +const char* _wrap_cvCalcArrBackProject_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcArrBackProject (@var{image}, @var{dst}, @var{hist})\n\ +@var{image} is of type CvArr. @var{dst} is of type CvArr. @var{hist} is of type CvHistogram. \n\ +@end deftypefn"; +const char* _wrap_cvFilter2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFilter2D (@var{src}, @var{dst}, @var{kernel}, @var{anchor} = cvPoint(-1,-1))\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{kernel} is of type CvMat. @var{anchor} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint_pop_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = pop (@var{self})\n\ +@var{self} is of type CvSeq_CvPoint. @var{retval} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SET_ELEM_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SET_ELEM (@var{ptr})\n\ +@var{ptr} is of type void. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvPOSIT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvPOSIT (@var{posit_object}, @var{image_points}, @var{focal_length}, @var{criteria}, @var{rotation_matrix}, @var{translation_vector})\n\ +@var{posit_object} is of type CvPOSITObject. @var{image_points} is of type CvPoint2D32f. @var{focal_length} is of type double. @var{criteria} is of type CvTermCriteria. @var{rotation_matrix} is of type CvMatr32f. @var{translation_vector} is of type CvVect32f. \n\ +@end deftypefn"; +const char* _wrap_cvConvertScaleAbs_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvConvertScaleAbs (@var{src}, @var{dst}, @var{scale} = 1, @var{shift} = 0)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{scale} is of type double. @var{shift} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvCalcOpticalFlowHS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcOpticalFlowHS (@var{prev}, @var{curr}, @var{use_previous}, @var{velx}, @var{vely}, @var{lambda}, @var{criteria})\n\ +@var{prev} is of type CvArr. @var{curr} is of type CvArr. @var{use_previous} is of type int. @var{velx} is of type CvArr. @var{vely} is of type CvArr. @var{lambda} is of type double. @var{criteria} is of type CvTermCriteria. \n\ +@end deftypefn"; +const char* _wrap_cvMaxRect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvMaxRect (@var{rect1}, @var{rect2})\n\ +@var{rect1} is of type CvRect. @var{rect2} is of type CvRect. @var{retval} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_cvRANSACUpdateNumIters_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRANSACUpdateNumIters (@var{p}, @var{err_prob}, @var{model_points}, @var{max_iters})\n\ +@var{p} is of type double. @var{err_prob} is of type double. @var{model_points} is of type int. @var{max_iters} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_3_cast_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvTuple<(float,3)>)>::cast (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type CvSeq_float_3. \n\ +@end deftypefn"; +const char* _wrap_cvRepeat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvRepeat (@var{src}, @var{dst})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseLSH_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseLSH (@var{lsh})\n\ +@var{lsh} is of type CvLSH. \n\ +@end deftypefn"; +const char* _wrap_cvCalcSubdivVoronoi2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcSubdivVoronoi2D (@var{subdiv})\n\ +@var{subdiv} is of type CvSubdiv2D. \n\ +@end deftypefn"; +const char* _wrap_cvClearSubdivVoronoi2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvClearSubdivVoronoi2D (@var{subdiv})\n\ +@var{subdiv} is of type CvSubdiv2D. \n\ +@end deftypefn"; +const char* _wrap_cvApproxPoly_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvApproxPoly_Shadow (@var{src_seq}, @var{header_size}, @var{storage}, @var{method}, @var{parameter})\n\ +@var{src_seq} is of type void. @var{header_size} is of type int. @var{storage} is of type CvMemStorage. @var{method} is of type int. @var{parameter} is of type double. @var{retval} is of type CvSeq_CvPoint. \n\ +@end deftypefn"; +const char* _wrap_cvSetReal3D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetReal3D (@var{arr}, @var{idx0}, @var{idx1}, @var{idx2}, @var{value})\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{idx1} is of type int. @var{idx2} is of type int. @var{value} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvGetReal3D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetReal3D (@var{arr}, @var{idx0}, @var{idx1}, @var{idx2})\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{idx1} is of type int. @var{idx2} is of type int. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvAnd_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvAnd (@var{src1}, @var{src2}, @var{dst}, @var{mask} = nil)\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvError_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvError (@var{status}, @var{func_name}, @var{err_msg}, @var{file_name}, @var{line})\n\ +@var{status} is of type int. @var{func_name} is of type char. @var{err_msg} is of type char. @var{file_name} is of type char. @var{line} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSampleLine_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSampleLine (@var{image}, @var{pt1}, @var{pt2}, @var{buffer}, @var{connectivity} = 8)\n\ +@var{image} is of type CvArr. @var{pt1} is of type CvPoint. @var{pt2} is of type CvPoint. @var{buffer} is of type void. @var{connectivity} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvInitFont_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvInitFont (@var{font}, @var{hscale}, @var{vscale}, @var{shear} = 0, @var{thickness} = 1, @var{line_type} = 8)\n\ +@var{font} is of type CvFont. @var{hscale} is of type double. @var{vscale} is of type double. @var{shear} is of type double. @var{thickness} is of type int. @var{line_type} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_rows_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = rows (@var{self})\n\ +@var{self} is of type CvMatrix. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCheckContourConvexity_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCheckContourConvexity (@var{contour})\n\ +@var{contour} is of type CvArr. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvAbsDiff_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvAbsDiff (@var{src1}, @var{src2}, @var{dst})\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvMemStorageAlloc_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvMemStorageAlloc (@var{storage}, @var{size})\n\ +@var{storage} is of type CvMemStorage. @var{size} is of type size_t. @var{retval} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvConDensUpdateByTime_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvConDensUpdateByTime (@var{condens})\n\ +@var{condens} is of type CvConDensation. \n\ +@end deftypefn"; +const char* _wrap_new_CvTuple_CvPoint_2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTuple<(CvPoint,2)>::CvTuple<(CvPoint,2)> ()\n\ +@var{retval} is of type CvTuple_CvPoint_2. \n\ +@end deftypefn"; +const char* _wrap_delete_CvTuple_CvPoint_2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTuple<(CvPoint,2)>::~CvTuple<(CvPoint,2)> (@var{self})\n\ +@var{self} is of type CvTuple_CvPoint_2. \n\ +@end deftypefn"; +const char* _wrap_new_CvSeq_CvPoint_2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvTuple<(CvPoint,2)>)>::CvTypedSeq<(CvTuple<(CvPoint,2)>)> ()\n\ +@var{retval} is of type CvSeq_CvPoint_2. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSeq_CvPoint_2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTypedSeq<(CvTuple<(CvPoint,2)>)>::~CvTypedSeq<(CvTuple<(CvPoint,2)>)> (@var{self})\n\ +@var{self} is of type CvSeq_CvPoint_2. \n\ +@end deftypefn"; +const char* _wrap_delete_CvPluginFuncInfo_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvPluginFuncInfo::~CvPluginFuncInfo (@var{self})\n\ +@var{self} is of type CvPluginFuncInfo. \n\ +@end deftypefn"; +const char* _wrap_new_CvPluginFuncInfo_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvPluginFuncInfo::CvPluginFuncInfo ()\n\ +@var{retval} is of type CvPluginFuncInfo. \n\ +@end deftypefn"; +const char* _wrap_cvRNG_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRNG ()\n\ +@var{retval} is of type CvRNG. \n\ +@end deftypefn"; +const char* _wrap_CV_8SC_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_8SC (@var{n})\n\ +@var{n} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_load_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = load (@var{self}, @var{filename})\n\ +@var{self} is of type CvMatrix. @var{filename} is of type char. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_cvScaleAdd_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvScaleAdd (@var{src1}, @var{scale}, @var{src2}, @var{dst})\n\ +@var{src1} is of type CvArr. @var{scale} is of type CvScalar. @var{src2} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_IplImage___div___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator / (@var{self}, @var{val})\n\ +@var{self} is of type . @var{val} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMat___div___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator / (@var{self}, @var{val})\n\ +@var{self} is of type CvMat. @var{val} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvUndistort2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvUndistort2 (@var{src}, @var{dst}, @var{camera_matrix}, @var{distortion_coeffs})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{camera_matrix} is of type CvMat. @var{distortion_coeffs} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_clear_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} clear (@var{self})\n\ +@var{self} is of type CvMatrix. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_clear_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} clear (@var{self})\n\ +@var{self} is of type CvPointVector. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_clear_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} clear (@var{self})\n\ +@var{self} is of type FloatVector. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector___paren_asgn___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn__ (@var{self}, @var{i}, @var{x})\n\ +@var{self} is of type CvPointVector. @var{i} is of type difference_type. @var{x} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_FloatVector___paren_asgn___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __paren_asgn__ (@var{self}, @var{i}, @var{x})\n\ +@var{self} is of type FloatVector. @var{i} is of type difference_type. @var{x} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_cvReadReal_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvReadReal (@var{node}, @var{default_value} = 0.)\n\ +@var{node} is of type CvFileNode. @var{default_value} is of type double. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvStereoRectifyUncalibrated_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvStereoRectifyUncalibrated (@var{points1}, @var{points2}, @var{F}, @var{img_size}, @var{H1}, @var{H2}, @var{threshold} = 5)\n\ +@var{points1} is of type CvMat. @var{points2} is of type CvMat. @var{F} is of type CvMat. @var{img_size} is of type CvSize. @var{H1} is of type CvMat. @var{H2} is of type CvMat. @var{threshold} is of type double. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_delete_CvHistogram_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvHistogram (@var{self})\n\ +@var{self} is of type CvHistogram. \n\ +@end deftypefn"; +const char* _wrap_CV_READ_EDGE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CV_READ_EDGE (@var{pt1}, @var{pt2}, @var{reader})\n\ +@var{pt1} is of type CvPoint. @var{pt2} is of type CvPoint. @var{reader} is of type CvSeqReader. \n\ +@end deftypefn"; +const char* _wrap_cvCalibrationMatrixValues_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalibrationMatrixValues (@var{camera_matrix}, @var{image_size}, @var{aperture_width} = 0, @var{aperture_height} = 0, @var{fovx} = nil, @var{fovy} = nil, @var{focal_length} = nil, @var{principal_point} = nil, @var{pixel_aspect_ratio} = nil)\n\ +@var{camera_matrix} is of type CvMat. @var{image_size} is of type CvSize. @var{aperture_width} is of type double. @var{aperture_height} is of type double. @var{fovx} is of type double. @var{fovy} is of type double. @var{focal_length} is of type double. @var{principal_point} is of type CvPoint2D64f. @var{pixel_aspect_ratio} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvCartToPolar_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCartToPolar (@var{x}, @var{y}, @var{magnitude}, @var{angle} = nil, @var{angle_in_degrees} = 0)\n\ +@var{x} is of type CvArr. @var{y} is of type CvArr. @var{magnitude} is of type CvArr. @var{angle} is of type CvArr. @var{angle_in_degrees} is of type int. \n\ +@end deftypefn"; +const char* _wrap_new_CvType_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvType (@var{type_name}, @var{is_instance})\n\ +@var{type_name} is of type char. @var{is_instance} is of type CvIsInstanceFunc. @var{retval} is of type CvType. \n\ +@end deftypefn"; +const char* _wrap_delete_CvType_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvType (@var{self})\n\ +@var{self} is of type CvType. \n\ +@end deftypefn"; +const char* _wrap_cvDrawContours_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvDrawContours (@var{img}, @var{contour}, @var{external_color}, @var{hole_color}, @var{max_level}, @var{thickness} = 1, @var{line_type} = 8, @var{offset} = cvPoint(0,0))\n\ +@var{img} is of type CvArr. @var{contour} is of type CvSeq. @var{external_color} is of type CvScalar. @var{hole_color} is of type CvScalar. @var{max_level} is of type int. @var{thickness} is of type int. @var{line_type} is of type int. @var{offset} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_cvStartFindContours_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvStartFindContours (@var{image}, @var{storage}, @var{header_size} = sizeof(CvContour), @var{mode} = 1, @var{method} = 2, @var{offset} = cvPoint(0,0))\n\ +@var{image} is of type CvArr. @var{storage} is of type CvMemStorage. @var{header_size} is of type int. @var{mode} is of type int. @var{method} is of type int. @var{offset} is of type CvPoint. @var{retval} is of type CvContourScanner. \n\ +@end deftypefn"; +const char* _wrap_cvEndFindContours_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvEndFindContours (@var{scanner})\n\ +@var{scanner} is of type CvContourScanner. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_HIST_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_HIST (@var{hist})\n\ +@var{hist} is of type CvHistogram. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvScalarAll_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvScalarAll (@var{val0123})\n\ +@var{val0123} is of type double. @var{retval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvCalcMotionGradient_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcMotionGradient (@var{mhi}, @var{mask}, @var{orientation}, @var{delta1}, @var{delta2}, @var{aperture_size} = 3)\n\ +@var{mhi} is of type CvArr. @var{mask} is of type CvArr. @var{orientation} is of type CvArr. @var{delta1} is of type double. @var{delta2} is of type double. @var{aperture_size} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvAXPY_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvAXPY (@var{A}, @var{real_scalar}, @var{B}, @var{C})\n\ +@var{A} is of type CvArr. @var{real_scalar} is of type double. @var{B} is of type CvArr. @var{C} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvExtractMSER_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvExtractMSER (@var{_img}, @var{_mask}, @var{contours}, @var{storage}, @var{params})\n\ +@var{_img} is of type CvArr. @var{_mask} is of type CvArr. @var{contours} is of type CvSeq. @var{storage} is of type CvMemStorage. @var{params} is of type CvMSERParams. \n\ +@end deftypefn"; +const char* _wrap_cvRandInt_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRandInt (@var{rng})\n\ +@var{rng} is of type CvRNG. @var{retval} is of type unsigned int. \n\ +@end deftypefn"; +const char* _wrap_delete_CvConDensation_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvConDensation (@var{self})\n\ +@var{self} is of type CvConDensation. \n\ +@end deftypefn"; +const char* _wrap_cvCreateConDensation_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateConDensation (@var{dynam_params}, @var{measure_params}, @var{sample_count})\n\ +@var{dynam_params} is of type int. @var{measure_params} is of type int. @var{sample_count} is of type int. @var{retval} is of type CvConDensation. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseConDensation_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseConDensation (@var{condens})\n\ +@var{condens} is of type CvConDensation. \n\ +@end deftypefn"; +const char* _wrap_cvSqrt_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSqrt (@var{value})\n\ +@var{value} is of type double. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_IS_FLOW_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_IS_FLOW (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvDet_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvDet (@var{mat})\n\ +@var{mat} is of type CvArr. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvPointTo32f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPointTo32f (@var{point})\n\ +@var{point} is of type CvPoint. @var{retval} is of type CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_CV_SUBDIV2D_NEXT_EDGE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_SUBDIV2D_NEXT_EDGE (@var{edge})\n\ +@var{edge} is of type CvSubdiv2DEdge. @var{retval} is of type CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_CV_HIST_HAS_RANGES_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_HIST_HAS_RANGES (@var{hist})\n\ +@var{hist} is of type CvHistogram. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_8UC_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_8UC (@var{n})\n\ +@var{n} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_delete_CvHaarClassifierCascade_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvHaarClassifierCascade (@var{self})\n\ +@var{self} is of type CvHaarClassifierCascade. \n\ +@end deftypefn"; +const char* _wrap_cvLoadHaarClassifierCascade_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvLoadHaarClassifierCascade (@var{directory}, @var{orig_window_size})\n\ +@var{directory} is of type char. @var{orig_window_size} is of type CvSize. @var{retval} is of type CvHaarClassifierCascade. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseHaarClassifierCascade_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseHaarClassifierCascade (@var{cascade})\n\ +@var{cascade} is of type CvHaarClassifierCascade. \n\ +@end deftypefn"; +const char* _wrap_cvSetImagesForHaarClassifierCascade_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetImagesForHaarClassifierCascade (@var{cascade}, @var{sum}, @var{sqsum}, @var{tilted_sum}, @var{scale})\n\ +@var{cascade} is of type CvHaarClassifierCascade. @var{sum} is of type CvArr. @var{sqsum} is of type CvArr. @var{tilted_sum} is of type CvArr. @var{scale} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvRunHaarClassifierCascade_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRunHaarClassifierCascade (@var{cascade}, @var{pt}, @var{start_stage} = 0)\n\ +@var{cascade} is of type CvHaarClassifierCascade. @var{pt} is of type CvPoint. @var{start_stage} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvAndS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvAndS (@var{src}, @var{value}, @var{dst}, @var{mask} = nil)\n\ +@var{src} is of type CvArr. @var{value} is of type CvScalar. @var{dst} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvImage_roi_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = roi (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_CvSubdiv2DEdge_Wrapper_ref_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = ref (@var{self})\n\ +@var{self} is of type CvSubdiv2DEdge_Wrapper. @var{retval} is of type CvSubdiv2DEdge. \n\ +@end deftypefn"; +const char* _wrap_CvRNG_Wrapper_ref_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = ref (@var{self})\n\ +@var{self} is of type CvRNG_Wrapper. @var{retval} is of type CvRNG. \n\ +@end deftypefn"; +const char* _wrap_cvInpaint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvInpaint (@var{src}, @var{inpaint_mask}, @var{dst}, @var{inpaintRange}, @var{flags})\n\ +@var{src} is of type CvArr. @var{inpaint_mask} is of type CvArr. @var{dst} is of type CvArr. @var{inpaintRange} is of type double. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvStartNextStream_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvStartNextStream (@var{fs})\n\ +@var{fs} is of type CvFileStorage. \n\ +@end deftypefn"; +const char* _wrap_cvWatershed_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvWatershed (@var{image}, @var{markers})\n\ +@var{image} is of type CvArr. @var{markers} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvResetImageROI_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvResetImageROI (@var{image})\n\ +@var{image} is of type . \n\ +@end deftypefn"; +const char* _wrap_cvCalcOpticalFlowLK_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcOpticalFlowLK (@var{prev}, @var{curr}, @var{win_size}, @var{velx}, @var{vely})\n\ +@var{prev} is of type CvArr. @var{curr} is of type CvArr. @var{win_size} is of type CvSize. @var{velx} is of type CvArr. @var{vely} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvImage_clear_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} clear (@var{self})\n\ +@var{self} is of type CvImage. \n\ +@end deftypefn"; +const char* _wrap_new_CvPoint3D32f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvPoint3D32f::CvPoint3D32f ()\n\ +@var{retval} is of type CvPoint3D32f. \n\ +@end deftypefn"; +const char* _wrap_delete_CvPoint3D32f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvPoint3D32f::~CvPoint3D32f (@var{self})\n\ +@var{self} is of type CvPoint3D32f. \n\ +@end deftypefn"; +const char* _wrap_cvPoint3D32f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPoint3D32f (@var{x}, @var{y}, @var{z})\n\ +@var{x} is of type double. @var{y} is of type double. @var{z} is of type double. @var{retval} is of type CvPoint3D32f. \n\ +@end deftypefn"; +const char* _wrap_CV_NEXT_GRAPH_EDGE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NEXT_GRAPH_EDGE (@var{edge}, @var{vertex})\n\ +@var{edge} is of type CvGraphEdge. @var{vertex} is of type CvGraphVtx. @var{retval} is of type CvGraphEdge. \n\ +@end deftypefn"; +const char* _wrap_cvGraphRemoveEdge_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvGraphRemoveEdge (@var{graph}, @var{start_idx}, @var{end_idx})\n\ +@var{graph} is of type CvGraph. @var{start_idx} is of type int. @var{end_idx} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvFindStereoCorrespondenceGC_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFindStereoCorrespondenceGC (@var{left}, @var{right}, @var{disparityLeft}, @var{disparityRight}, @var{state}, @var{useDisparityGuess} = 0)\n\ +@var{left} is of type CvArr. @var{right} is of type CvArr. @var{disparityLeft} is of type CvArr. @var{disparityRight} is of type CvArr. @var{state} is of type CvStereoGCState. @var{useDisparityGuess} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvFlip_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFlip (@var{src}, @var{dst} = nil, @var{flip_mode} = 0)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{flip_mode} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvKalmanPredict_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvKalmanPredict (@var{kalman}, @var{control} = nil)\n\ +@var{kalman} is of type CvKalman. @var{control} is of type CvMat. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvGetDiag_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetDiag (@var{arr}, @var{submat}, @var{diag} = 0)\n\ +@var{arr} is of type CvArr. @var{submat} is of type CvMat. @var{diag} is of type int. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvMinMaxLoc_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMinMaxLoc (@var{arr}, @var{min_val}, @var{max_val}, @var{min_loc} = nil, @var{max_loc} = nil, @var{mask} = nil)\n\ +@var{arr} is of type CvArr. @var{min_val} is of type double. @var{max_val} is of type double. @var{min_loc} is of type CvPoint. @var{max_loc} is of type CvPoint. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_swap_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} swap (@var{self}, @var{v})\n\ +@var{self} is of type CvPointVector. @var{v} is of type CvPointVector. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_swap_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} swap (@var{self}, @var{v})\n\ +@var{self} is of type FloatVector. @var{v} is of type FloatVector. \n\ +@end deftypefn"; +const char* _wrap_cvEndWriteSeq_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvEndWriteSeq (@var{writer})\n\ +@var{writer} is of type CvSeqWriter. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvStartWriteSeq_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvStartWriteSeq (@var{seq_flags}, @var{header_size}, @var{elem_size}, @var{storage}, @var{writer})\n\ +@var{seq_flags} is of type int. @var{header_size} is of type int. @var{elem_size} is of type int. @var{storage} is of type CvMemStorage. @var{writer} is of type CvSeqWriter. \n\ +@end deftypefn"; +const char* _wrap_cvRectToROI_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRectToROI (@var{rect}, @var{coi})\n\ +@var{rect} is of type CvRect. @var{coi} is of type int. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_cvSave_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSave (@var{filename}, @var{struct_ptr}, @var{name} = nil, @var{comment} = nil, @var{attributes} = cvAttrList())\n\ +@var{filename} is of type char. @var{struct_ptr} is of type void. @var{name} is of type char. @var{comment} is of type char. @var{attributes} is of type CvAttrList. \n\ +@end deftypefn"; +const char* _wrap_IplImage___rxor___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rxor__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMat___rxor___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rxor__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvLogPolar_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvLogPolar (@var{src}, @var{dst}, @var{center}, @var{M}, @var{flags} = 1+8)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{center} is of type CvPoint2D32f. @var{M} is of type double. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCvtSeqToArray_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCvtSeqToArray_Shadow (@var{seq}, @var{elements})\n\ +@var{seq} is of type CvSeq. @var{elements} is of type CvArr. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CV_MAT_DEPTH_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_MAT_DEPTH (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvThreshold_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvThreshold (@var{src}, @var{dst}, @var{threshold}, @var{max_value}, @var{threshold_type})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{threshold} is of type double. @var{max_value} is of type double. @var{threshold_type} is of type int. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvAdaptiveThreshold_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvAdaptiveThreshold (@var{src}, @var{dst}, @var{max_value}, @var{adaptive_method} = 0, @var{threshold_type} = 0, @var{block_size} = 3, @var{param1} = 5)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{max_value} is of type double. @var{adaptive_method} is of type int. @var{threshold_type} is of type int. @var{block_size} is of type int. @var{param1} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvEndWriteStruct_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvEndWriteStruct (@var{fs})\n\ +@var{fs} is of type CvFileStorage. \n\ +@end deftypefn"; +const char* _wrap_cvStartWriteStruct_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvStartWriteStruct (@var{fs}, @var{name}, @var{struct_flags}, @var{type_name} = nil, @var{attributes} = cvAttrList())\n\ +@var{fs} is of type CvFileStorage. @var{name} is of type char. @var{struct_flags} is of type int. @var{type_name} is of type char. @var{attributes} is of type CvAttrList. \n\ +@end deftypefn"; +const char* _wrap_new_CvMatrix3_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvMatrix3::CvMatrix3 ()\n\ +@var{retval} is of type CvMatrix3. \n\ +@end deftypefn"; +const char* _wrap_delete_CvMatrix3_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvMatrix3::~CvMatrix3 (@var{self})\n\ +@var{self} is of type CvMatrix3. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_GRAPH_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_GRAPH (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvPointSeqFromMat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPointSeqFromMat (@var{seq_kind}, @var{mat}, @var{contour_header}, @var{block})\n\ +@var{seq_kind} is of type int. @var{mat} is of type CvArr. @var{contour_header} is of type CvContour. @var{block} is of type CvSeqBlock. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseMat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseMat (@var{mat})\n\ +@var{mat} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvConvert_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvConvert (@var{src}, @var{dst})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvSeqPush_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSeqPush (@var{seq}, @var{element} = nil)\n\ +@var{seq} is of type CvSeq. @var{element} is of type void. @var{retval} is of type schar. \n\ +@end deftypefn"; +const char* _wrap_delete_CvGraph_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvGraph::~CvGraph (@var{self})\n\ +@var{self} is of type CvGraph. \n\ +@end deftypefn"; +const char* _wrap_new_CvGraph_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvGraph::CvGraph ()\n\ +@var{retval} is of type CvGraph. \n\ +@end deftypefn"; +const char* _wrap_cvFirstType_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFirstType ()\n\ +@var{retval} is of type CvTypeInfo. \n\ +@end deftypefn"; +const char* _wrap_CvTuple_CvPoint_2___brace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __brace (@var{self}, @var{i})\n\ +@var{self} is of type CvTuple_CvPoint_2. @var{i} is of type int. @var{retval} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CvTuple_float_2___brace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __brace (@var{self}, @var{i})\n\ +@var{self} is of type CvTuple_float_2. @var{i} is of type int. @var{retval} is of type float. \n\ +@end deftypefn"; +const char* _wrap_CvTuple_float_3___brace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __brace (@var{self}, @var{i})\n\ +@var{self} is of type CvTuple_float_3. @var{i} is of type int. @var{retval} is of type float. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint___brace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __brace (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvPoint. @var{i} is of type int. @var{retval} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint2D32f___brace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __brace (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvPoint2D32f. @var{i} is of type int. @var{retval} is of type CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvRect___brace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __brace (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvRect. @var{i} is of type int. @var{retval} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvSeq___brace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __brace (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvSeq. @var{i} is of type int. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvQuadEdge2D___brace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __brace (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvQuadEdge2D. @var{i} is of type int. @var{retval} is of type CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvConnectedComp___brace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __brace (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvConnectedComp. @var{i} is of type int. @var{retval} is of type CvConnectedComp. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint_2___brace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __brace (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_CvPoint_2. @var{i} is of type int. @var{retval} is of type CvTuple_CvPoint_2. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_2___brace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __brace (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_float_2. @var{i} is of type int. @var{retval} is of type CvTuple_float_2. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_3___brace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __brace (@var{self}, @var{i})\n\ +@var{self} is of type CvSeq_float_3. @var{i} is of type int. @var{retval} is of type CvTuple_float_3. \n\ +@end deftypefn"; +const char* _wrap_cvRandArr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvRandArr (@var{rng}, @var{arr}, @var{dist_type}, @var{param1}, @var{param2})\n\ +@var{rng} is of type CvRNG. @var{arr} is of type CvArr. @var{dist_type} is of type int. @var{param1} is of type CvScalar. @var{param2} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvClearGraph_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvClearGraph (@var{graph})\n\ +@var{graph} is of type CvGraph. \n\ +@end deftypefn"; +const char* _wrap_cvGetHashedKey_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetHashedKey (@var{fs}, @var{name}, @var{len} = -1, @var{create_missing} = 0)\n\ +@var{fs} is of type CvFileStorage. @var{name} is of type char. @var{len} is of type int. @var{create_missing} is of type int. @var{retval} is of type CvStringHashNode. \n\ +@end deftypefn"; +const char* _wrap_cvGEMM_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvGEMM (@var{src1}, @var{src2}, @var{alpha}, @var{src3}, @var{beta}, @var{dst}, @var{tABC} = 0)\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{alpha} is of type double. @var{src3} is of type CvArr. @var{beta} is of type double. @var{dst} is of type CvArr. @var{tABC} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCreateKalman_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateKalman (@var{dynam_params}, @var{measure_params}, @var{control_params} = 0)\n\ +@var{dynam_params} is of type int. @var{measure_params} is of type int. @var{control_params} is of type int. @var{retval} is of type CvKalman. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseKalman_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseKalman (@var{kalman})\n\ +@var{kalman} is of type CvKalman. \n\ +@end deftypefn"; +const char* _wrap_cvmGet_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvmGet (@var{mat}, @var{row}, @var{col})\n\ +@var{mat} is of type CvMat. @var{row} is of type int. @var{col} is of type int. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSeqReader_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSeqReader::~CvSeqReader (@var{self})\n\ +@var{self} is of type CvSeqReader. \n\ +@end deftypefn"; +const char* _wrap_new_CvSeqReader_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSeqReader::CvSeqReader ()\n\ +@var{retval} is of type CvSeqReader. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_IMAGE_HDR_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_IMAGE_HDR (@var{img})\n\ +@var{img} is of type CvArr. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCloneImage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCloneImageMat (@var{mat})\n\ +@var{mat} is of type CvMat. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvCreateImage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateImageMat (@var{size}, @var{depth}, @var{channels})\n\ +@var{size} is of type CvSize. @var{depth} is of type int. @var{channels} is of type int. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_size_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = size (@var{self})\n\ +@var{self} is of type CvPointVector. @var{retval} is of type size_type. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_size_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = size (@var{self})\n\ +@var{self} is of type FloatVector. @var{retval} is of type size_type. \n\ +@end deftypefn"; +const char* _wrap_IplImage___gt___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator > (@var{self}, @var{val})\n\ +@var{self} is of type . @var{val} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMat___gt___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator > (@var{self}, @var{val})\n\ +@var{self} is of type CvMat. @var{val} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_new_CvSURFParams_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSURFParams::CvSURFParams ()\n\ +@var{retval} is of type CvSURFParams. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSURFParams_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSURFParams::~CvSURFParams (@var{self})\n\ +@var{self} is of type CvSURFParams. \n\ +@end deftypefn"; +const char* _wrap_cvSURFParams_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSURFParams (@var{hessianThreshold}, @var{extended} = 0)\n\ +@var{hessianThreshold} is of type double. @var{extended} is of type int. @var{retval} is of type CvSURFParams. \n\ +@end deftypefn"; +const char* _wrap_new_CvMSERParams_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvMSERParams::CvMSERParams ()\n\ +@var{retval} is of type CvMSERParams. \n\ +@end deftypefn"; +const char* _wrap_delete_CvMSERParams_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvMSERParams::~CvMSERParams (@var{self})\n\ +@var{self} is of type CvMSERParams. \n\ +@end deftypefn"; +const char* _wrap_cvMSERParams_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvMSERParams (@var{delta} = 5, @var{min_area} = 60, @var{max_area} = 14400, @var{max_variation} = .25, @var{min_diversity} = .2, @var{max_evolution} = 200, @var{area_threshold} = 1.01, @var{min_margin} = .003, @var{edge_blur_size} = 5)\n\ +@var{delta} is of type int. @var{min_area} is of type int. @var{max_area} is of type int. @var{max_variation} is of type float. @var{min_diversity} is of type float. @var{max_evolution} is of type int. @var{area_threshold} is of type double. @var{min_margin} is of type double. @var{edge_blur_size} is of type int. @var{retval} is of type CvMSERParams. \n\ +@end deftypefn"; +const char* _wrap_new_CvStarDetectorParams_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvStarDetectorParams::CvStarDetectorParams ()\n\ +@var{retval} is of type CvStarDetectorParams. \n\ +@end deftypefn"; +const char* _wrap_delete_CvStarDetectorParams_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvStarDetectorParams::~CvStarDetectorParams (@var{self})\n\ +@var{self} is of type CvStarDetectorParams. \n\ +@end deftypefn"; +const char* _wrap_cvStarDetectorParams_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvStarDetectorParams (@var{maxSize} = 45, @var{responseThreshold} = 30, @var{lineThresholdProjected} = 10, @var{lineThresholdBinarized} = 8, @var{suppressNonmaxSize} = 5)\n\ +@var{maxSize} is of type int. @var{responseThreshold} is of type int. @var{lineThresholdProjected} is of type int. @var{lineThresholdBinarized} is of type int. @var{suppressNonmaxSize} is of type int. @var{retval} is of type CvStarDetectorParams. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_is_valid_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = is_valid (@var{self})\n\ +@var{self} is of type CvMatrix. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_CvImage_is_valid_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = is_valid (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_cvGraphRemoveVtx_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGraphRemoveVtx (@var{graph}, @var{index})\n\ +@var{graph} is of type CvGraph. @var{index} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_IplImage___rmul___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rmul__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvMat___rmul___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rmul__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvPyrDown_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvPyrDown (@var{src}, @var{dst}, @var{filter} = CV_GAUSSIAN_5x5)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{filter} is of type int. \n\ +@end deftypefn"; +const char* _wrap_new_CvSeq_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSeq::CvSeq ()\n\ +@var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSeq_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSeq::~CvSeq (@var{self})\n\ +@var{self} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_new_CvSeq_CvSeq_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(p.CvSeq)>::CvTypedSeq<(p.CvSeq)> ()\n\ +@var{retval} is of type CvSeq_CvSeq. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSeq_CvSeq_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTypedSeq<(p.CvSeq)>::~CvTypedSeq<(p.CvSeq)> (@var{self})\n\ +@var{self} is of type CvSeq_CvSeq. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSet_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSet::~CvSet (@var{self})\n\ +@var{self} is of type CvSet. \n\ +@end deftypefn"; +const char* _wrap_new_CvSet_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSet::CvSet ()\n\ +@var{retval} is of type CvSet. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_IDX_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_IDX (@var{mat}, @var{node})\n\ +@var{mat} is of type CvSparseMat. @var{node} is of type CvSparseNode. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_POLYGON_TREE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_POLYGON_TREE (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvDiv_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvDiv (@var{src1}, @var{src2}, @var{dst}, @var{scale} = 1)\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. @var{scale} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvReduce_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReduce (@var{src}, @var{dst}, @var{dim} = -1, @var{op} = 0)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{dim} is of type int. @var{op} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvComputeCorrespondEpilines_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvComputeCorrespondEpilines (@var{points}, @var{which_image}, @var{fundamental_matrix}, @var{correspondent_lines})\n\ +@var{points} is of type CvMat. @var{which_image} is of type int. @var{fundamental_matrix} is of type CvMat. @var{correspondent_lines} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_new_CvSize_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSize::CvSize ()\n\ +@var{retval} is of type CvSize. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSize_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSize::~CvSize (@var{self})\n\ +@var{self} is of type CvSize. \n\ +@end deftypefn"; +const char* _wrap_cvClipLine_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvClipLine (@var{img_size}, @var{pt1}, @var{pt2})\n\ +@var{img_size} is of type CvSize. @var{pt1} is of type CvPoint. @var{pt2} is of type CvPoint. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetSubRect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetSubRect (@var{arr}, @var{submat}, @var{rect})\n\ +@var{arr} is of type CvArr. @var{submat} is of type CvMat. @var{rect} is of type CvRect. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvNorm_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvNorm (@var{arr1}, @var{arr2} = nil, @var{norm_type} = 4, @var{mask} = nil)\n\ +@var{arr1} is of type CvArr. @var{arr2} is of type CvArr. @var{norm_type} is of type int. @var{mask} is of type CvArr. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvCalcArrHist_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcArrHist (@var{arr}, @var{hist}, @var{accumulate} = 0, @var{mask} = nil)\n\ +@var{arr} is of type CvArr. @var{hist} is of type CvHistogram. @var{accumulate} is of type int. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvSetZero_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetZero (@var{arr})\n\ +@var{arr} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvCreateSeq_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateSeq (@var{seq_flags}, @var{header_size}, @var{elem_size}, @var{storage})\n\ +@var{seq_flags} is of type int. @var{header_size} is of type int. @var{elem_size} is of type int. @var{storage} is of type CvMemStorage. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvmSet_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvmSet (@var{mat}, @var{row}, @var{col}, @var{value})\n\ +@var{mat} is of type CvMat. @var{row} is of type int. @var{col} is of type int. @var{value} is of type double. \n\ +@end deftypefn"; +const char* _wrap_CV_CMP_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CV_CMP (@var{a}, @var{b})\n\ +@var{a} is of type int. @var{b} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCreateSet_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateSet (@var{set_flags}, @var{header_size}, @var{elem_size}, @var{storage})\n\ +@var{set_flags} is of type int. @var{header_size} is of type int. @var{elem_size} is of type int. @var{storage} is of type CvMemStorage. @var{retval} is of type CvSet. \n\ +@end deftypefn"; +const char* _wrap_cvSubdiv2DEdgeDst_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSubdiv2DEdgeDst (@var{edge})\n\ +@var{edge} is of type CvSubdiv2DEdge. @var{retval} is of type CvSubdiv2DPoint. \n\ +@end deftypefn"; +const char* _wrap_cvSeqInsertSlice_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSeqInsertSlice (@var{seq}, @var{before_index}, @var{from_arr})\n\ +@var{seq} is of type CvSeq. @var{before_index} is of type int. @var{from_arr} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CV_ARE_DEPTHS_EQ_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_ARE_DEPTHS_EQ (@var{mat1}, @var{mat2})\n\ +@var{mat1} is of type CvMat. @var{mat2} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_MAT_TYPE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_MAT_TYPE (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGraphAddEdge_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGraphAddEdge (@var{graph}, @var{start_idx}, @var{end_idx}, @var{edge} = nil, @var{inserted_edge} = nil)\n\ +@var{graph} is of type CvGraph. @var{start_idx} is of type int. @var{end_idx} is of type int. @var{edge} is of type CvGraphEdge. @var{inserted_edge} is of type CvGraphEdge. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_IS_SEQ_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_IS_SEQ (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SET_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SET (@var{set})\n\ +@var{set} is of type CvSet. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_delete_CvGraphVtx_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvGraphVtx::~CvGraphVtx (@var{self})\n\ +@var{self} is of type CvGraphVtx. \n\ +@end deftypefn"; +const char* _wrap_new_CvGraphVtx_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvGraphVtx::CvGraphVtx ()\n\ +@var{retval} is of type CvGraphVtx. \n\ +@end deftypefn"; +const char* _wrap_cvGetGraphVtx_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvGetGraphVtx (@var{graph}, @var{idx})\n\ +@var{graph} is of type CvGraph. @var{idx} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvTranspose_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvTranspose (@var{src}, @var{dst})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvUpdateMotionHistory_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvUpdateMotionHistory (@var{silhouette}, @var{mhi}, @var{timestamp}, @var{duration})\n\ +@var{silhouette} is of type CvArr. @var{mhi} is of type CvArr. @var{timestamp} is of type double. @var{duration} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvGetNextSparseNode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetNextSparseNode (@var{mat_iterator})\n\ +@var{mat_iterator} is of type CvSparseMatIterator. @var{retval} is of type CvSparseNode. \n\ +@end deftypefn"; +const char* _wrap_new_CvSparseNode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSparseNode::CvSparseNode ()\n\ +@var{retval} is of type CvSparseNode. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSparseNode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSparseNode::~CvSparseNode (@var{self})\n\ +@var{self} is of type CvSparseNode. \n\ +@end deftypefn"; +const char* _wrap_cvGetThreadNum_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetThreadNum ()\n\ +@var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetSeqElem_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetSeqElem (@var{seq}, @var{index})\n\ +@var{seq} is of type CvSeq. @var{index} is of type int. @var{retval} is of type schar. \n\ +@end deftypefn"; +const char* _wrap_cvGraphRemoveVtxByPtr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGraphRemoveVtxByPtr (@var{graph}, @var{vtx})\n\ +@var{graph} is of type CvGraph. @var{vtx} is of type CvGraphVtx. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetFileNodeName_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetFileNodeName (@var{node})\n\ +@var{node} is of type CvFileNode. @var{retval} is of type char. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_capacity_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = capacity (@var{self})\n\ +@var{self} is of type FloatVector. @var{retval} is of type size_type. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_capacity_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = capacity (@var{self})\n\ +@var{self} is of type CvPointVector. @var{retval} is of type size_type. \n\ +@end deftypefn"; +const char* _wrap_cvAvgSdv_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvAvgSdv (@var{arr}, @var{mean}, @var{std_dev}, @var{mask} = nil)\n\ +@var{arr} is of type CvArr. @var{mean} is of type CvScalar. @var{std_dev} is of type CvScalar. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_delete_CvKalman_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvKalman (@var{self})\n\ +@var{self} is of type CvKalman. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint_cast_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvPoint)>::cast (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type CvSeq_CvPoint. \n\ +@end deftypefn"; +const char* _wrap_new_CvMoments_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvMoments::CvMoments ()\n\ +@var{retval} is of type CvMoments. \n\ +@end deftypefn"; +const char* _wrap_delete_CvMoments_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvMoments::~CvMoments (@var{self})\n\ +@var{self} is of type CvMoments. \n\ +@end deftypefn"; +const char* _wrap_new_CvHuMoments_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvHuMoments::CvHuMoments ()\n\ +@var{retval} is of type CvHuMoments. \n\ +@end deftypefn"; +const char* _wrap_delete_CvHuMoments_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvHuMoments::~CvHuMoments (@var{self})\n\ +@var{self} is of type CvHuMoments. \n\ +@end deftypefn"; +const char* _wrap_new_CvChainPtReader_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvChainPtReader::CvChainPtReader ()\n\ +@var{retval} is of type CvChainPtReader. \n\ +@end deftypefn"; +const char* _wrap_delete_CvChainPtReader_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvChainPtReader::~CvChainPtReader (@var{self})\n\ +@var{self} is of type CvChainPtReader. \n\ +@end deftypefn"; +const char* _wrap_cvMoments_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMoments (@var{arr}, @var{moments}, @var{binary} = 0)\n\ +@var{arr} is of type CvArr. @var{moments} is of type CvMoments. @var{binary} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetHuMoments_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvGetHuMoments (@var{moments}, @var{hu_moments})\n\ +@var{moments} is of type CvMoments. @var{hu_moments} is of type CvHuMoments. \n\ +@end deftypefn"; +const char* _wrap_cvSetImageIOFunctions_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSetImageIOFunctions (@var{_load_image}, @var{_load_image_m}, @var{_save_image}, @var{_show_image})\n\ +@var{_load_image} is of type CvLoadImageFunc. @var{_load_image_m} is of type CvLoadImageMFunc. @var{_save_image} is of type CvSaveImageFunc. @var{_show_image} is of type CvShowImageFunc. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvAvg_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvAvg (@var{arr}, @var{mask} = nil)\n\ +@var{arr} is of type CvArr. @var{mask} is of type CvArr. @var{retval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_IplImage___req___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __req__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvMat___req___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __req__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseImage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseImage (@var{image})\n\ +@var{image} is of type . \n\ +@end deftypefn"; +const char* _wrap_cvSnakeImage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSnakeImage_Shadow (@var{image}, @var{points}, @var{alpha}, @var{beta}, @var{gamma}, @var{win}, @var{criteria})\n\ +@var{image} is of type CvMat. @var{points} is of type CvPointVector. @var{alpha} is of type FloatVector. @var{beta} is of type FloatVector. @var{gamma} is of type FloatVector. @var{win} is of type CvSize. @var{criteria} is of type CvTermCriteria. @var{retval} is of type CvPointVector. \n\ +@end deftypefn"; +const char* _wrap_CvImage_origin_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = origin (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetRows_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetRows (@var{arr}, @var{submat}, @var{start_row}, @var{end_row}, @var{delta_row} = 1)\n\ +@var{arr} is of type CvArr. @var{submat} is of type CvMat. @var{start_row} is of type int. @var{end_row} is of type int. @var{delta_row} is of type int. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvWriteReal_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvWriteReal (@var{fs}, @var{name}, @var{value})\n\ +@var{fs} is of type CvFileStorage. @var{name} is of type char. @var{value} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvMul_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMul (@var{src1}, @var{src2}, @var{dst}, @var{scale} = 1)\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. @var{scale} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvOr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvOr (@var{src1}, @var{src2}, @var{dst}, @var{mask} = nil)\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvSetSeqReaderPos_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetSeqReaderPos (@var{reader}, @var{index}, @var{is_relative} = 0)\n\ +@var{reader} is of type CvSeqReader. @var{index} is of type int. @var{is_relative} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetSeqReaderPos_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetSeqReaderPos (@var{reader})\n\ +@var{reader} is of type CvSeqReader. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseGraphScanner_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseGraphScanner (@var{scanner})\n\ +@var{scanner} is of type CvGraphScanner. \n\ +@end deftypefn"; +const char* _wrap_cvCreateGraphScanner_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateGraphScanner (@var{graph}, @var{vtx} = nil, @var{mask} = -1)\n\ +@var{graph} is of type CvGraph. @var{vtx} is of type CvGraphVtx. @var{mask} is of type int. @var{retval} is of type CvGraphScanner. \n\ +@end deftypefn"; +const char* _wrap_delete_CvGraphScanner_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvGraphScanner (@var{self})\n\ +@var{self} is of type CvGraphScanner. \n\ +@end deftypefn"; +const char* _wrap_cvNormalize_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvNormalize (@var{src}, @var{dst}, @var{a} = 1., @var{b} = 0., @var{norm_type} = 4, @var{mask} = nil)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{a} is of type double. @var{b} is of type double. @var{norm_type} is of type int. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvSize_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSize (@var{width}, @var{height})\n\ +@var{width} is of type int. @var{height} is of type int. @var{retval} is of type CvSize. \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator_copy_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = copy (@var{self})\n\ +@var{self} is of type OctSwigIterator. @var{retval} is of type OctSwigIterator. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_TEMP_MAT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_TEMP_MAT (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseFileStorage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseFileStorage (@var{fs})\n\ +@var{fs} is of type CvFileStorage. \n\ +@end deftypefn"; +const char* _wrap_cvOpenFileStorage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvOpenFileStorage (@var{filename}, @var{memstorage}, @var{flags})\n\ +@var{filename} is of type char. @var{memstorage} is of type CvMemStorage. @var{flags} is of type int. @var{retval} is of type CvFileStorage. \n\ +@end deftypefn"; +const char* _wrap_cvClearMemStorage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvClearMemStorage (@var{storage})\n\ +@var{storage} is of type CvMemStorage. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseMemStorage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseMemStorage (@var{storage})\n\ +@var{storage} is of type CvMemStorage. \n\ +@end deftypefn"; +const char* _wrap_cvCreateChildMemStorage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateChildMemStorage (@var{parent})\n\ +@var{parent} is of type CvMemStorage. @var{retval} is of type CvMemStorage. \n\ +@end deftypefn"; +const char* _wrap_cvCreateMemStorage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateMemStorage (@var{block_size} = 0)\n\ +@var{block_size} is of type int. @var{retval} is of type CvMemStorage. \n\ +@end deftypefn"; +const char* _wrap_delete_CvMemStorage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvMemStorage (@var{self})\n\ +@var{self} is of type CvMemStorage. \n\ +@end deftypefn"; +const char* _wrap_cvIncRefData_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvIncRefData (@var{arr})\n\ +@var{arr} is of type CvArr. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvDecRefData_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvDecRefData (@var{arr})\n\ +@var{arr} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvSVBkSb_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSVBkSb (@var{W}, @var{U}, @var{V}, @var{B}, @var{X}, @var{flags})\n\ +@var{W} is of type CvArr. @var{U} is of type CvArr. @var{V} is of type CvArr. @var{B} is of type CvArr. @var{X} is of type CvArr. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCalibrateCamera2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalibrateCamera2 (@var{object_points}, @var{image_points}, @var{point_counts}, @var{image_size}, @var{camera_matrix}, @var{distortion_coeffs}, @var{rotation_vectors} = nil, @var{translation_vectors} = nil, @var{flags} = 0)\n\ +@var{object_points} is of type CvMat. @var{image_points} is of type CvMat. @var{point_counts} is of type CvMat. @var{image_size} is of type CvSize. @var{camera_matrix} is of type CvMat. @var{distortion_coeffs} is of type CvMat. @var{rotation_vectors} is of type CvMat. @var{translation_vectors} is of type CvMat. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_IS_EMPTY_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_IS_EMPTY (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvNextGraphItem_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvNextGraphItem (@var{scanner})\n\ +@var{scanner} is of type CvGraphScanner. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_IS_USER_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_IS_USER (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCreateStructuringElementEx_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateStructuringElementEx (@var{cols}, @var{rows}, @var{anchor_x}, @var{anchor_y}, @var{shape}, @var{values} = nil)\n\ +@var{cols} is of type int. @var{rows} is of type int. @var{anchor_x} is of type int. @var{anchor_y} is of type int. @var{shape} is of type int. @var{values} is of type int. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_cvInitUndistortMap_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvInitUndistortMap (@var{camera_matrix}, @var{distortion_coeffs}, @var{mapx}, @var{mapy})\n\ +@var{camera_matrix} is of type CvMat. @var{distortion_coeffs} is of type CvMat. @var{mapx} is of type CvArr. @var{mapy} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvMat___str_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __str (@var{self})\n\ +@var{self} is of type CvMat. @var{retval} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvSetMemoryManager_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetMemoryManager (@var{alloc_func} = nil, @var{free_func} = nil, @var{userdata} = nil)\n\ +@var{alloc_func} is of type CvAllocFunc. @var{free_func} is of type CvFreeFunc. @var{userdata} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvDCT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvDCT (@var{src}, @var{dst}, @var{flags})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCreateKDTree_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateKDTree (@var{desc})\n\ +@var{desc} is of type CvMat. @var{retval} is of type CvFeatureTree. \n\ +@end deftypefn"; +const char* _wrap_CvImage_read_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = read (@var{self}, @var{fs}, @var{seqname}, @var{idx})\n\ +@var{self} is of type CvImage. @var{fs} is of type CvFileStorage. @var{seqname} is of type char. @var{idx} is of type int. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_IplImage___le___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator <= (@var{self}, @var{val})\n\ +@var{self} is of type . @var{val} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMat___le___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator <= (@var{self}, @var{val})\n\ +@var{self} is of type CvMat. @var{val} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvAlloc_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvAlloc (@var{size})\n\ +@var{size} is of type size_t. @var{retval} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvKalmanCorrect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvKalmanCorrect (@var{kalman}, @var{measurement})\n\ +@var{kalman} is of type CvKalman. @var{measurement} is of type CvMat. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_CV_REV_READ_SEQ_ELEM_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CV_REV_READ_SEQ_ELEM (@var{elem}, @var{reader})\n\ +@var{elem} is of type CvPoint. @var{reader} is of type CvSeqReader. \n\ +@end deftypefn"; +const char* _wrap_CV_READ_SEQ_ELEM_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CV_READ_SEQ_ELEM (@var{elem}, @var{reader})\n\ +@var{elem} is of type CvPoint. @var{reader} is of type CvSeqReader. \n\ +@end deftypefn"; +const char* _wrap_CV_PREV_SEQ_ELEM_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CV_PREV_SEQ_ELEM (@var{elem_size}, @var{reader})\n\ +@var{elem_size} is of type int. @var{reader} is of type CvSeqReader. \n\ +@end deftypefn"; +const char* _wrap_CV_NEXT_SEQ_ELEM_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CV_NEXT_SEQ_ELEM (@var{elem_size}, @var{reader})\n\ +@var{elem_size} is of type int. @var{reader} is of type CvSeqReader. \n\ +@end deftypefn"; +const char* _wrap_CV_WRITE_SEQ_ELEM_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CV_WRITE_SEQ_ELEM (@var{elem}, @var{writer})\n\ +@var{elem} is of type CvPoint. @var{writer} is of type CvSeqWriter. \n\ +@end deftypefn"; +const char* _wrap_delete_CvGraphVtx2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvGraphVtx2D::~CvGraphVtx2D (@var{self})\n\ +@var{self} is of type CvGraphVtx2D. \n\ +@end deftypefn"; +const char* _wrap_new_CvGraphVtx2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvGraphVtx2D::CvGraphVtx2D ()\n\ +@var{retval} is of type CvGraphVtx2D. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvRect_cast_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvRect)>::cast (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type CvSeq_CvRect. \n\ +@end deftypefn"; +const char* _wrap_cvSliceLength_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSliceLength (@var{slice}, @var{seq})\n\ +@var{slice} is of type CvSlice. @var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvArcLength_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvArcLength_Shadow (@var{arr})\n\ +@var{arr} is of type CvArr. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_new_CvHaarFeature_rect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvHaarFeature_rect::CvHaarFeature_rect ()\n\ +@var{retval} is of type CvHaarFeature_rect. \n\ +@end deftypefn"; +const char* _wrap_delete_CvHaarFeature_rect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvHaarFeature_rect::~CvHaarFeature_rect (@var{self})\n\ +@var{self} is of type CvHaarFeature_rect. \n\ +@end deftypefn"; +const char* _wrap_cvPtrND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPtrND (@var{arr}, @var{idx}, @var{type} = nil, @var{create_node} = 1, @var{precalc_hashval} = nil)\n\ +@var{arr} is of type CvArr. @var{idx} is of type int. @var{type} is of type int. @var{create_node} is of type int. @var{precalc_hashval} is of type unsigned int. @var{retval} is of type uchar. \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator___decr___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator -- (@var{self})\n\ +@var{self} is of type OctSwigIterator. @var{retval} is of type OctSwigIterator. \n\ +@end deftypefn"; +const char* _wrap_new_CvAvgComp_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvAvgComp::CvAvgComp ()\n\ +@var{retval} is of type CvAvgComp. \n\ +@end deftypefn"; +const char* _wrap_delete_CvAvgComp_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvAvgComp::~CvAvgComp (@var{self})\n\ +@var{self} is of type CvAvgComp. \n\ +@end deftypefn"; +const char* _wrap_IplImage___rand___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rand__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMat___rand___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rand__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvConnectedComp_cast_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvConnectedComp)>::cast (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type CvSeq_CvConnectedComp. \n\ +@end deftypefn"; +const char* _wrap_cvReshapeND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReshapeND (@var{arr}, @var{header}, @var{new_cn}, @var{new_dims}, @var{new_sizes})\n\ +@var{arr} is of type CvArr. @var{header} is of type CvMat. @var{new_cn} is of type int. @var{new_dims} is of type int. @var{new_sizes} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvImage_reset_roi_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} reset_roi (@var{self})\n\ +@var{self} is of type CvImage. \n\ +@end deftypefn"; +const char* _wrap_CvImage_set_roi_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} set_roi (@var{self}, @var{roi})\n\ +@var{self} is of type CvImage. @var{roi} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_delete_CvMatrix_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvMatrix (@var{self})\n\ +@var{self} is of type CvMatrix. \n\ +@end deftypefn"; +const char* _wrap_new_CvMatrix_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvMatrix (@var{fs}, @var{seqname}, @var{idx})\n\ +@var{fs} is of type CvFileStorage. @var{seqname} is of type char. @var{idx} is of type int. @var{retval} is of type CvMatrix. \n\ +@end deftypefn"; +const char* _wrap_cvCalcCovarMatrix_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcCovarMatrix (@var{vects}, @var{count}, @var{cov_mat}, @var{avg}, @var{flags})\n\ +@var{vects} is of type CvArr. @var{count} is of type int. @var{cov_mat} is of type CvArr. @var{avg} is of type CvArr. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cv2DRotationMatrix_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cv2DRotationMatrix (@var{center}, @var{angle}, @var{scale}, @var{map_matrix})\n\ +@var{center} is of type CvPoint2D32f. @var{angle} is of type double. @var{scale} is of type double. @var{map_matrix} is of type CvMat. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvDecomposeProjectionMatrix_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvDecomposeProjectionMatrix (@var{projMatr}, @var{calibMatr}, @var{rotMatr}, @var{posVect}, @var{rotMatrX} = nil, @var{rotMatrY} = nil, @var{rotMatrZ} = nil, @var{eulerAngles} = nil)\n\ +@var{projMatr} is of type CvMat. @var{calibMatr} is of type CvMat. @var{rotMatr} is of type CvMat. @var{posVect} is of type CvMat. @var{rotMatrX} is of type CvMat. @var{rotMatrY} is of type CvMat. @var{rotMatrZ} is of type CvMat. @var{eulerAngles} is of type CvPoint3D64f. \n\ +@end deftypefn"; +const char* _wrap_cvMultiplyAcc_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMultiplyAcc (@var{image1}, @var{image2}, @var{acc}, @var{mask} = nil)\n\ +@var{image1} is of type CvArr. @var{image2} is of type CvArr. @var{acc} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvRect_pop_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = pop (@var{self})\n\ +@var{self} is of type CvSeq_CvRect. @var{retval} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_cvExp_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvExp (@var{src}, @var{dst})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_new_CvContourTree_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvContourTree::CvContourTree ()\n\ +@var{retval} is of type CvContourTree. \n\ +@end deftypefn"; +const char* _wrap_delete_CvContourTree_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvContourTree::~CvContourTree (@var{self})\n\ +@var{self} is of type CvContourTree. \n\ +@end deftypefn"; +const char* _wrap_cvCreateContourTree_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateContourTree (@var{contour}, @var{storage}, @var{threshold})\n\ +@var{contour} is of type CvSeq. @var{storage} is of type CvMemStorage. @var{threshold} is of type double. @var{retval} is of type CvContourTree. \n\ +@end deftypefn"; +const char* _wrap_cvReadInt_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvReadInt (@var{node}, @var{default_value} = 0)\n\ +@var{node} is of type CvFileNode. @var{default_value} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCamShift_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCamShift (@var{prob_image}, @var{window}, @var{criteria}, @var{comp}, @var{box} = nil)\n\ +@var{prob_image} is of type CvArr. @var{window} is of type CvRect. @var{criteria} is of type CvTermCriteria. @var{comp} is of type CvConnectedComp. @var{box} is of type CvBox2D. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSet1D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSet1D (@var{arr}, @var{idx0}, @var{value})\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{value} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvSubdiv2DNextEdge_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSubdiv2DNextEdge (@var{edge})\n\ +@var{edge} is of type CvSubdiv2DEdge. @var{retval} is of type CvSubdiv2DEdge. \n\ +@end deftypefn"; +const char* _wrap_cvRandReal_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRandReal (@var{rng})\n\ +@var{rng} is of type CvRNG. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvStereoRectify_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvStereoRectify (@var{camera_matrix1}, @var{camera_matrix2}, @var{dist_coeffs1}, @var{dist_coeffs2}, @var{image_size}, @var{R}, @var{T}, @var{R1}, @var{R2}, @var{P1}, @var{P2}, @var{Q} = 0, @var{flags} = 1024)\n\ +@var{camera_matrix1} is of type CvMat. @var{camera_matrix2} is of type CvMat. @var{dist_coeffs1} is of type CvMat. @var{dist_coeffs2} is of type CvMat. @var{image_size} is of type CvSize. @var{R} is of type CvMat. @var{T} is of type CvMat. @var{R1} is of type CvMat. @var{R2} is of type CvMat. @var{P1} is of type CvMat. @var{P2} is of type CvMat. @var{Q} is of type CvMat. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_3_pop_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = pop (@var{self})\n\ +@var{self} is of type CvSeq_float_3. @var{retval} is of type CvTuple_float_3. \n\ +@end deftypefn"; +const char* _wrap_CV_ARE_SIZES_EQ_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_ARE_SIZES_EQ (@var{mat1}, @var{mat2})\n\ +@var{mat1} is of type CvMat. @var{mat2} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvQuadEdge2D_cast_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvQuadEdge2D)>::cast (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type CvSeq_CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_delete_IplConvKernel_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} IplConvKernel (@var{self})\n\ +@var{self} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_addref_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} addref (@var{self})\n\ +@var{self} is of type CvMatrix. \n\ +@end deftypefn"; +const char* _wrap_cvSolvePoly_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSolvePoly (@var{coeffs}, @var{roots2}, @var{maxiter} = 20, @var{fig} = 100)\n\ +@var{coeffs} is of type CvMat. @var{roots2} is of type CvMat. @var{maxiter} is of type int. @var{fig} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSet2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSet2D (@var{arr}, @var{idx0}, @var{idx1}, @var{value})\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{idx1} is of type int. @var{value} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvCopy_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCopy (@var{src}, @var{dst}, @var{mask} = nil)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_GRAPH_EDGE_VISITED_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_GRAPH_EDGE_VISITED (@var{edge})\n\ +@var{edge} is of type CvGraphEdge. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_GRAPH_VERTEX_VISITED_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_GRAPH_VERTEX_VISITED (@var{vtx})\n\ +@var{vtx} is of type CvGraphVtx. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSeqElemIdx_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSeqElemIdx (@var{seq}, @var{element}, @var{block} = nil)\n\ +@var{seq} is of type CvSeq. @var{element} is of type void. @var{block} is of type CvSeqBlock. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetSpatialMoment_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetSpatialMoment (@var{moments}, @var{x_order}, @var{y_order})\n\ +@var{moments} is of type CvMoments. @var{x_order} is of type int. @var{y_order} is of type int. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvGetCentralMoment_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetCentralMoment (@var{moments}, @var{x_order}, @var{y_order})\n\ +@var{moments} is of type CvMoments. @var{x_order} is of type int. @var{y_order} is of type int. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvGetNormalizedCentralMoment_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetNormalizedCentralMoment (@var{moments}, @var{x_order}, @var{y_order})\n\ +@var{moments} is of type CvMoments. @var{x_order} is of type int. @var{y_order} is of type int. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_CV_MAT_CN_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_MAT_CN (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvRange_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRange (@var{mat}, @var{start}, @var{end})\n\ +@var{mat} is of type CvArr. @var{start} is of type double. @var{end} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_back_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = back (@var{self})\n\ +@var{self} is of type CvPointVector. @var{retval} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_back_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = back (@var{self})\n\ +@var{self} is of type FloatVector. @var{retval} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_IplImage___str_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __str (@var{self})\n\ +@var{self} is of type . @var{retval} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvFindChessboardCorners_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFindChessboardCorners (@var{image}, @var{pattern_size}, @var{flags} = 1+2)\n\ +@var{image} is of type void. @var{pattern_size} is of type CvSize. @var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvDrawChessboardCorners_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvDrawChessboardCorners (@var{image}, @var{pattern_size}, @var{corners}, @var{pattern_was_found})\n\ +@var{image} is of type CvArr. @var{pattern_size} is of type CvSize. @var{corners} is of type CvPoint2D32f. @var{pattern_was_found} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGraphVtxIdx_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGraphVtxIdx (@var{graph}, @var{vtx})\n\ +@var{graph} is of type CvGraph. @var{vtx} is of type CvGraphVtx. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_pop_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = pop (@var{self})\n\ +@var{self} is of type CvPointVector. @var{retval} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_pop_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = pop (@var{self})\n\ +@var{self} is of type FloatVector. @var{retval} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_IplImage___rsub___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rsub__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMat___rsub___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rsub__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_CV_64FC_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_64FC (@var{n})\n\ +@var{n} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvFindFundamentalMat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFindFundamentalMat (@var{points1}, @var{points2}, @var{fundamental_matrix}, @var{method} = 8, @var{param1} = 3., @var{param2} = 0.99, @var{status} = nil)\n\ +@var{points1} is of type CvMat. @var{points2} is of type CvMat. @var{fundamental_matrix} is of type CvMat. @var{method} is of type int. @var{param1} is of type double. @var{param2} is of type double. @var{status} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_RGB_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_RGB (@var{r}, @var{g}, @var{b})\n\ +@var{r} is of type double. @var{g} is of type double. @var{b} is of type int. @var{retval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvInRange_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvInRange (@var{src}, @var{lower}, @var{upper}, @var{dst})\n\ +@var{src} is of type CvArr. @var{lower} is of type CvArr. @var{upper} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CV_ELEM_SIZE1_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_ELEM_SIZE1 (@var{type})\n\ +@var{type} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCalcGlobalOrientation_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCalcGlobalOrientation (@var{orientation}, @var{mask}, @var{mhi}, @var{timestamp}, @var{duration})\n\ +@var{orientation} is of type CvArr. @var{mask} is of type CvArr. @var{mhi} is of type CvArr. @var{timestamp} is of type double. @var{duration} is of type double. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvRestoreMemStoragePos_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvRestoreMemStoragePos (@var{storage}, @var{pos})\n\ +@var{storage} is of type CvMemStorage. @var{pos} is of type CvMemStoragePos. \n\ +@end deftypefn"; +const char* _wrap_cvSaveMemStoragePos_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSaveMemStoragePos (@var{storage}, @var{pos})\n\ +@var{storage} is of type CvMemStorage. @var{pos} is of type CvMemStoragePos. \n\ +@end deftypefn"; +const char* _wrap_new_CvMemStoragePos_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvMemStoragePos::CvMemStoragePos ()\n\ +@var{retval} is of type CvMemStoragePos. \n\ +@end deftypefn"; +const char* _wrap_delete_CvMemStoragePos_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvMemStoragePos::~CvMemStoragePos (@var{self})\n\ +@var{self} is of type CvMemStoragePos. \n\ +@end deftypefn"; +const char* _wrap_CvSubdiv2D_typed_edges_get_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = typed_edges_get (@var{self})\n\ +@var{self} is of type CvSubdiv2D. @var{retval} is of type CvSeq_CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_cvEigenVV_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvEigenVV (@var{mat}, @var{evects}, @var{evals}, @var{eps} = 0, @var{lowindex} = -1, @var{highindex} = -1)\n\ +@var{mat} is of type CvArr. @var{evects} is of type CvArr. @var{evals} is of type CvArr. @var{eps} is of type double. @var{lowindex} is of type int. @var{highindex} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvLog_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvLog (@var{src}, @var{dst})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvImage_load_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = load (@var{self}, @var{filename})\n\ +@var{self} is of type CvImage. @var{filename} is of type char. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_cvSet3D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSet3D (@var{arr}, @var{idx0}, @var{idx1}, @var{idx2}, @var{value})\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{idx1} is of type int. @var{idx2} is of type int. @var{value} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseData_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseData (@var{arr})\n\ +@var{arr} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvDFT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvDFT (@var{src}, @var{dst}, @var{flags}, @var{nonzero_rows} = 0)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{flags} is of type int. @var{nonzero_rows} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_MAT_CONT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_MAT_CONT (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCloneMat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCloneMat (@var{mat})\n\ +@var{mat} is of type CvMat. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvExtractSURF_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvExtractSURF (@var{img}, @var{mask}, @var{keypoints}, @var{descriptors}, @var{storage}, @var{params}, @var{useProvidedKeyPts} = 0)\n\ +@var{img} is of type CvArr. @var{mask} is of type CvArr. @var{keypoints} is of type CvSeq. @var{descriptors} is of type CvSeq. @var{storage} is of type CvMemStorage. @var{params} is of type CvSURFParams. @var{useProvidedKeyPts} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvRectangle_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvRectangle (@var{img}, @var{pt1}, @var{pt2}, @var{color}, @var{thickness} = 1, @var{line_type} = 8, @var{shift} = 0)\n\ +@var{img} is of type CvArr. @var{pt1} is of type CvPoint. @var{pt2} is of type CvPoint. @var{color} is of type CvScalar. @var{thickness} is of type int. @var{line_type} is of type int. @var{shift} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetCol_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetCol (@var{arr}, @var{submat}, @var{col})\n\ +@var{arr} is of type CvArr. @var{submat} is of type CvMat. @var{col} is of type int. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvSetSeqBlockSize_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetSeqBlockSize (@var{seq}, @var{delta_elems})\n\ +@var{seq} is of type CvSeq. @var{delta_elems} is of type int. \n\ +@end deftypefn"; +const char* _wrap_IplImage___rge___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rge__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvMat___rge___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rge__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvCalcBackProjectPatch_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcBackProjectPatch (@var{image}, @var{dst}, @var{range}, @var{hist}, @var{method}, @var{factor})\n\ +@var{image} is of type . @var{dst} is of type CvArr. @var{range} is of type CvSize. @var{hist} is of type CvHistogram. @var{method} is of type int. @var{factor} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvCalcArrBackProjectPatch_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcArrBackProjectPatch (@var{image}, @var{dst}, @var{range}, @var{hist}, @var{method}, @var{factor})\n\ +@var{image} is of type CvArr. @var{dst} is of type CvArr. @var{range} is of type CvSize. @var{hist} is of type CvHistogram. @var{method} is of type int. @var{factor} is of type double. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_data_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = data (@var{self})\n\ +@var{self} is of type CvMatrix. @var{retval} is of type uchar. \n\ +@end deftypefn"; +const char* _wrap_cvPow_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvPow (@var{src}, @var{dst}, @var{power})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{power} is of type double. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_MAT_HDR_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_MAT_HDR (@var{mat})\n\ +@var{mat} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SPARSE_MAT_HDR_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SPARSE_MAT_HDR (@var{mat})\n\ +@var{mat} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvConDensInitSampleSet_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvConDensInitSampleSet (@var{condens}, @var{lower_bound}, @var{upper_bound})\n\ +@var{condens} is of type CvConDensation. @var{lower_bound} is of type CvMat. @var{upper_bound} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_POINT_SUBSET_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_POINT_SUBSET (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_new_CvMat_data_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvMat_data::CvMat_data ()\n\ +@var{retval} is of type CvMat_data. \n\ +@end deftypefn"; +const char* _wrap_delete_CvMat_data_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvMat_data::~CvMat_data (@var{self})\n\ +@var{self} is of type CvMat_data. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_set_data_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} set_data (@var{self}, @var{data})\n\ +@var{self} is of type CvMatrix. @var{data} is of type void. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_CLOSED_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_CLOSED (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvWriteString_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvWriteString (@var{fs}, @var{name}, @var{str}, @var{quote} = 0)\n\ +@var{fs} is of type CvFileStorage. @var{name} is of type char. @var{str} is of type char. @var{quote} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvMemStorageAllocString_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvMemStorageAllocString (@var{storage}, @var{ptr}, @var{len} = -1)\n\ +@var{storage} is of type CvMemStorage. @var{ptr} is of type char. @var{len} is of type int. @var{retval} is of type CvString. \n\ +@end deftypefn"; +const char* _wrap_CvSubdiv2D_typed_edges_set_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} typed_edges_set (@var{self}, @var{?})\n\ +@var{self} is of type CvSubdiv2D. @var{?} is of type CvSeq_CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_HAS_NAME_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_HAS_NAME (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCloneSparseMat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCloneSparseMat (@var{mat})\n\ +@var{mat} is of type CvSparseMat. @var{retval} is of type CvSparseMat. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseSparseMat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseSparseMat (@var{mat})\n\ +@var{mat} is of type CvSparseMat. \n\ +@end deftypefn"; +const char* _wrap_cvCreateSparseMat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateSparseMat (@var{dims}, @var{type})\n\ +@var{dims} is of type int. @var{type} is of type int. @var{retval} is of type CvSparseMat. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSparseMat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSparseMat (@var{self})\n\ +@var{self} is of type CvSparseMat. \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator_equal_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = equal (@var{self}, @var{x})\n\ +@var{self} is of type OctSwigIterator. @var{x} is of type OctSwigIterator. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_POLYGON_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_POLYGON (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvXor_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvXor (@var{src1}, @var{src2}, @var{dst}, @var{mask} = nil)\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvLaplace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvLaplace (@var{src}, @var{dst}, @var{aperture_size} = 3)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{aperture_size} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvLSHQuery_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvLSHQuery (@var{lsh}, @var{query_points}, @var{indices}, @var{dist}, @var{k}, @var{emax})\n\ +@var{lsh} is of type CvLSH. @var{query_points} is of type CvMat. @var{indices} is of type CvMat. @var{dist} is of type CvMat. @var{k} is of type int. @var{emax} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSetNew_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSetNew (@var{set_header})\n\ +@var{set_header} is of type CvSet. @var{retval} is of type CvSetElem. \n\ +@end deftypefn"; +const char* _wrap_CV_SIGN_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CV_SIGN (@var{a})\n\ +@var{a} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvConvertMaps_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvConvertMaps (@var{mapx}, @var{mapy}, @var{mapxy}, @var{mapalpha})\n\ +@var{mapx} is of type CvArr. @var{mapy} is of type CvArr. @var{mapxy} is of type CvArr. @var{mapalpha} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvSet_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSet (@var{arr}, @var{value}, @var{mask} = nil)\n\ +@var{arr} is of type CvArr. @var{value} is of type CvScalar. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvSeqInsert_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSeqInsert (@var{seq}, @var{before_index}, @var{element} = nil)\n\ +@var{seq} is of type CvSeq. @var{before_index} is of type int. @var{element} is of type void. @var{retval} is of type schar. \n\ +@end deftypefn"; +const char* _wrap_cvCreateSpillTree_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateSpillTree (@var{raw_data}, @var{naive} = 50, @var{rho} = .7, @var{tau} = .1)\n\ +@var{raw_data} is of type CvMat. @var{naive} is of type int. @var{rho} is of type double. @var{tau} is of type double. @var{retval} is of type CvFeatureTree. \n\ +@end deftypefn"; +const char* _wrap_cvHaarDetectObjects_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvHaarDetectObjects_Shadow (@var{image}, @var{cascade}, @var{storage})\n\ +@var{image} is of type CvArr. @var{cascade} is of type CvHaarClassifierCascade. @var{storage} is of type CvMemStorage. @var{retval} is of type CvSeq_CvRect. \n\ +@end deftypefn"; +const char* _wrap_cvCalcImageHomography_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcImageHomography (@var{line}, @var{center}, @var{intrinsic}, @var{homography})\n\ +@var{line} is of type float. @var{center} is of type CvPoint3D32f. @var{intrinsic} is of type float. @var{homography} is of type float. \n\ +@end deftypefn"; +const char* _wrap_cvFindHomography_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFindHomography (@var{src_points}, @var{dst_points}, @var{homography}, @var{method} = 0, @var{ransacReprojThreshold} = 0, @var{mask} = 0)\n\ +@var{src_points} is of type CvMat. @var{dst_points} is of type CvMat. @var{homography} is of type CvMat. @var{method} is of type int. @var{ransacReprojThreshold} is of type double. @var{mask} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_MAKETYPE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_MAKETYPE (@var{depth}, @var{cn})\n\ +@var{depth} is of type int. @var{cn} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvWrite_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvWrite (@var{fs}, @var{name}, @var{ptr}, @var{attributes} = cvAttrList())\n\ +@var{fs} is of type CvFileStorage. @var{name} is of type char. @var{ptr} is of type void. @var{attributes} is of type CvAttrList. \n\ +@end deftypefn"; +const char* _wrap_new_CvMatND_data_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvMatND_data::CvMatND_data ()\n\ +@var{retval} is of type CvMatND_data. \n\ +@end deftypefn"; +const char* _wrap_delete_CvMatND_data_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvMatND_data::~CvMatND_data (@var{self})\n\ +@var{self} is of type CvMatND_data. \n\ +@end deftypefn"; +const char* _wrap_cvCalcPCA_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcPCA (@var{data}, @var{mean}, @var{eigenvals}, @var{eigenvects}, @var{flags})\n\ +@var{data} is of type CvArr. @var{mean} is of type CvArr. @var{eigenvals} is of type CvArr. @var{eigenvects} is of type CvArr. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvRodrigues2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRodrigues2 (@var{src}, @var{dst}, @var{jacobian} = 0)\n\ +@var{src} is of type CvMat. @var{dst} is of type CvMat. @var{jacobian} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvNormalizeHist_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvNormalizeHist (@var{hist}, @var{factor})\n\ +@var{hist} is of type CvHistogram. @var{factor} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvEqualizeHist_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvEqualizeHist (@var{src}, @var{dst})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvClone_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvClone (@var{struct_ptr})\n\ +@var{struct_ptr} is of type void. @var{retval} is of type void. \n\ +@end deftypefn"; +const char* _wrap_new_CvHaarClassifier_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvHaarClassifier::CvHaarClassifier ()\n\ +@var{retval} is of type CvHaarClassifier. \n\ +@end deftypefn"; +const char* _wrap_delete_CvHaarClassifier_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvHaarClassifier::~CvHaarClassifier (@var{self})\n\ +@var{self} is of type CvHaarClassifier. \n\ +@end deftypefn"; +const char* _wrap_new_CvHaarStageClassifier_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvHaarStageClassifier::CvHaarStageClassifier ()\n\ +@var{retval} is of type CvHaarStageClassifier. \n\ +@end deftypefn"; +const char* _wrap_delete_CvHaarStageClassifier_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvHaarStageClassifier::~CvHaarStageClassifier (@var{self})\n\ +@var{self} is of type CvHaarStageClassifier. \n\ +@end deftypefn"; +const char* _wrap_cvMinAreaRect2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvMinAreaRect2 (@var{points}, @var{storage} = nil)\n\ +@var{points} is of type CvArr. @var{storage} is of type CvMemStorage. @var{retval} is of type CvBox2D. \n\ +@end deftypefn"; +const char* _wrap_cvStartAppendToSeq_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvStartAppendToSeq (@var{seq}, @var{writer})\n\ +@var{seq} is of type CvSeq. @var{writer} is of type CvSeqWriter. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_IS_REAL_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_IS_REAL (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_reserve_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} reserve (@var{self}, @var{n})\n\ +@var{self} is of type FloatVector. @var{n} is of type size_type. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_reserve_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} reserve (@var{self}, @var{n})\n\ +@var{self} is of type CvPointVector. @var{n} is of type size_type. \n\ +@end deftypefn"; +const char* _wrap_cvCompareHist_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCompareHist (@var{hist1}, @var{hist2}, @var{method})\n\ +@var{hist1} is of type CvHistogram. @var{hist2} is of type CvHistogram. @var{method} is of type int. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvMerge_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMerge (@var{src0}, @var{src1}, @var{src2}, @var{src3}, @var{dst})\n\ +@var{src0} is of type CvArr. @var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{src3} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator_value_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = value (@var{self})\n\ +@var{self} is of type OctSwigIterator. @var{retval} is of type octave_value. \n\ +@end deftypefn"; +const char* _wrap_cvGetDims_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetDims (@var{arr})\n\ +@var{arr} is of type CvArr. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector___paren___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren__ (@var{self}, @var{i})\n\ +@var{self} is of type CvPointVector. @var{i} is of type difference_type. @var{retval} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_FloatVector___paren___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __paren__ (@var{self}, @var{i})\n\ +@var{self} is of type FloatVector. @var{i} is of type difference_type. @var{retval} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_cvInitIntrinsicParams2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvInitIntrinsicParams2D (@var{object_points}, @var{image_points}, @var{npoints}, @var{image_size}, @var{camera_matrix}, @var{aspect_ratio} = 1.)\n\ +@var{object_points} is of type CvMat. @var{image_points} is of type CvMat. @var{npoints} is of type CvMat. @var{image_size} is of type CvSize. @var{camera_matrix} is of type CvMat. @var{aspect_ratio} is of type double. \n\ +@end deftypefn"; +const char* _wrap_IplImage___xor___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator ^ (@var{self}, @var{val})\n\ +@var{self} is of type . @var{val} is of type CvScalar. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMat___xor___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator ^ (@var{self}, @var{val})\n\ +@var{self} is of type CvMat. @var{val} is of type CvScalar. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvReadString_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvReadString (@var{node}, @var{default_value} = nil)\n\ +@var{node} is of type CvFileNode. @var{default_value} is of type char. @var{retval} is of type char. \n\ +@end deftypefn"; +const char* _wrap_delete_CvString_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvString::~CvString (@var{self})\n\ +@var{self} is of type CvString. \n\ +@end deftypefn"; +const char* _wrap_new_CvString_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvString::CvString ()\n\ +@var{retval} is of type CvString. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_assign_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} assign (@var{self}, @var{n}, @var{x})\n\ +@var{self} is of type CvPointVector. @var{n} is of type size_type. @var{x} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_assign_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} assign (@var{self}, @var{n}, @var{x})\n\ +@var{self} is of type FloatVector. @var{n} is of type size_type. @var{x} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_new_CvPoint3D64f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvPoint3D64f::CvPoint3D64f ()\n\ +@var{retval} is of type CvPoint3D64f. \n\ +@end deftypefn"; +const char* _wrap_delete_CvPoint3D64f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvPoint3D64f::~CvPoint3D64f (@var{self})\n\ +@var{self} is of type CvPoint3D64f. \n\ +@end deftypefn"; +const char* _wrap_cvPoint3D64f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPoint3D64f (@var{x}, @var{y}, @var{z})\n\ +@var{x} is of type double. @var{y} is of type double. @var{z} is of type double. @var{retval} is of type CvPoint3D64f. \n\ +@end deftypefn"; +const char* _wrap_cvGetTickCount_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetTickCount ()\n\ +@var{retval} is of type int64. \n\ +@end deftypefn"; +const char* _wrap_cvSubdiv2DSymEdge_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSubdiv2DSymEdge (@var{edge})\n\ +@var{edge} is of type CvSubdiv2DEdge. @var{retval} is of type CvSubdiv2DEdge. \n\ +@end deftypefn"; +const char* _wrap_cvPerspectiveTransform_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvPerspectiveTransform (@var{src}, @var{dst}, @var{mat})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{mat} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvTransform_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvTransform (@var{src}, @var{dst}, @var{transmat}, @var{shiftvec} = nil)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{transmat} is of type CvMat. @var{shiftvec} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_IplImage___ne___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator != (@var{self}, @var{val})\n\ +@var{self} is of type . @var{val} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvSubdiv2DEdge_Wrapper___ne___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator != (@var{self}, @var{x})\n\ +@var{self} is of type CvSubdiv2DEdge_Wrapper. @var{x} is of type CvSubdiv2DEdge_Wrapper. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_CvRNG_Wrapper___ne___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator != (@var{self}, @var{x})\n\ +@var{self} is of type CvRNG_Wrapper. @var{x} is of type CvRNG_Wrapper. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator___ne___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator != (@var{self}, @var{x})\n\ +@var{self} is of type OctSwigIterator. @var{x} is of type OctSwigIterator. @var{retval} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_CvMat___ne___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator != (@var{self}, @var{val})\n\ +@var{self} is of type CvMat. @var{val} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvGetAffineTransform_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetAffineTransform (@var{src}, @var{dst}, @var{map_matrix})\n\ +@var{src} is of type CvPoint2D32f. @var{dst} is of type CvPoint2D32f. @var{map_matrix} is of type CvMat. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvGetPerspectiveTransform_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetPerspectiveTransform (@var{src}, @var{dst}, @var{map_matrix})\n\ +@var{src} is of type CvPoint2D32f. @var{dst} is of type CvPoint2D32f. @var{map_matrix} is of type CvMat. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvEstimateRigidTransform_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvEstimateRigidTransform (@var{A}, @var{B}, @var{M}, @var{full_affine})\n\ +@var{A} is of type CvArr. @var{B} is of type CvArr. @var{M} is of type CvMat. @var{full_affine} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvDistTransform_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvDistTransform (@var{src}, @var{dst}, @var{distance_type} = 2, @var{mask_size} = 3, @var{mask} = nil, @var{labels} = nil)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{distance_type} is of type int. @var{mask_size} is of type int. @var{mask} is of type float. @var{labels} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvSubdiv2DLocate_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSubdiv2DLocate (@var{subdiv}, @var{pt}, @var{edge})\n\ +@var{subdiv} is of type CvSubdiv2D. @var{pt} is of type CvPoint2D32f. @var{edge} is of type CvSubdiv2DEdge. @var{retval} is of type CvSubdiv2DPointLocation. \n\ +@end deftypefn"; +const char* _wrap_cvLine_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvLine (@var{img}, @var{pt1}, @var{pt2}, @var{color}, @var{thickness} = 1, @var{line_type} = 8, @var{shift} = 0)\n\ +@var{img} is of type CvArr. @var{pt1} is of type CvPoint. @var{pt2} is of type CvPoint. @var{color} is of type CvScalar. @var{thickness} is of type int. @var{line_type} is of type int. @var{shift} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_release_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} release (@var{self})\n\ +@var{self} is of type CvMatrix. \n\ +@end deftypefn"; +const char* _wrap_CvImage_release_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} release (@var{self})\n\ +@var{self} is of type CvImage. \n\ +@end deftypefn"; +const char* _wrap_cvRelease_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvRelease (@var{struct_ptr})\n\ +@var{struct_ptr} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvGetMinMaxHistValue_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvGetMinMaxHistValue (@var{hist}, @var{min_value}, @var{max_value}, @var{min_idx} = nil, @var{max_idx} = nil)\n\ +@var{hist} is of type CvHistogram. @var{min_value} is of type float. @var{max_value} is of type float. @var{min_idx} is of type int. @var{max_idx} is of type int. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_insert_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} insert (@var{self}, @var{pos}, @var{n}, @var{x})\n\ +@var{self} is of type FloatVector. @var{pos} is of type iterator. @var{n} is of type size_type. @var{x} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_insert_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} insert (@var{self}, @var{pos}, @var{n}, @var{x})\n\ +@var{self} is of type CvPointVector. @var{pos} is of type iterator. @var{n} is of type size_type. @var{x} is of type value_type. \n\ +@end deftypefn"; +const char* _wrap_cvSubdivDelaunay2DInsert_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSubdivDelaunay2DInsert (@var{subdiv}, @var{pt})\n\ +@var{subdiv} is of type CvSubdiv2D. @var{pt} is of type CvPoint2D32f. @var{retval} is of type CvSubdiv2DPoint. \n\ +@end deftypefn"; +const char* _wrap_cvEllipse2Poly_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvEllipse2Poly (@var{center}, @var{axes}, @var{angle}, @var{arc_start}, @var{arc_end}, @var{pts}, @var{delta})\n\ +@var{center} is of type CvPoint. @var{axes} is of type CvSize. @var{angle} is of type int. @var{arc_start} is of type int. @var{arc_end} is of type int. @var{pts} is of type CvPoint. @var{delta} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_CHAIN_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_CHAIN (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_IMAGE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_IMAGE (@var{img})\n\ +@var{img} is of type CvArr. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_delete_CvTypeInfo_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTypeInfo::~CvTypeInfo (@var{self})\n\ +@var{self} is of type CvTypeInfo. \n\ +@end deftypefn"; +const char* _wrap_new_CvTypeInfo_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypeInfo::CvTypeInfo ()\n\ +@var{retval} is of type CvTypeInfo. \n\ +@end deftypefn"; +const char* _wrap_cvSubdiv2DEdgeOrg_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSubdiv2DEdgeOrg (@var{edge})\n\ +@var{edge} is of type CvSubdiv2DEdge. @var{retval} is of type CvSubdiv2DPoint. \n\ +@end deftypefn"; +const char* _wrap_delete_CvFont_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvFont::~CvFont (@var{self})\n\ +@var{self} is of type CvFont. \n\ +@end deftypefn"; +const char* _wrap_new_CvFont_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvFont::CvFont ()\n\ +@var{retval} is of type CvFont. \n\ +@end deftypefn"; +const char* _wrap_new_CvSubdiv2DPoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSubdiv2DPoint::CvSubdiv2DPoint ()\n\ +@var{retval} is of type CvSubdiv2DPoint. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSubdiv2DPoint_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSubdiv2DPoint::~CvSubdiv2DPoint (@var{self})\n\ +@var{self} is of type CvSubdiv2DPoint. \n\ +@end deftypefn"; +const char* _wrap_cvLSHAdd_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvLSHAdd (@var{lsh}, @var{data}, @var{indices} = 0)\n\ +@var{lsh} is of type CvLSH. @var{data} is of type CvMat. @var{indices} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvAddWeighted_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvAddWeighted (@var{src1}, @var{alpha}, @var{src2}, @var{beta}, @var{gamma}, @var{dst})\n\ +@var{src1} is of type CvArr. @var{alpha} is of type double. @var{src2} is of type CvArr. @var{beta} is of type double. @var{gamma} is of type double. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvGetModuleInfo_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvGetModuleInfo (@var{module_name}, @var{version}, @var{loaded_addon_plugins})\n\ +@var{module_name} is of type char. @var{version} is of type char. @var{loaded_addon_plugins} is of type char. \n\ +@end deftypefn"; +const char* _wrap_delete_CvModuleInfo_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvModuleInfo::~CvModuleInfo (@var{self})\n\ +@var{self} is of type CvModuleInfo. \n\ +@end deftypefn"; +const char* _wrap_new_CvModuleInfo_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvModuleInfo::CvModuleInfo ()\n\ +@var{retval} is of type CvModuleInfo. \n\ +@end deftypefn"; +const char* _wrap_cvCalcProbDensity_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcProbDensity (@var{hist1}, @var{hist2}, @var{dst_hist}, @var{scale} = 255)\n\ +@var{hist1} is of type CvHistogram. @var{hist2} is of type CvHistogram. @var{dst_hist} is of type CvHistogram. @var{scale} is of type double. \n\ +@end deftypefn"; +const char* _wrap_delete_CvChain_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvChain::~CvChain (@var{self})\n\ +@var{self} is of type CvChain. \n\ +@end deftypefn"; +const char* _wrap_new_CvChain_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvChain::CvChain ()\n\ +@var{retval} is of type CvChain. \n\ +@end deftypefn"; +const char* _wrap_delete_CvImage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvImage (@var{self})\n\ +@var{self} is of type CvImage. \n\ +@end deftypefn"; +const char* _wrap_new_CvImage_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvImage (@var{fs}, @var{seqname}, @var{idx})\n\ +@var{fs} is of type CvFileStorage. @var{seqname} is of type char. @var{idx} is of type int. @var{retval} is of type CvImage. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvSeq_pop_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = pop (@var{self})\n\ +@var{self} is of type CvSeq_CvSeq. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvFree__texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFree_ (@var{ptr})\n\ +@var{ptr} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvIsNaN_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvIsNaN (@var{value})\n\ +@var{value} is of type double. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvColorToScalar_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvColorToScalar (@var{packed_color}, @var{arrtype})\n\ +@var{packed_color} is of type double. @var{arrtype} is of type int. @var{retval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvRawDataToScalar_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvRawDataToScalar (@var{data}, @var{type}, @var{scalar})\n\ +@var{data} is of type void. @var{type} is of type int. @var{scalar} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_step_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = step (@var{self})\n\ +@var{self} is of type CvMatrix. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvDilate_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvDilate (@var{src}, @var{dst}, @var{element} = nil, @var{iterations} = 1)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{element} is of type . @var{iterations} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCreateSeqBlock_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCreateSeqBlock (@var{writer})\n\ +@var{writer} is of type CvSeqWriter. \n\ +@end deftypefn"; +const char* _wrap_cvChangeSeqBlock_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvChangeSeqBlock (@var{reader}, @var{direction})\n\ +@var{reader} is of type void. @var{direction} is of type int. \n\ +@end deftypefn"; +const char* _wrap_new_CvSeqBlock_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSeqBlock::CvSeqBlock ()\n\ +@var{retval} is of type CvSeqBlock. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSeqBlock_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSeqBlock::~CvSeqBlock (@var{self})\n\ +@var{self} is of type CvSeqBlock. \n\ +@end deftypefn"; +const char* _wrap_cvMulSpectrums_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMulSpectrums (@var{src1}, @var{src2}, @var{dst}, @var{flags})\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_IplImage___mul___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator * (@var{self}, @var{val})\n\ +@var{self} is of type . @var{val} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMat___mul___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator * (@var{self}, @var{val})\n\ +@var{self} is of type CvMat. @var{val} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvRunningAvg_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvRunningAvg (@var{image}, @var{acc}, @var{alpha}, @var{mask} = nil)\n\ +@var{image} is of type CvArr. @var{acc} is of type CvArr. @var{alpha} is of type double. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_delete_CvLSH_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvLSH (@var{self})\n\ +@var{self} is of type CvLSH. \n\ +@end deftypefn"; +const char* _wrap_new_CvMemBlock_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvMemBlock::CvMemBlock ()\n\ +@var{retval} is of type CvMemBlock. \n\ +@end deftypefn"; +const char* _wrap_delete_CvMemBlock_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvMemBlock::~CvMemBlock (@var{self})\n\ +@var{self} is of type CvMemBlock. \n\ +@end deftypefn"; +const char* _wrap_cvSplit_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSplit (@var{src}, @var{dst0}, @var{dst1}, @var{dst2}, @var{dst3})\n\ +@var{src} is of type CvArr. @var{dst0} is of type CvArr. @var{dst1} is of type CvArr. @var{dst2} is of type CvArr. @var{dst3} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_GRAPH_ORIENTED_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_GRAPH_ORIENTED (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvPointFrom32f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPointFrom32f (@var{point})\n\ +@var{point} is of type CvPoint2D32f. @var{retval} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_cvConvexHull2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvConvexHull2_Shadow (@var{points})\n\ +@var{points} is of type CvArr. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvCalcBayesianProb_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcBayesianProb (@var{src}, @var{number}, @var{dst})\n\ +@var{src} is of type CvHistogram. @var{number} is of type int. @var{dst} is of type CvHistogram. \n\ +@end deftypefn"; +const char* _wrap_cvSeqRemoveSlice_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSeqRemoveSlice (@var{seq}, @var{slice})\n\ +@var{seq} is of type CvSeq. @var{slice} is of type CvSlice. \n\ +@end deftypefn"; +const char* _wrap_new_CvMatND_dim_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvMatND_dim::CvMatND_dim ()\n\ +@var{retval} is of type CvMatND_dim. \n\ +@end deftypefn"; +const char* _wrap_delete_CvMatND_dim_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvMatND_dim::~CvMatND_dim (@var{self})\n\ +@var{self} is of type CvMatND_dim. \n\ +@end deftypefn"; +const char* _wrap_cvCreateLSH_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateLSH (@var{ops}, @var{d}, @var{L} = 10, @var{k} = 10, @var{type} = (((6) &((1 << 3) -1)) +(((1) -1) << 3)), @var{r} = 4, @var{seed} = -1)\n\ +@var{ops} is of type CvLSHOperations. @var{d} is of type int. @var{L} is of type int. @var{k} is of type int. @var{type} is of type int. @var{r} is of type double. @var{seed} is of type int64. @var{retval} is of type CvLSH. \n\ +@end deftypefn"; +const char* _wrap_CvImage_width_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = width (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IABS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IABS (@var{a})\n\ +@var{a} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvReadRawDataSlice_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReadRawDataSlice (@var{fs}, @var{reader}, @var{count}, @var{dst}, @var{dt})\n\ +@var{fs} is of type CvFileStorage. @var{reader} is of type CvSeqReader. @var{count} is of type int. @var{dst} is of type void. @var{dt} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvErrorStr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvErrorStr (@var{status})\n\ +@var{status} is of type int. @var{retval} is of type char. \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator_decr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = decr (@var{self})\n\ +@var{self} is of type OctSwigIterator. @var{retval} is of type OctSwigIterator. \n\ +@end deftypefn"; +const char* _wrap_cvCalcPGH_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCalcPGH (@var{contour}, @var{hist})\n\ +@var{contour} is of type CvSeq. @var{hist} is of type CvHistogram. \n\ +@end deftypefn"; +const char* _wrap_CV_IMAX_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IMAX (@var{a}, @var{b})\n\ +@var{a} is of type int. @var{b} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvMinS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMinS (@var{src}, @var{value}, @var{dst})\n\ +@var{src} is of type CvArr. @var{value} is of type double. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvNextNArraySlice_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvNextNArraySlice (@var{array_iterator})\n\ +@var{array_iterator} is of type CvNArrayIterator. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvFont_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFont (@var{scale}, @var{thickness} = 1)\n\ +@var{scale} is of type double. @var{thickness} is of type int. @var{retval} is of type CvFont. \n\ +@end deftypefn"; +const char* _wrap_cvTreeToNodeSeq_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvTreeToNodeSeq (@var{first}, @var{header_size}, @var{storage})\n\ +@var{first} is of type void. @var{header_size} is of type int. @var{storage} is of type CvMemStorage. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvSetRemoveByPtr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetRemoveByPtr (@var{set_header}, @var{elem})\n\ +@var{set_header} is of type CvSet. @var{elem} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvSetNumThreads_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetNumThreads (@var{threads} = 0)\n\ +@var{threads} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetNumThreads_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetNumThreads ()\n\ +@var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_delete_Cv64suf_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} Cv64suf::~Cv64suf (@var{self})\n\ +@var{self} is of type Cv64suf. \n\ +@end deftypefn"; +const char* _wrap_new_Cv64suf_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = Cv64suf::Cv64suf ()\n\ +@var{retval} is of type Cv64suf. \n\ +@end deftypefn"; +const char* _wrap_new_CvStereoBMState_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvStereoBMState::CvStereoBMState ()\n\ +@var{retval} is of type CvStereoBMState. \n\ +@end deftypefn"; +const char* _wrap_delete_CvStereoBMState_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvStereoBMState::~CvStereoBMState (@var{self})\n\ +@var{self} is of type CvStereoBMState. \n\ +@end deftypefn"; +const char* _wrap_cvCreateStereoBMState_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateStereoBMState (@var{preset} = 0, @var{numberOfDisparities} = 0)\n\ +@var{preset} is of type int. @var{numberOfDisparities} is of type int. @var{retval} is of type CvStereoBMState. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseStereoBMState_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseStereoBMState (@var{state})\n\ +@var{state} is of type CvStereoBMState. \n\ +@end deftypefn"; +const char* _wrap_cvSeqSlice_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSeqSlice (@var{seq}, @var{slice}, @var{storage} = nil, @var{copy_data} = 0)\n\ +@var{seq} is of type CvSeq. @var{slice} is of type CvSlice. @var{storage} is of type CvMemStorage. @var{copy_data} is of type int. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_new_CvScalar_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvScalar::CvScalar ()\n\ +@var{retval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_delete_CvScalar_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvScalar::~CvScalar (@var{self})\n\ +@var{self} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvScalar_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvScalar (@var{val0})\n\ +@var{val0} is of type double. @var{retval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvRealScalar_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRealScalar (@var{val0})\n\ +@var{val0} is of type double. @var{retval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvErode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvErode (@var{src}, @var{dst}, @var{element} = nil, @var{iterations} = 1)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{element} is of type . @var{iterations} is of type int. \n\ +@end deftypefn"; +const char* _wrap_IplImage___radd___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __radd__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMat___radd___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __radd__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_new_CvBox2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvBox2D::CvBox2D ()\n\ +@var{retval} is of type CvBox2D. \n\ +@end deftypefn"; +const char* _wrap_delete_CvBox2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvBox2D::~CvBox2D (@var{self})\n\ +@var{self} is of type CvBox2D. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_MATND_HDR_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_MATND_HDR (@var{mat})\n\ +@var{mat} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvRemoveNodeFromTree_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvRemoveNodeFromTree (@var{node}, @var{frame})\n\ +@var{node} is of type void. @var{frame} is of type void. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SEQ_CURVE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SEQ_CURVE (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvProjectPoints2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvProjectPoints2 (@var{object_points}, @var{rotation_vector}, @var{translation_vector}, @var{camera_matrix}, @var{distortion_coeffs}, @var{image_points}, @var{dpdrot} = nil, @var{dpdt} = nil, @var{dpdf} = nil, @var{dpdc} = nil, @var{dpddist} = nil, @var{aspect_ratio} = 0)\n\ +@var{object_points} is of type CvMat. @var{rotation_vector} is of type CvMat. @var{translation_vector} is of type CvMat. @var{camera_matrix} is of type CvMat. @var{distortion_coeffs} is of type CvMat. @var{image_points} is of type CvMat. @var{dpdrot} is of type CvMat. @var{dpdt} is of type CvMat. @var{dpdf} is of type CvMat. @var{dpdc} is of type CvMat. @var{dpddist} is of type CvMat. @var{aspect_ratio} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvSetIdentity_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetIdentity (@var{mat}, @var{value} = cvRealScalar(1))\n\ +@var{mat} is of type CvArr. @var{value} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvCmp_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCmp (@var{src1}, @var{src2}, @var{dst}, @var{cmp_op})\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. @var{cmp_op} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvWriteFileNode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvWriteFileNode (@var{fs}, @var{new_node_name}, @var{node}, @var{embed})\n\ +@var{fs} is of type CvFileStorage. @var{new_node_name} is of type char. @var{node} is of type CvFileNode. @var{embed} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetFileNode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetFileNode (@var{fs}, @var{map}, @var{key}, @var{create_missing} = 0)\n\ +@var{fs} is of type CvFileStorage. @var{map} is of type CvFileNode. @var{key} is of type CvStringHashNode. @var{create_missing} is of type int. @var{retval} is of type CvFileNode. \n\ +@end deftypefn"; +const char* _wrap_cvGetRootFileNode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetRootFileNode (@var{fs}, @var{stream_index} = 0)\n\ +@var{fs} is of type CvFileStorage. @var{stream_index} is of type int. @var{retval} is of type CvFileNode. \n\ +@end deftypefn"; +const char* _wrap_delete_CvFileNode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvFileNode::~CvFileNode (@var{self})\n\ +@var{self} is of type CvFileNode. \n\ +@end deftypefn"; +const char* _wrap_new_CvFileNode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvFileNode::CvFileNode ()\n\ +@var{retval} is of type CvFileNode. \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator___incr___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator ++ (@var{self})\n\ +@var{self} is of type OctSwigIterator. @var{retval} is of type OctSwigIterator. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_TYPE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_TYPE (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_new_CvQuadEdge2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvQuadEdge2D::CvQuadEdge2D ()\n\ +@var{retval} is of type CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_delete_CvQuadEdge2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvQuadEdge2D::~CvQuadEdge2D (@var{self})\n\ +@var{self} is of type CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_new_CvSeq_CvQuadEdge2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvQuadEdge2D)>::CvTypedSeq<(CvQuadEdge2D)> ()\n\ +@var{retval} is of type CvSeq_CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSeq_CvQuadEdge2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTypedSeq<(CvQuadEdge2D)>::~CvTypedSeq<(CvQuadEdge2D)> (@var{self})\n\ +@var{self} is of type CvSeq_CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_cvFree_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFree (@var{ptr})\n\ +@var{ptr} is of type void. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_set_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} set (@var{self}, @var{m}, @var{add_ref})\n\ +@var{self} is of type CvMatrix. @var{m} is of type CvMat. @var{add_ref} is of type bool. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvSeq_cast_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(p.CvSeq)>::cast (@var{seq})\n\ +@var{seq} is of type CvSeq. @var{retval} is of type CvSeq_CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvCheckTermCriteria_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCheckTermCriteria (@var{criteria}, @var{default_eps}, @var{default_max_iters})\n\ +@var{criteria} is of type CvTermCriteria. @var{default_eps} is of type double. @var{default_max_iters} is of type int. @var{retval} is of type CvTermCriteria. \n\ +@end deftypefn"; +const char* _wrap_new_CvTermCriteria_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTermCriteria::CvTermCriteria ()\n\ +@var{retval} is of type CvTermCriteria. \n\ +@end deftypefn"; +const char* _wrap_delete_CvTermCriteria_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTermCriteria::~CvTermCriteria (@var{self})\n\ +@var{self} is of type CvTermCriteria. \n\ +@end deftypefn"; +const char* _wrap_cvTermCriteria_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvTermCriteria (@var{type}, @var{max_iter}, @var{epsilon})\n\ +@var{type} is of type int. @var{max_iter} is of type int. @var{epsilon} is of type double. @var{retval} is of type CvTermCriteria. \n\ +@end deftypefn"; +const char* _wrap_CvScalar___getitem___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __getitem__ (@var{self}, @var{index})\n\ +@var{self} is of type CvScalar. @var{index} is of type int. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_CvScalar___setitem___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __setitem__ (@var{self}, @var{index}, @var{value})\n\ +@var{self} is of type CvScalar. @var{index} is of type int. @var{value} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvMeanShift_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvMeanShift (@var{prob_image}, @var{window}, @var{criteria}, @var{comp})\n\ +@var{prob_image} is of type CvArr. @var{window} is of type CvRect. @var{criteria} is of type CvTermCriteria. @var{comp} is of type CvConnectedComp. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCreatePOSITObject_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreatePOSITObject (@var{points}, @var{point_count})\n\ +@var{points} is of type CvPoint3D32f. @var{point_count} is of type int. @var{retval} is of type CvPOSITObject. \n\ +@end deftypefn"; +const char* _wrap_cvReleasePOSITObject_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleasePOSITObject (@var{posit_object})\n\ +@var{posit_object} is of type CvPOSITObject. \n\ +@end deftypefn"; +const char* _wrap_cvRedirectError_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRedirectError (@var{error_handler}, @var{userdata} = nil, @var{prev_userdata} = nil)\n\ +@var{error_handler} is of type CvErrorCallback. @var{userdata} is of type void. @var{prev_userdata} is of type void. @var{retval} is of type CvErrorCallback. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_asCvMat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator CvMat* (@var{self})\n\ +@var{self} is of type CvMatrix. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvSetData_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetData (@var{arr}, @var{data}, @var{step})\n\ +@var{arr} is of type CvArr. @var{data} is of type void. @var{step} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvPointVector_rbegin_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = rbegin (@var{self})\n\ +@var{self} is of type CvPointVector. @var{retval} is of type const_reverse_iterator. \n\ +@end deftypefn"; +const char* _wrap_FloatVector_rbegin_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = rbegin (@var{self})\n\ +@var{self} is of type FloatVector. @var{retval} is of type const_reverse_iterator. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_type_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = type (@var{self})\n\ +@var{self} is of type CvMatrix. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvInitSubdivDelaunay2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvInitSubdivDelaunay2D (@var{subdiv}, @var{rect})\n\ +@var{subdiv} is of type CvSubdiv2D. @var{rect} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_cvCreateSubdivDelaunay2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateSubdivDelaunay2D (@var{rect}, @var{storage})\n\ +@var{rect} is of type CvRect. @var{storage} is of type CvMemStorage. @var{retval} is of type CvSubdiv2D. \n\ +@end deftypefn"; +const char* _wrap_cvGetMat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetMat (@var{arr}, @var{header}, @var{coi} = nil, @var{allowND} = 0)\n\ +@var{arr} is of type CvArr. @var{header} is of type CvMat. @var{coi} is of type int. @var{allowND} is of type int. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvFillConvexPoly_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvFillConvexPoly (@var{img}, @var{pts}, @var{npts}, @var{color}, @var{line_type} = 8, @var{shift} = 0)\n\ +@var{img} is of type CvArr. @var{pts} is of type CvPoint. @var{npts} is of type int. @var{color} is of type CvScalar. @var{line_type} is of type int. @var{shift} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGraphVtxDegreeByPtr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGraphVtxDegreeByPtr (@var{graph}, @var{vtx})\n\ +@var{graph} is of type CvGraph. @var{vtx} is of type CvGraphVtx. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvFindGraphEdgeByPtr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFindGraphEdgeByPtr (@var{graph}, @var{start_vtx}, @var{end_vtx})\n\ +@var{graph} is of type CvGraph. @var{start_vtx} is of type CvGraphVtx. @var{end_vtx} is of type CvGraphVtx. @var{retval} is of type CvGraphEdge. \n\ +@end deftypefn"; +const char* _wrap_cvGraphRemoveEdgeByPtr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvGraphRemoveEdgeByPtr (@var{graph}, @var{start_vtx}, @var{end_vtx})\n\ +@var{graph} is of type CvGraph. @var{start_vtx} is of type CvGraphVtx. @var{end_vtx} is of type CvGraphVtx. \n\ +@end deftypefn"; +const char* _wrap_cvGraphAddEdgeByPtr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGraphAddEdgeByPtr (@var{graph}, @var{start_vtx}, @var{end_vtx}, @var{edge} = nil, @var{inserted_edge} = nil)\n\ +@var{graph} is of type CvGraph. @var{start_vtx} is of type CvGraphVtx. @var{end_vtx} is of type CvGraphVtx. @var{edge} is of type CvGraphEdge. @var{inserted_edge} is of type CvGraphEdge. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetSetElem_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetSetElem (@var{set_header}, @var{index})\n\ +@var{set_header} is of type CvSet. @var{index} is of type int. @var{retval} is of type CvSetElem. \n\ +@end deftypefn"; +const char* _wrap_new_CvSetElem_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSetElem::CvSetElem ()\n\ +@var{retval} is of type CvSetElem. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSetElem_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSetElem::~CvSetElem (@var{self})\n\ +@var{self} is of type CvSetElem. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_save_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} save (@var{self}, @var{filename}, @var{matname})\n\ +@var{self} is of type CvMatrix. @var{filename} is of type char. @var{matname} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvCreatePyramid_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreatePyramid (@var{img}, @var{extra_layers}, @var{rate}, @var{layer_sizes} = 0, @var{bufarr} = 0, @var{calc} = 1, @var{filter} = CV_GAUSSIAN_5x5)\n\ +@var{img} is of type CvArr. @var{extra_layers} is of type int. @var{rate} is of type double. @var{layer_sizes} is of type CvSize. @var{bufarr} is of type CvArr. @var{calc} is of type int. @var{filter} is of type int. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvReleasePyramid_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleasePyramid (@var{pyramid}, @var{extra_layers})\n\ +@var{pyramid} is of type CvMat. @var{extra_layers} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSetAdd_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSetAdd (@var{set_header}, @var{elem} = nil, @var{inserted_elem} = nil)\n\ +@var{set_header} is of type CvSet. @var{elem} is of type CvSetElem. @var{inserted_elem} is of type CvSetElem. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_IplImage___lt___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator < (@var{self}, @var{val})\n\ +@var{self} is of type . @var{val} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMat___lt___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator < (@var{self}, @var{val})\n\ +@var{self} is of type CvMat. @var{val} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvGetElemType_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetElemType (@var{arr})\n\ +@var{arr} is of type CvArr. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvIntegral_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvIntegral (@var{image}, @var{sum}, @var{sqsum} = nil, @var{tilted_sum} = nil)\n\ +@var{image} is of type CvArr. @var{sum} is of type CvArr. @var{sqsum} is of type CvArr. @var{tilted_sum} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvReprojectImageTo3D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReprojectImageTo3D (@var{disparityImage}, @var{_3dImage}, @var{Q}, @var{handleMissingValues} = 0)\n\ +@var{disparityImage} is of type CvArr. @var{_3dImage} is of type CvArr. @var{Q} is of type CvMat. @var{handleMissingValues} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvErrorFromIppStatus_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvErrorFromIppStatus (@var{ipp_status})\n\ +@var{ipp_status} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSetErrStatus_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetErrStatus (@var{status})\n\ +@var{status} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetErrStatus_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetErrStatus ()\n\ +@var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvPoint___str___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __str__ (@var{self})\n\ +@var{self} is of type CvPoint. @var{retval} is of type char. \n\ +@end deftypefn"; +const char* _wrap_CvPoint2D32f___str___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __str__ (@var{self})\n\ +@var{self} is of type CvPoint2D32f. @var{retval} is of type char. \n\ +@end deftypefn"; +const char* _wrap_CvScalar___str___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __str__ (@var{self})\n\ +@var{self} is of type CvScalar. @var{retval} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvGetTextSize_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvGetTextSize (@var{text_string}, @var{font}, @var{text_size})\n\ +@var{text_string} is of type char. @var{font} is of type CvFont. @var{text_size} is of type CvSize. \n\ +@end deftypefn"; +const char* _wrap_cvRead_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRead (@var{fs}, @var{node}, @var{attributes} = nil)\n\ +@var{fs} is of type CvFileStorage. @var{node} is of type CvFileNode. @var{attributes} is of type CvAttrList. @var{retval} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvReadStringByName_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvReadStringByName (@var{fs}, @var{map}, @var{name}, @var{default_value} = nil)\n\ +@var{fs} is of type CvFileStorage. @var{map} is of type CvFileNode. @var{name} is of type char. @var{default_value} is of type char. @var{retval} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvGetFileNodeByName_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetFileNodeByName (@var{fs}, @var{map}, @var{name})\n\ +@var{fs} is of type CvFileStorage. @var{map} is of type CvFileNode. @var{name} is of type char. @var{retval} is of type CvFileNode. \n\ +@end deftypefn"; +const char* _wrap_cvSubdiv2DGetEdge_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSubdiv2DGetEdge (@var{edge}, @var{type})\n\ +@var{edge} is of type CvSubdiv2DEdge. @var{type} is of type CvNextEdgeType. @var{retval} is of type CvSubdiv2DEdge. \n\ +@end deftypefn"; +const char* _wrap_delete_CvMat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvMat (@var{self})\n\ +@var{self} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_new_CvRect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvRect::CvRect ()\n\ +@var{retval} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_delete_CvRect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvRect::~CvRect (@var{self})\n\ +@var{self} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_cvCalcEMD2_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCalcEMD2 (@var{signature1}, @var{signature2}, @var{distance_type}, @var{distance_func} = nil, @var{cost_matrix} = nil, @var{flow} = nil, @var{lower_bound} = nil, @var{userdata} = nil)\n\ +@var{signature1} is of type CvArr. @var{signature2} is of type CvArr. @var{distance_type} is of type int. @var{distance_func} is of type CvDistanceFunction. @var{cost_matrix} is of type CvArr. @var{flow} is of type CvArr. @var{lower_bound} is of type float. @var{userdata} is of type void. @var{retval} is of type float. \n\ +@end deftypefn"; +const char* _wrap_cvPointPolygonTest_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPointPolygonTest (@var{contour}, @var{pt}, @var{measure_dist})\n\ +@var{contour} is of type CvArr. @var{pt} is of type CvPoint2D32f. @var{measure_dist} is of type int. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_new_CvSeq_CvRect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvRect)>::CvTypedSeq<(CvRect)> ()\n\ +@var{retval} is of type CvSeq_CvRect. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSeq_CvRect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTypedSeq<(CvRect)>::~CvTypedSeq<(CvRect)> (@var{self})\n\ +@var{self} is of type CvSeq_CvRect. \n\ +@end deftypefn"; +const char* _wrap_cvAddS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvAddS (@var{src}, @var{value}, @var{dst}, @var{mask} = nil)\n\ +@var{src} is of type CvArr. @var{value} is of type CvScalar. @var{dst} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvCbrt_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCbrt (@var{value})\n\ +@var{value} is of type float. @var{retval} is of type float. \n\ +@end deftypefn"; +const char* _wrap_cvMatMulAdd_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMatMulAdd (@var{src1}, @var{src2}, @var{src3}, @var{dst})\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{src3} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CV_ELEM_SIZE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_ELEM_SIZE (@var{type})\n\ +@var{type} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvSort_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSort (@var{src}, @var{dst} = nil, @var{idxmat} = nil, @var{flags} = 0)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{idxmat} is of type CvArr. @var{flags} is of type int. \n\ +@end deftypefn"; +const char* _wrap_delete_CvFileNode_data_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvFileNode_data::~CvFileNode_data (@var{self})\n\ +@var{self} is of type CvFileNode_data. \n\ +@end deftypefn"; +const char* _wrap_new_CvFileNode_data_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvFileNode_data::CvFileNode_data ()\n\ +@var{retval} is of type CvFileNode_data. \n\ +@end deftypefn"; +const char* _wrap_delete_IplROI_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} IplROI::~IplROI (@var{self})\n\ +@var{self} is of type . \n\ +@end deftypefn"; +const char* _wrap_new_IplROI_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = IplROI::IplROI ()\n\ +@var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_cvCreateData_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCreateData (@var{arr})\n\ +@var{arr} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvCreateMat_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateMat (@var{rows}, @var{cols}, @var{type})\n\ +@var{rows} is of type int. @var{cols} is of type int. @var{type} is of type int. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvCreateMemoryLSH_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCreateMemoryLSH (@var{d}, @var{n}, @var{L} = 10, @var{k} = 10, @var{type} = (((6) &((1 << 3) -1)) +(((1) -1) << 3)), @var{r} = 4, @var{seed} = -1)\n\ +@var{d} is of type int. @var{n} is of type int. @var{L} is of type int. @var{k} is of type int. @var{type} is of type int. @var{r} is of type double. @var{seed} is of type int64. @var{retval} is of type CvLSH. \n\ +@end deftypefn"; +const char* _wrap_delete_CvContour_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvContour::~CvContour (@var{self})\n\ +@var{self} is of type CvContour. \n\ +@end deftypefn"; +const char* _wrap_new_CvContour_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvContour::CvContour ()\n\ +@var{retval} is of type CvContour. \n\ +@end deftypefn"; +const char* _wrap_cvFindNextContour_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFindNextContour (@var{scanner})\n\ +@var{scanner} is of type CvContourScanner. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvSubstituteContour_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSubstituteContour (@var{scanner}, @var{new_contour})\n\ +@var{scanner} is of type CvContourScanner. @var{new_contour} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_CV_NODE_IS_MAP_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_NODE_IS_MAP (@var{flags})\n\ +@var{flags} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_MAT_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_MAT (@var{mat})\n\ +@var{mat} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_32FC_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_32FC (@var{n})\n\ +@var{n} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGraphGetVtxCount_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGraphGetVtxCount (@var{graph})\n\ +@var{graph} is of type CvGraph. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvPtr1D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPtr1D (@var{arr}, @var{idx0}, @var{type} = nil)\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{type} is of type int. @var{retval} is of type uchar. \n\ +@end deftypefn"; +const char* _wrap_CV_ARE_CNS_EQ_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_ARE_CNS_EQ (@var{mat1}, @var{mat2})\n\ +@var{mat1} is of type CvMat. @var{mat2} is of type CvMat. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvCrossProduct_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCrossProduct (@var{src1}, @var{src2}, @var{dst})\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvDotProduct_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvDotProduct (@var{src1}, @var{src2})\n\ +@var{src1} is of type CvArr. @var{src2} is of type CvArr. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvStartReadSeq_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvStartReadSeq (@var{seq}, @var{reader}, @var{reverse} = 0)\n\ +@var{seq} is of type CvSeq. @var{reader} is of type CvSeqReader. @var{reverse} is of type int. \n\ +@end deftypefn"; +const char* _wrap_delete_CvStringHashNode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvStringHashNode::~CvStringHashNode (@var{self})\n\ +@var{self} is of type CvStringHashNode. \n\ +@end deftypefn"; +const char* _wrap_new_CvStringHashNode_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvStringHashNode::CvStringHashNode ()\n\ +@var{retval} is of type CvStringHashNode. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_SPARSE_HIST_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_SPARSE_HIST (@var{hist})\n\ +@var{hist} is of type CvHistogram. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_IplImage___sub___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator - (@var{self}, @var{val})\n\ +@var{self} is of type . @var{val} is of type CvScalar. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator___sub___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator - (@var{self}, @var{x})\n\ +@var{self} is of type OctSwigIterator. @var{x} is of type OctSwigIterator. @var{retval} is of type ptrdiff_t. \n\ +@end deftypefn"; +const char* _wrap_CvMat___sub___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = operator - (@var{self}, @var{val})\n\ +@var{self} is of type CvMat. @var{val} is of type CvScalar. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvSeqInvert_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSeqInvert (@var{seq})\n\ +@var{seq} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvGraphAddVtx_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGraphAddVtx (@var{graph}, @var{vtx} = nil, @var{inserted_vtx} = nil)\n\ +@var{graph} is of type CvGraph. @var{vtx} is of type CvGraphVtx. @var{inserted_vtx} is of type CvGraphVtx. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvRegisterModule_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRegisterModule (@var{module_info})\n\ +@var{module_info} is of type CvModuleInfo. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGraphEdgeIdx_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGraphEdgeIdx (@var{graph}, @var{edge})\n\ +@var{graph} is of type CvGraph. @var{edge} is of type CvGraphEdge. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_new_CvModule_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvModule (@var{_info})\n\ +@var{_info} is of type CvModuleInfo. @var{retval} is of type CvModule. \n\ +@end deftypefn"; +const char* _wrap_delete_CvModule_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvModule (@var{self})\n\ +@var{self} is of type CvModule. \n\ +@end deftypefn"; +const char* _wrap_IplImage___pow___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __pow__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type . \n\ +@end deftypefn"; +const char* _wrap_CvMat___pow___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __pow__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvTriangulatePoints_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvTriangulatePoints (@var{projMatr1}, @var{projMatr2}, @var{projPoints1}, @var{projPoints2}, @var{points4D})\n\ +@var{projMatr1} is of type CvMat. @var{projMatr2} is of type CvMat. @var{projPoints1} is of type CvMat. @var{projPoints2} is of type CvMat. @var{points4D} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvMahalanobis_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvMahalanobis (@var{vec1}, @var{vec2}, @var{mat})\n\ +@var{vec1} is of type CvArr. @var{vec2} is of type CvArr. @var{mat} is of type CvArr. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseStructuringElement_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseStructuringElement (@var{element})\n\ +@var{element} is of type . \n\ +@end deftypefn"; +const char* _wrap_delete_CvSubdiv2DEdge_Wrapper_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvSubdiv2DEdge_Wrapper::~CvSubdiv2DEdge_Wrapper (@var{self})\n\ +@var{self} is of type CvSubdiv2DEdge_Wrapper. \n\ +@end deftypefn"; +const char* _wrap_new_CvSubdiv2DEdge_Wrapper_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvSubdiv2DEdge_Wrapper (@var{val})\n\ +@var{val} is of type CvSubdiv2DEdge. @var{retval} is of type CvSubdiv2DEdge_Wrapper. \n\ +@end deftypefn"; +const char* _wrap_delete_CvRNG_Wrapper_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvRNG_Wrapper::~CvRNG_Wrapper (@var{self})\n\ +@var{self} is of type CvRNG_Wrapper. \n\ +@end deftypefn"; +const char* _wrap_new_CvRNG_Wrapper_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvRNG_Wrapper (@var{val})\n\ +@var{val} is of type CvRNG. @var{retval} is of type CvRNG_Wrapper. \n\ +@end deftypefn"; +const char* _wrap_cvCeil_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvCeil (@var{value})\n\ +@var{value} is of type double. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator_distance_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = distance (@var{self}, @var{x})\n\ +@var{self} is of type OctSwigIterator. @var{x} is of type OctSwigIterator. @var{retval} is of type ptrdiff_t. \n\ +@end deftypefn"; +const char* _wrap_cvSubdiv2DRotateEdge_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvSubdiv2DRotateEdge (@var{edge}, @var{rotate})\n\ +@var{edge} is of type CvSubdiv2DEdge. @var{rotate} is of type int. @var{retval} is of type CvSubdiv2DEdge. \n\ +@end deftypefn"; +const char* _wrap_cvPtr2D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPtr2D (@var{arr}, @var{idx0}, @var{idx1}, @var{type} = nil)\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{idx1} is of type int. @var{type} is of type int. @var{retval} is of type uchar. \n\ +@end deftypefn"; +const char* _wrap_cvBackProjectPCA_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvBackProjectPCA (@var{proj}, @var{mean}, @var{eigenvects}, @var{result})\n\ +@var{proj} is of type CvArr. @var{mean} is of type CvArr. @var{eigenvects} is of type CvArr. @var{result} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvProjectPCA_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvProjectPCA (@var{data}, @var{mean}, @var{eigenvects}, @var{result})\n\ +@var{data} is of type CvArr. @var{mean} is of type CvArr. @var{eigenvects} is of type CvArr. @var{result} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvReadByName_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvReadByName (@var{fs}, @var{map}, @var{name}, @var{attributes} = nil)\n\ +@var{fs} is of type CvFileStorage. @var{map} is of type CvFileNode. @var{name} is of type char. @var{attributes} is of type CvAttrList. @var{retval} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvReadRealByName_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvReadRealByName (@var{fs}, @var{map}, @var{name}, @var{default_value} = 0.)\n\ +@var{fs} is of type CvFileStorage. @var{map} is of type CvFileNode. @var{name} is of type char. @var{default_value} is of type double. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvReadIntByName_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvReadIntByName (@var{fs}, @var{map}, @var{name}, @var{default_value} = 0)\n\ +@var{fs} is of type CvFileStorage. @var{map} is of type CvFileNode. @var{name} is of type char. @var{default_value} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvRect_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvRect (@var{x}, @var{y}, @var{width}, @var{height})\n\ +@var{x} is of type int. @var{y} is of type int. @var{width} is of type int. @var{height} is of type int. @var{retval} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_cvGetND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetND (@var{arr}, @var{idx})\n\ +@var{arr} is of type CvArr. @var{idx} is of type int. @var{retval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvTrace_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvTrace (@var{mat})\n\ +@var{mat} is of type CvArr. @var{retval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvCompleteSymm_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCompleteSymm (@var{matrix}, @var{LtoR} = 0)\n\ +@var{matrix} is of type CvMat. @var{LtoR} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvLoad_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvLoad (@var{filename}, @var{memstorage} = nil, @var{name} = nil, @var{real_name} = nil)\n\ +@var{filename} is of type char. @var{memstorage} is of type CvMemStorage. @var{name} is of type char. @var{real_name} is of type char. @var{retval} is of type void. \n\ +@end deftypefn"; +const char* _wrap_IplImage___rgt___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rgt__ (@var{self}, @var{arg})\n\ +@var{self} is of type . @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvMat___rgt___texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = __rgt__ (@var{self}, @var{arg})\n\ +@var{self} is of type CvMat. @var{arg} is of type double. @var{retval} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_CvImage_data_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = data (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type uchar. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_cols_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cols (@var{self})\n\ +@var{self} is of type CvMatrix. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvGetRow_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetRow (@var{arr}, @var{submat}, @var{row})\n\ +@var{arr} is of type CvArr. @var{submat} is of type CvMat. @var{row} is of type int. @var{retval} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvQuadEdge2D_pop_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = pop (@var{self})\n\ +@var{self} is of type CvSeq_CvQuadEdge2D. @var{retval} is of type CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_UNIFORM_HIST_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_UNIFORM_HIST (@var{hist})\n\ +@var{hist} is of type CvHistogram. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_OctSwigIterator_incr_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = incr (@var{self})\n\ +@var{self} is of type OctSwigIterator. @var{retval} is of type OctSwigIterator. \n\ +@end deftypefn"; +const char* _wrap_cvPtr3D_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPtr3D (@var{arr}, @var{idx0}, @var{idx1}, @var{idx2}, @var{type} = nil)\n\ +@var{arr} is of type CvArr. @var{idx0} is of type int. @var{idx1} is of type int. @var{idx2} is of type int. @var{type} is of type int. @var{retval} is of type uchar. \n\ +@end deftypefn"; +const char* _wrap_new_CvPointVector_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = std::vector<(CvPoint)> (@var{size}, @var{value})\n\ +@var{size} is of type size_type. @var{value} is of type value_type. @var{retval} is of type CvPointVector. \n\ +@end deftypefn"; +const char* _wrap_delete_FloatVector_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} std::vector<(float)>::~vector<(float)> (@var{self})\n\ +@var{self} is of type FloatVector. \n\ +@end deftypefn"; +const char* _wrap_new_FloatVector_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = std::vector<(float)> (@var{size}, @var{value})\n\ +@var{size} is of type size_type. @var{value} is of type value_type. @var{retval} is of type FloatVector. \n\ +@end deftypefn"; +const char* _wrap_delete_CvPointVector_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} std::vector<(CvPoint)>::~vector<(CvPoint)> (@var{self})\n\ +@var{self} is of type CvPointVector. \n\ +@end deftypefn"; +const char* _wrap_cvOrS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvOrS (@var{src}, @var{value}, @var{dst}, @var{mask} = nil)\n\ +@var{src} is of type CvArr. @var{value} is of type CvScalar. @var{dst} is of type CvArr. @var{mask} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvInsertNodeIntoTree_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvInsertNodeIntoTree (@var{node}, @var{parent}, @var{frame})\n\ +@var{node} is of type void. @var{parent} is of type void. @var{frame} is of type void. \n\ +@end deftypefn"; +const char* _wrap_cvCornerEigenValsAndVecs_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvCornerEigenValsAndVecs (@var{image}, @var{eigenvv}, @var{block_size}, @var{aperture_size} = 3)\n\ +@var{image} is of type CvArr. @var{eigenvv} is of type CvArr. @var{block_size} is of type int. @var{aperture_size} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvUseOptimized_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvUseOptimized (@var{on_off})\n\ +@var{on_off} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CV_IS_STORAGE_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IS_STORAGE (@var{storage})\n\ +@var{storage} is of type CvMemStorage. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvTuple_CvPoint_2___brace_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __brace_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvTuple_CvPoint_2. @var{i} is of type int. @var{obj} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CvTuple_float_2___brace_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __brace_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvTuple_float_2. @var{i} is of type int. @var{obj} is of type float. \n\ +@end deftypefn"; +const char* _wrap_CvTuple_float_3___brace_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __brace_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvTuple_float_3. @var{i} is of type int. @var{obj} is of type float. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint___brace_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __brace_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvPoint. @var{i} is of type int. @var{obj} is of type CvPoint. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint2D32f___brace_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __brace_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvPoint2D32f. @var{i} is of type int. @var{obj} is of type CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvRect___brace_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __brace_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvRect. @var{i} is of type int. @var{obj} is of type CvRect. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvSeq___brace_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __brace_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvSeq. @var{i} is of type int. @var{obj} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvQuadEdge2D___brace_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __brace_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvQuadEdge2D. @var{i} is of type int. @var{obj} is of type CvQuadEdge2D. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvConnectedComp___brace_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __brace_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvConnectedComp. @var{i} is of type int. @var{obj} is of type CvConnectedComp. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_CvPoint_2___brace_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __brace_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_CvPoint_2. @var{i} is of type int. @var{obj} is of type CvTuple_CvPoint_2. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_2___brace_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __brace_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_float_2. @var{i} is of type int. @var{obj} is of type CvTuple_float_2. \n\ +@end deftypefn"; +const char* _wrap_CvSeq_float_3___brace_asgn_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} __brace_asgn (@var{self}, @var{i}, @var{obj})\n\ +@var{self} is of type CvSeq_float_3. @var{i} is of type int. @var{obj} is of type CvTuple_float_3. \n\ +@end deftypefn"; +const char* _wrap_cvReleaseHist_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvReleaseHist (@var{hist})\n\ +@var{hist} is of type CvHistogram. \n\ +@end deftypefn"; +const char* _wrap_cvWarpPerspective_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvWarpPerspective (@var{src}, @var{dst}, @var{map_matrix}, @var{flags} = 1+8, @var{fillval} = cvScalarAll(0))\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{map_matrix} is of type CvMat. @var{flags} is of type int. @var{fillval} is of type CvScalar. \n\ +@end deftypefn"; +const char* _wrap_cvInvert_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvInvert (@var{src}, @var{dst}, @var{method} = 0)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{method} is of type int. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvMulTransposed_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvMulTransposed (@var{src}, @var{dst}, @var{order}, @var{delta} = nil, @var{scale} = 1.)\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{order} is of type int. @var{delta} is of type CvArr. @var{scale} is of type double. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_pix_size_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = pix_size (@var{self})\n\ +@var{self} is of type CvMatrix. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_size_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = size (@var{self})\n\ +@var{self} is of type CvMatrix. @var{retval} is of type CvSize. \n\ +@end deftypefn"; +const char* _wrap_CvImage_pix_size_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = pix_size (@var{self})\n\ +@var{self} is of type CvImage. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_CvMatrix_show_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} show (@var{self}, @var{window_name})\n\ +@var{self} is of type CvMatrix. @var{window_name} is of type char. \n\ +@end deftypefn"; +const char* _wrap_cvIplDepth_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvIplDepth (@var{type})\n\ +@var{type} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_new_CvConnectedComp_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvConnectedComp::CvConnectedComp ()\n\ +@var{retval} is of type CvConnectedComp. \n\ +@end deftypefn"; +const char* _wrap_delete_CvConnectedComp_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvConnectedComp::~CvConnectedComp (@var{self})\n\ +@var{self} is of type CvConnectedComp. \n\ +@end deftypefn"; +const char* _wrap_new_CvSeq_CvConnectedComp_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvConnectedComp)>::CvTypedSeq<(CvConnectedComp)> ()\n\ +@var{retval} is of type CvSeq_CvConnectedComp. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSeq_CvConnectedComp_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTypedSeq<(CvConnectedComp)>::~CvTypedSeq<(CvConnectedComp)> (@var{self})\n\ +@var{self} is of type CvSeq_CvConnectedComp. \n\ +@end deftypefn"; +const char* _wrap_new_CvPoint2D32f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvPoint2D32f::CvPoint2D32f ()\n\ +@var{retval} is of type CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_delete_CvPoint2D32f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvPoint2D32f::~CvPoint2D32f (@var{self})\n\ +@var{self} is of type CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_cvPoint2D32f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvPoint2D32f (@var{x}, @var{y})\n\ +@var{x} is of type double. @var{y} is of type double. @var{retval} is of type CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_cvSetRealND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvSetRealND (@var{arr}, @var{idx}, @var{value})\n\ +@var{arr} is of type CvArr. @var{idx} is of type int. @var{value} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvGetRealND_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetRealND (@var{arr}, @var{idx})\n\ +@var{arr} is of type CvArr. @var{idx} is of type int. @var{retval} is of type double. \n\ +@end deftypefn"; +const char* _wrap_cvStartReadChainPoints_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvStartReadChainPoints (@var{chain}, @var{reader})\n\ +@var{chain} is of type CvChain. @var{reader} is of type CvChainPtReader. \n\ +@end deftypefn"; +const char* _wrap_cvFindDominantPoints_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvFindDominantPoints (@var{contour}, @var{storage}, @var{method} = 1, @var{parameter1} = 0, @var{parameter2} = 0, @var{parameter3} = 0, @var{parameter4} = 0)\n\ +@var{contour} is of type CvSeq. @var{storage} is of type CvMemStorage. @var{method} is of type int. @var{parameter1} is of type double. @var{parameter2} is of type double. @var{parameter3} is of type double. @var{parameter4} is of type double. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvBoxPoints_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvBoxPoints (@var{box}, @var{pt})\n\ +@var{box} is of type CvBox2D. @var{pt} is of type CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_cvGetStarKeypoints_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = cvGetStarKeypoints (@var{img}, @var{storage}, @var{params} = cvStarDetectorParams())\n\ +@var{img} is of type CvArr. @var{storage} is of type CvMemStorage. @var{params} is of type CvStarDetectorParams. @var{retval} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvUndistortPoints_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvUndistortPoints (@var{src}, @var{dst}, @var{camera_matrix}, @var{dist_coeffs}, @var{R} = 0, @var{P} = 0)\n\ +@var{src} is of type CvMat. @var{dst} is of type CvMat. @var{camera_matrix} is of type CvMat. @var{dist_coeffs} is of type CvMat. @var{R} is of type CvMat. @var{P} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_new_CvSeq_CvPoint2D32f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CvTypedSeq<(CvPoint2D32f)>::CvTypedSeq<(CvPoint2D32f)> ()\n\ +@var{retval} is of type CvSeq_CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_delete_CvSeq_CvPoint2D32f_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} CvTypedSeq<(CvPoint2D32f)>::~CvTypedSeq<(CvPoint2D32f)> (@var{self})\n\ +@var{self} is of type CvSeq_CvPoint2D32f. \n\ +@end deftypefn"; +const char* _wrap_CV_IMIN_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} @var{retval} = CV_IMIN (@var{a}, @var{b})\n\ +@var{a} is of type int. @var{b} is of type int. @var{retval} is of type int. \n\ +@end deftypefn"; +const char* _wrap_cvClearSeq_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvClearSeq (@var{seq})\n\ +@var{seq} is of type CvSeq. \n\ +@end deftypefn"; +const char* _wrap_cvInRangeS_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvInRangeS (@var{src}, @var{lower}, @var{upper}, @var{dst})\n\ +@var{src} is of type CvArr. @var{lower} is of type CvScalar. @var{upper} is of type CvScalar. @var{dst} is of type CvArr. \n\ +@end deftypefn"; +const char* _wrap_cvGetQuadrangleSubPix_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvGetQuadrangleSubPix (@var{src}, @var{dst}, @var{map_matrix})\n\ +@var{src} is of type CvArr. @var{dst} is of type CvArr. @var{map_matrix} is of type CvMat. \n\ +@end deftypefn"; +const char* _wrap_cvClearSet_texinfo = "-*- texinfo -*-\n\ +@deftypefn {Loadable Function} cvClearSet (@var{set_header})\n\ +@var{set_header} is of type CvSet. \n\ +@end deftypefn"; + +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_delete_OctSwigIterator (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 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_OctSwigIterator",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OctSwigIterator" "', argument " "1"" of type '" "swig::OctSwigIterator *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + delete arg1; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator_value (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 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("OctSwigIterator_value",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator_value" "', argument " "1"" of type '" "swig::OctSwigIterator const *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + try { + result = ((swig::OctSwigIterator const *)arg1)->value(); + } + catch(swig::stop_iteration &_e) { + { + error("stop_iteration exception"); + SWIG_fail; + } + } + + _outv = result; + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator_incr__SWIG_0 (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + swig::OctSwigIterator *result = 0 ; + + if (!SWIG_check_num_args("OctSwigIterator_incr",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator_incr" "', argument " "1"" of type '" "swig::OctSwigIterator *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + ecode2 = SWIG_AsVal_size_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OctSwigIterator_incr" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = (size_t)(val2); + try { + result = (swig::OctSwigIterator *)(arg1)->incr(arg2); + } + catch(swig::stop_iteration &_e) { + { + error("stop_iteration exception"); + SWIG_fail; + } + } + + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator_incr__SWIG_1 (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + swig::OctSwigIterator *result = 0 ; + + if (!SWIG_check_num_args("OctSwigIterator_incr",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator_incr" "', argument " "1"" of type '" "swig::OctSwigIterator *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + try { + result = (swig::OctSwigIterator *)(arg1)->incr(); + } + catch(swig::stop_iteration &_e) { + { + error("stop_iteration exception"); + SWIG_fail; + } + } + + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator_incr (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_swig__OctSwigIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_OctSwigIterator_incr__SWIG_1(args, nargout); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__OctSwigIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_OctSwigIterator_incr__SWIG_0(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_OctSwigIterator_decr__SWIG_0 (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + swig::OctSwigIterator *result = 0 ; + + if (!SWIG_check_num_args("OctSwigIterator_decr",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator_decr" "', argument " "1"" of type '" "swig::OctSwigIterator *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + ecode2 = SWIG_AsVal_size_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OctSwigIterator_decr" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = (size_t)(val2); + try { + result = (swig::OctSwigIterator *)(arg1)->decr(arg2); + } + catch(swig::stop_iteration &_e) { + { + error("stop_iteration exception"); + SWIG_fail; + } + } + + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator_decr__SWIG_1 (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + swig::OctSwigIterator *result = 0 ; + + if (!SWIG_check_num_args("OctSwigIterator_decr",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator_decr" "', argument " "1"" of type '" "swig::OctSwigIterator *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + try { + result = (swig::OctSwigIterator *)(arg1)->decr(); + } + catch(swig::stop_iteration &_e) { + { + error("stop_iteration exception"); + SWIG_fail; + } + } + + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator_decr (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_swig__OctSwigIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_OctSwigIterator_decr__SWIG_1(args, nargout); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__OctSwigIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_OctSwigIterator_decr__SWIG_0(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_OctSwigIterator_distance (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + swig::OctSwigIterator *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; + ptrdiff_t result; + + if (!SWIG_check_num_args("OctSwigIterator_distance",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator_distance" "', argument " "1"" of type '" "swig::OctSwigIterator const *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_swig__OctSwigIterator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OctSwigIterator_distance" "', argument " "2"" of type '" "swig::OctSwigIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OctSwigIterator_distance" "', argument " "2"" of type '" "swig::OctSwigIterator const &""'"); + } + arg2 = (swig::OctSwigIterator *)(argp2); + try { + result = ((swig::OctSwigIterator const *)arg1)->distance((swig::OctSwigIterator const &)*arg2); + } + catch(std::invalid_argument &_e) { + error("C++ side threw an exception of type " "std::invalid_argument"); SWIG_fail; + } + + _outv = SWIG_From_ptrdiff_t((ptrdiff_t)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator_equal (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + swig::OctSwigIterator *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("OctSwigIterator_equal",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator_equal" "', argument " "1"" of type '" "swig::OctSwigIterator const *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_swig__OctSwigIterator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OctSwigIterator_equal" "', argument " "2"" of type '" "swig::OctSwigIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OctSwigIterator_equal" "', argument " "2"" of type '" "swig::OctSwigIterator const &""'"); + } + arg2 = (swig::OctSwigIterator *)(argp2); + try { + result = (bool)((swig::OctSwigIterator const *)arg1)->equal((swig::OctSwigIterator const &)*arg2); + } + catch(std::invalid_argument &_e) { + error("C++ side threw an exception of type " "std::invalid_argument"); 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_OctSwigIterator_copy (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + swig::OctSwigIterator *result = 0 ; + + if (!SWIG_check_num_args("OctSwigIterator_copy",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator_copy" "', argument " "1"" of type '" "swig::OctSwigIterator const *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + result = (swig::OctSwigIterator *)((swig::OctSwigIterator const *)arg1)->copy(); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__OctSwigIterator, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator_next (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 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("OctSwigIterator_next",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator_next" "', argument " "1"" of type '" "swig::OctSwigIterator *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + try { + result = (arg1)->next(); + } + catch(swig::stop_iteration &_e) { + { + error("stop_iteration exception"); + SWIG_fail; + } + } + + _outv = result; + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator_previous (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 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("OctSwigIterator_previous",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator_previous" "', argument " "1"" of type '" "swig::OctSwigIterator *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + try { + result = (arg1)->previous(); + } + catch(swig::stop_iteration &_e) { + { + error("stop_iteration exception"); + SWIG_fail; + } + } + + _outv = result; + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator_advance (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + swig::OctSwigIterator *result = 0 ; + + if (!SWIG_check_num_args("OctSwigIterator_advance",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator_advance" "', argument " "1"" of type '" "swig::OctSwigIterator *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OctSwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = (ptrdiff_t)(val2); + try { + result = (swig::OctSwigIterator *)(arg1)->advance(arg2); + } + catch(swig::stop_iteration &_e) { + { + error("stop_iteration exception"); + SWIG_fail; + } + } + + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator___eq__ (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + swig::OctSwigIterator *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("OctSwigIterator___eq__",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator___eq__" "', argument " "1"" of type '" "swig::OctSwigIterator const *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_swig__OctSwigIterator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OctSwigIterator___eq__" "', argument " "2"" of type '" "swig::OctSwigIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OctSwigIterator___eq__" "', argument " "2"" of type '" "swig::OctSwigIterator const &""'"); + } + arg2 = (swig::OctSwigIterator *)(argp2); + result = (bool)((swig::OctSwigIterator const *)arg1)->operator ==((swig::OctSwigIterator 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_OctSwigIterator___ne__ (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + swig::OctSwigIterator *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("OctSwigIterator___ne__",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator___ne__" "', argument " "1"" of type '" "swig::OctSwigIterator const *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_swig__OctSwigIterator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OctSwigIterator___ne__" "', argument " "2"" of type '" "swig::OctSwigIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OctSwigIterator___ne__" "', argument " "2"" of type '" "swig::OctSwigIterator const &""'"); + } + arg2 = (swig::OctSwigIterator *)(argp2); + result = (bool)((swig::OctSwigIterator const *)arg1)->operator !=((swig::OctSwigIterator 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_OctSwigIterator___incr__ (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + swig::OctSwigIterator *result = 0 ; + + if (!SWIG_check_num_args("OctSwigIterator___incr__",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator___incr__" "', argument " "1"" of type '" "swig::OctSwigIterator *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + result = (swig::OctSwigIterator *)(arg1)->operator ++(); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator___decr__ (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + swig::OctSwigIterator *result = 0 ; + + if (!SWIG_check_num_args("OctSwigIterator___decr__",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator___decr__" "', argument " "1"" of type '" "swig::OctSwigIterator *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + result = (swig::OctSwigIterator *)(arg1)->operator --(); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator___add__ (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + swig::OctSwigIterator *result = 0 ; + + if (!SWIG_check_num_args("OctSwigIterator___add__",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator___add__" "', argument " "1"" of type '" "swig::OctSwigIterator const *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OctSwigIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = (ptrdiff_t)(val2); + try { + result = (swig::OctSwigIterator *)((swig::OctSwigIterator const *)arg1)->operator +(arg2); + } + catch(swig::stop_iteration &_e) { + { + error("stop_iteration exception"); + SWIG_fail; + } + } + + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__OctSwigIterator, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator___sub____SWIG_0 (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + swig::OctSwigIterator *result = 0 ; + + if (!SWIG_check_num_args("OctSwigIterator___sub__",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator___sub__" "', argument " "1"" of type '" "swig::OctSwigIterator const *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OctSwigIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = (ptrdiff_t)(val2); + try { + result = (swig::OctSwigIterator *)((swig::OctSwigIterator const *)arg1)->operator -(arg2); + } + catch(swig::stop_iteration &_e) { + { + error("stop_iteration exception"); + SWIG_fail; + } + } + + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__OctSwigIterator, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator___sub____SWIG_1 (const octave_value_list& args, int nargout) { + swig::OctSwigIterator *arg1 = (swig::OctSwigIterator *) 0 ; + swig::OctSwigIterator *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; + ptrdiff_t result; + + if (!SWIG_check_num_args("OctSwigIterator___sub__",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_swig__OctSwigIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OctSwigIterator___sub__" "', argument " "1"" of type '" "swig::OctSwigIterator const *""'"); + } + arg1 = (swig::OctSwigIterator *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_swig__OctSwigIterator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OctSwigIterator___sub__" "', argument " "2"" of type '" "swig::OctSwigIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OctSwigIterator___sub__" "', argument " "2"" of type '" "swig::OctSwigIterator const &""'"); + } + arg2 = (swig::OctSwigIterator *)(argp2); + result = ((swig::OctSwigIterator const *)arg1)->operator -((swig::OctSwigIterator const &)*arg2); + _outv = SWIG_From_ptrdiff_t((ptrdiff_t)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_OctSwigIterator___sub__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__OctSwigIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_swig__OctSwigIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_OctSwigIterator___sub____SWIG_1(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__OctSwigIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_OctSwigIterator___sub____SWIG_0(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static swig_octave_member swig_OctSwigIterator_members[] = { +{"value",_wrap_OctSwigIterator_value,0,0,0,0}, +{"incr",_wrap_OctSwigIterator_incr,0,0,0,0}, +{"decr",_wrap_OctSwigIterator_decr,0,0,0,0}, +{"distance",_wrap_OctSwigIterator_distance,0,0,0,0}, +{"equal",_wrap_OctSwigIterator_equal,0,0,0,0}, +{"copy",_wrap_OctSwigIterator_copy,0,0,0,0}, +{"next",_wrap_OctSwigIterator_next,0,0,0,0}, +{"previous",_wrap_OctSwigIterator_previous,0,0,0,0}, +{"advance",_wrap_OctSwigIterator_advance,0,0,0,0}, +{"__eq__",_wrap_OctSwigIterator___eq__,0,0,0,0}, +{"__ne__",_wrap_OctSwigIterator___ne__,0,0,0,0}, +{"__incr__",_wrap_OctSwigIterator___incr__,0,0,0,0}, +{"__decr__",_wrap_OctSwigIterator___decr__,0,0,0,0}, +{"__add__",_wrap_OctSwigIterator___add__,0,0,0,0}, +{"__sub__",_wrap_OctSwigIterator___sub__,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_OctSwigIterator_base_names[] = {0}; +static const swig_type_info *swig_OctSwigIterator_base[] = {0}; +static swig_octave_class _wrap_class_OctSwigIterator = {"OctSwigIterator", &SWIGTYPE_p_swig__OctSwigIterator,0,0,0,_wrap_delete_OctSwigIterator,swig_OctSwigIterator_members,swig_OctSwigIterator_base_names,swig_OctSwigIterator_base }; + +static octave_value_list _wrap_FloatVector_pop (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float >::value_type result; + + if (!SWIG_check_num_args("FloatVector_pop",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_pop" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + try { + result = (std::vector< float >::value_type)std_vector_Sl_float_Sg__pop(arg1); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector___paren__ (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float >::value_type result; + + if (!SWIG_check_num_args("FloatVector___paren__",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___paren__" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___paren__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'"); + } + arg2 = (std::vector< float >::difference_type)(val2); + try { + result = (std::vector< float >::value_type)std_vector_Sl_float_Sg____paren__(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector___paren_asgn__ (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::difference_type arg2 ; + std::vector< float >::value_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + float val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("FloatVector___paren_asgn__",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___paren_asgn__" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___paren_asgn__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'"); + } + arg2 = (std::vector< float >::difference_type)(val2); + ecode3 = SWIG_AsVal_float(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector___paren_asgn__" "', argument " "3"" of type '" "std::vector< float >::value_type""'"); + } + arg3 = (std::vector< float >::value_type)(val3); + try { + std_vector_Sl_float_Sg____paren_asgn__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_append (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::value_type 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("FloatVector_append",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_append" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_append" "', argument " "2"" of type '" "std::vector< float >::value_type""'"); + } + arg2 = (std::vector< float >::value_type)(val2); + std_vector_Sl_float_Sg__append(arg1,arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_FloatVector__SWIG_0 (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float > *result = 0 ; + + if (!SWIG_check_num_args("new_FloatVector",args.length(),0,0,0)) { + SWIG_fail; + } + result = (std::vector< float > *)new std::vector< float >(); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_FloatVector__SWIG_1 (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float > *result = 0 ; + + if (!SWIG_check_num_args("new_FloatVector",args.length(),1,1,0)) { + SWIG_fail; + } + { + std::vector > *ptr = (std::vector > *)0; + res1 = swig::asptr(args(0), &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatVector" "', argument " "1"" of type '" "std::vector< float > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatVector" "', argument " "1"" of type '" "std::vector< float > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< float > *)new std::vector< float >((std::vector< float > const &)*arg1); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (SWIG_IsNewObj(res1)) delete arg1; +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_empty (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 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("FloatVector_empty",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_empty" "', argument " "1"" of type '" "std::vector< float > const *""'"); + } + arg1 = (std::vector< float > *)(argp1); + result = (bool)((std::vector< float > const *)arg1)->empty(); + _outv = SWIG_From_bool((bool)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_size (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float >::size_type result; + + if (!SWIG_check_num_args("FloatVector_size",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_size" "', argument " "1"" of type '" "std::vector< float > const *""'"); + } + arg1 = (std::vector< float > *)(argp1); + result = ((std::vector< float > const *)arg1)->size(); + _outv = SWIG_From_size_t((size_t)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_clear (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("FloatVector_clear",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_clear" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + (arg1)->clear(); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_swap (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float > *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; + + if (!SWIG_check_num_args("FloatVector_swap",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_swap" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatVector_swap" "', argument " "2"" of type '" "std::vector< float > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatVector_swap" "', argument " "2"" of type '" "std::vector< float > &""'"); + } + arg2 = (std::vector< float > *)(argp2); + (arg1)->swap(*arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_get_allocator (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + SwigValueWrapper< std::allocator< float > > result; + + if (!SWIG_check_num_args("FloatVector_get_allocator",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_get_allocator" "', argument " "1"" of type '" "std::vector< float > const *""'"); + } + arg1 = (std::vector< float > *)(argp1); + result = ((std::vector< float > const *)arg1)->get_allocator(); + _outv = SWIG_NewPointerObj((new std::vector< float >::allocator_type((const std::vector< float >::allocator_type&)(result))), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_begin (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float >::const_iterator result; + + if (!SWIG_check_num_args("FloatVector_begin",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_begin" "', argument " "1"" of type '" "std::vector< float > const *""'"); + } + arg1 = (std::vector< float > *)(argp1); + result = ((std::vector< float > const *)arg1)->begin(); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< float >::const_iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_end (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float >::const_iterator result; + + if (!SWIG_check_num_args("FloatVector_end",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_end" "', argument " "1"" of type '" "std::vector< float > const *""'"); + } + arg1 = (std::vector< float > *)(argp1); + result = ((std::vector< float > const *)arg1)->end(); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< float >::const_iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_rbegin (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float >::const_reverse_iterator result; + + if (!SWIG_check_num_args("FloatVector_rbegin",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_rbegin" "', argument " "1"" of type '" "std::vector< float > const *""'"); + } + arg1 = (std::vector< float > *)(argp1); + result = ((std::vector< float > const *)arg1)->rbegin(); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< float >::const_reverse_iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_rend (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float >::const_reverse_iterator result; + + if (!SWIG_check_num_args("FloatVector_rend",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_rend" "', argument " "1"" of type '" "std::vector< float > const *""'"); + } + arg1 = (std::vector< float > *)(argp1); + result = ((std::vector< float > const *)arg1)->rend(); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< float >::const_reverse_iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_FloatVector__SWIG_2 (const octave_value_list& args, int nargout) { + std::vector< float >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float > *result = 0 ; + + if (!SWIG_check_num_args("new_FloatVector",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_FloatVector" "', argument " "1"" of type '" "std::vector< float >::size_type""'"); + } + arg1 = (std::vector< float >::size_type)(val1); + result = (std::vector< float > *)new std::vector< float >(arg1); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_pop_back (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("FloatVector_pop_back",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_pop_back" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + (arg1)->pop_back(); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_resize__SWIG_0 (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("FloatVector_resize",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_resize" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + ecode2 = SWIG_AsVal_size_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_resize" "', argument " "2"" of type '" "std::vector< float >::size_type""'"); + } + arg2 = (std::vector< float >::size_type)(val2); + (arg1)->resize(arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_erase__SWIG_0 (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::iterator arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::OctSwigIterator *iter2 = 0 ; + int res2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float >::iterator result; + + if (!SWIG_check_num_args("FloatVector_erase",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_erase" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), SWIG_as_voidptrptr(&iter2), swig::OctSwigIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_erase" "', argument " "2"" of type '" "std::vector< float >::iterator""'"); + } else { + swig::OctSwigIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_erase" "', argument " "2"" of type '" "std::vector< float >::iterator""'"); + } + } + result = (arg1)->erase(arg2); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< float >::iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_erase__SWIG_1 (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::iterator arg2 ; + std::vector< float >::iterator arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::OctSwigIterator *iter2 = 0 ; + int res2 ; + swig::OctSwigIterator *iter3 = 0 ; + int res3 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float >::iterator result; + + if (!SWIG_check_num_args("FloatVector_erase",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_erase" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), SWIG_as_voidptrptr(&iter2), swig::OctSwigIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_erase" "', argument " "2"" of type '" "std::vector< float >::iterator""'"); + } else { + swig::OctSwigIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_erase" "', argument " "2"" of type '" "std::vector< float >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(args(2), SWIG_as_voidptrptr(&iter3), swig::OctSwigIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_erase" "', argument " "3"" of type '" "std::vector< float >::iterator""'"); + } else { + swig::OctSwigIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_erase" "', argument " "3"" of type '" "std::vector< float >::iterator""'"); + } + } + result = (arg1)->erase(arg2,arg3); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< float >::iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_erase (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; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::OctSwigIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_FloatVector_erase__SWIG_0(args, nargout); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::OctSwigIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + swig::OctSwigIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_FloatVector_erase__SWIG_1(args, nargout); + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_new_FloatVector__SWIG_3 (const octave_value_list& args, int nargout) { + std::vector< float >::size_type arg1 ; + std::vector< float >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + std::vector< float >::value_type temp2 ; + float val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float > *result = 0 ; + + if (!SWIG_check_num_args("new_FloatVector",args.length(),2,2,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_size_t(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FloatVector" "', argument " "1"" of type '" "std::vector< float >::size_type""'"); + } + arg1 = (std::vector< float >::size_type)(val1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatVector" "', argument " "2"" of type '" "std::vector< float >::value_type""'"); + } + temp2 = (std::vector< float >::value_type)(val2); + arg2 = &temp2; + result = (std::vector< float > *)new std::vector< float >(arg1,(std::vector< float >::value_type const &)*arg2); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_FloatVector (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_FloatVector__SWIG_0(args, nargout); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_FloatVector__SWIG_2(args, nargout); + } + } + if (argc == 1) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_FloatVector__SWIG_1(args, nargout); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_FloatVector__SWIG_3(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_FloatVector_push_back (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< float >::value_type temp2 ; + float val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("FloatVector_push_back",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_push_back" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_push_back" "', argument " "2"" of type '" "std::vector< float >::value_type""'"); + } + temp2 = (std::vector< float >::value_type)(val2); + arg2 = &temp2; + (arg1)->push_back((std::vector< float >::value_type const &)*arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_front (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float >::value_type *result = 0 ; + + if (!SWIG_check_num_args("FloatVector_front",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_front" "', argument " "1"" of type '" "std::vector< float > const *""'"); + } + arg1 = (std::vector< float > *)(argp1); + result = (std::vector< float >::value_type *) &((std::vector< float > const *)arg1)->front(); + _outv = SWIG_From_float((float)(*result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_back (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float >::value_type *result = 0 ; + + if (!SWIG_check_num_args("FloatVector_back",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_back" "', argument " "1"" of type '" "std::vector< float > const *""'"); + } + arg1 = (std::vector< float > *)(argp1); + result = (std::vector< float >::value_type *) &((std::vector< float > const *)arg1)->back(); + _outv = SWIG_From_float((float)(*result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_assign (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::size_type arg2 ; + std::vector< float >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< float >::value_type temp3 ; + float val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("FloatVector_assign",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_assign" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + ecode2 = SWIG_AsVal_size_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_assign" "', argument " "2"" of type '" "std::vector< float >::size_type""'"); + } + arg2 = (std::vector< float >::size_type)(val2); + ecode3 = SWIG_AsVal_float(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector_assign" "', argument " "3"" of type '" "std::vector< float >::value_type""'"); + } + temp3 = (std::vector< float >::value_type)(val3); + arg3 = &temp3; + (arg1)->assign(arg2,(std::vector< float >::value_type const &)*arg3); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_resize__SWIG_1 (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::size_type arg2 ; + std::vector< float >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< float >::value_type temp3 ; + float val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("FloatVector_resize",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_resize" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + ecode2 = SWIG_AsVal_size_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_resize" "', argument " "2"" of type '" "std::vector< float >::size_type""'"); + } + arg2 = (std::vector< float >::size_type)(val2); + ecode3 = SWIG_AsVal_float(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector_resize" "', argument " "3"" of type '" "std::vector< float >::value_type""'"); + } + temp3 = (std::vector< float >::value_type)(val3); + arg3 = &temp3; + (arg1)->resize(arg2,(std::vector< float >::value_type const &)*arg3); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_resize (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; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FloatVector_resize__SWIG_0(args, nargout); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FloatVector_resize__SWIG_1(args, nargout); + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_FloatVector_insert__SWIG_0 (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::iterator arg2 ; + std::vector< float >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::OctSwigIterator *iter2 = 0 ; + int res2 ; + std::vector< float >::value_type temp3 ; + float val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float >::iterator result; + + if (!SWIG_check_num_args("FloatVector_insert",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_insert" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), SWIG_as_voidptrptr(&iter2), swig::OctSwigIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_insert" "', argument " "2"" of type '" "std::vector< float >::iterator""'"); + } else { + swig::OctSwigIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_insert" "', argument " "2"" of type '" "std::vector< float >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_float(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector_insert" "', argument " "3"" of type '" "std::vector< float >::value_type""'"); + } + temp3 = (std::vector< float >::value_type)(val3); + arg3 = &temp3; + result = (arg1)->insert(arg2,(std::vector< float >::value_type const &)*arg3); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< float >::iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_insert__SWIG_1 (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::iterator arg2 ; + std::vector< float >::size_type arg3 ; + std::vector< float >::value_type *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::OctSwigIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + std::vector< float >::value_type temp4 ; + float val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("FloatVector_insert",args.length(),4,4,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_insert" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), SWIG_as_voidptrptr(&iter2), swig::OctSwigIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_insert" "', argument " "2"" of type '" "std::vector< float >::iterator""'"); + } else { + swig::OctSwigIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "FloatVector_insert" "', argument " "2"" of type '" "std::vector< float >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_size_t(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector_insert" "', argument " "3"" of type '" "std::vector< float >::size_type""'"); + } + arg3 = (std::vector< float >::size_type)(val3); + ecode4 = SWIG_AsVal_float(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatVector_insert" "', argument " "4"" of type '" "std::vector< float >::value_type""'"); + } + temp4 = (std::vector< float >::value_type)(val4); + arg4 = &temp4; + (arg1)->insert(arg2,arg3,(std::vector< float >::value_type const &)*arg4); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_insert (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; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::OctSwigIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_float(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FloatVector_insert__SWIG_0(args, nargout); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::OctSwigIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FloatVector_insert__SWIG_1(args, nargout); + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_FloatVector_reserve (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("FloatVector_reserve",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_reserve" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(argp1); + ecode2 = SWIG_AsVal_size_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_reserve" "', argument " "2"" of type '" "std::vector< float >::size_type""'"); + } + arg2 = (std::vector< float >::size_type)(val2); + (arg1)->reserve(arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_FloatVector_capacity (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< float >::size_type result; + + if (!SWIG_check_num_args("FloatVector_capacity",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_capacity" "', argument " "1"" of type '" "std::vector< float > const *""'"); + } + arg1 = (std::vector< float > *)(argp1); + result = ((std::vector< float > const *)arg1)->capacity(); + _outv = SWIG_From_size_t((size_t)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_FloatVector (const octave_value_list& args, int nargout) { + std::vector< float > *arg1 = (std::vector< float > *) 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_FloatVector",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatVector" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = (std::vector< float > *)(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_FloatVector_members[] = { +{"pop",_wrap_FloatVector_pop,0,0,0,0}, +{"__paren__",_wrap_FloatVector___paren__,0,0,0,0}, +{"__paren_asgn__",_wrap_FloatVector___paren_asgn__,0,0,0,0}, +{"append",_wrap_FloatVector_append,0,0,0,0}, +{"empty",_wrap_FloatVector_empty,0,0,0,0}, +{"size",_wrap_FloatVector_size,0,0,0,0}, +{"clear",_wrap_FloatVector_clear,0,0,0,0}, +{"swap",_wrap_FloatVector_swap,0,0,0,0}, +{"get_allocator",_wrap_FloatVector_get_allocator,0,0,0,0}, +{"begin",_wrap_FloatVector_begin,0,0,0,0}, +{"end",_wrap_FloatVector_end,0,0,0,0}, +{"rbegin",_wrap_FloatVector_rbegin,0,0,0,0}, +{"rend",_wrap_FloatVector_rend,0,0,0,0}, +{"pop_back",_wrap_FloatVector_pop_back,0,0,0,0}, +{"erase",_wrap_FloatVector_erase,0,0,0,0}, +{"push_back",_wrap_FloatVector_push_back,0,0,0,0}, +{"front",_wrap_FloatVector_front,0,0,0,0}, +{"back",_wrap_FloatVector_back,0,0,0,0}, +{"assign",_wrap_FloatVector_assign,0,0,0,0}, +{"resize",_wrap_FloatVector_resize,0,0,0,0}, +{"insert",_wrap_FloatVector_insert,0,0,0,0}, +{"reserve",_wrap_FloatVector_reserve,0,0,0,0}, +{"capacity",_wrap_FloatVector_capacity,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_FloatVector_base_names[] = {0}; +static const swig_type_info *swig_FloatVector_base[] = {0}; +static swig_octave_class _wrap_class_FloatVector = {"FloatVector", &SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t,0,_wrap_new_FloatVector,0,_wrap_delete_FloatVector,swig_FloatVector_members,swig_FloatVector_base_names,swig_FloatVector_base }; + +static octave_value_list _wrap_CvPointVector_pop (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint >::value_type result; + + if (!SWIG_check_num_args("CvPointVector_pop",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_pop" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + try { + result = std_vector_Sl_CvPoint_Sg__pop(arg1); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + _outv = SWIG_NewPointerObj((new std::vector< CvPoint >::value_type((const std::vector< CvPoint >::value_type&)(result))), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector___paren__ (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + std::vector< CvPoint >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint >::value_type result; + + if (!SWIG_check_num_args("CvPointVector___paren__",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector___paren__" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector___paren__" "', argument " "2"" of type '" "std::vector< CvPoint >::difference_type""'"); + } + arg2 = (std::vector< CvPoint >::difference_type)(val2); + try { + result = std_vector_Sl_CvPoint_Sg____paren__(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + _outv = SWIG_NewPointerObj((new std::vector< CvPoint >::value_type((const std::vector< CvPoint >::value_type&)(result))), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector___paren_asgn__ (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + std::vector< CvPoint >::difference_type arg2 ; + std::vector< CvPoint >::value_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvPointVector___paren_asgn__",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector___paren_asgn__" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector___paren_asgn__" "', argument " "2"" of type '" "std::vector< CvPoint >::difference_type""'"); + } + arg2 = (std::vector< CvPoint >::difference_type)(val2); + { + arg3 = OctObject_to_CvPoint(args(2)); + } + try { + std_vector_Sl_CvPoint_Sg____paren_asgn__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_append (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + std::vector< CvPoint >::value_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvPointVector_append",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_append" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + { + arg2 = OctObject_to_CvPoint(args(1)); + } + std_vector_Sl_CvPoint_Sg__append(arg1,arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvPointVector__SWIG_0 (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint > *result = 0 ; + + if (!SWIG_check_num_args("new_CvPointVector",args.length(),0,0,0)) { + SWIG_fail; + } + result = (std::vector< CvPoint > *)new std::vector< CvPoint >(); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvPointVector__SWIG_1 (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint > *result = 0 ; + + if (!SWIG_check_num_args("new_CvPointVector",args.length(),1,1,0)) { + SWIG_fail; + } + { + std::vector > *ptr = (std::vector > *)0; + res1 = swig::asptr(args(0), &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvPointVector" "', argument " "1"" of type '" "std::vector< CvPoint > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvPointVector" "', argument " "1"" of type '" "std::vector< CvPoint > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< CvPoint > *)new std::vector< CvPoint >((std::vector< CvPoint > const &)*arg1); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (SWIG_IsNewObj(res1)) delete arg1; +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_empty (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 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("CvPointVector_empty",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_empty" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + result = (bool)((std::vector< CvPoint > const *)arg1)->empty(); + _outv = SWIG_From_bool((bool)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_size (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint >::size_type result; + + if (!SWIG_check_num_args("CvPointVector_size",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_size" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + result = ((std::vector< CvPoint > const *)arg1)->size(); + _outv = SWIG_From_size_t((size_t)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_clear (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvPointVector_clear",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_clear" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + (arg1)->clear(); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_swap (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + std::vector< CvPoint > *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; + + if (!SWIG_check_num_args("CvPointVector_swap",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_swap" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvPointVector_swap" "', argument " "2"" of type '" "std::vector< CvPoint > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector_swap" "', argument " "2"" of type '" "std::vector< CvPoint > &""'"); + } + arg2 = (std::vector< CvPoint > *)(argp2); + (arg1)->swap(*arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_get_allocator (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + SwigValueWrapper< std::allocator< CvPoint > > result; + + if (!SWIG_check_num_args("CvPointVector_get_allocator",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_get_allocator" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + result = ((std::vector< CvPoint > const *)arg1)->get_allocator(); + _outv = SWIG_NewPointerObj((new std::vector< CvPoint >::allocator_type((const std::vector< CvPoint >::allocator_type&)(result))), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_begin (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint >::const_iterator result; + + if (!SWIG_check_num_args("CvPointVector_begin",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_begin" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + result = ((std::vector< CvPoint > const *)arg1)->begin(); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< CvPoint >::const_iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_end (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint >::const_iterator result; + + if (!SWIG_check_num_args("CvPointVector_end",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_end" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + result = ((std::vector< CvPoint > const *)arg1)->end(); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< CvPoint >::const_iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_rbegin (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint >::const_reverse_iterator result; + + if (!SWIG_check_num_args("CvPointVector_rbegin",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_rbegin" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + result = ((std::vector< CvPoint > const *)arg1)->rbegin(); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< CvPoint >::const_reverse_iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_rend (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint >::const_reverse_iterator result; + + if (!SWIG_check_num_args("CvPointVector_rend",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_rend" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + result = ((std::vector< CvPoint > const *)arg1)->rend(); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< CvPoint >::const_reverse_iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvPointVector__SWIG_2 (const octave_value_list& args, int nargout) { + std::vector< CvPoint >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint > *result = 0 ; + + if (!SWIG_check_num_args("new_CvPointVector",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_CvPointVector" "', argument " "1"" of type '" "std::vector< CvPoint >::size_type""'"); + } + arg1 = (std::vector< CvPoint >::size_type)(val1); + result = (std::vector< CvPoint > *)new std::vector< CvPoint >(arg1); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_pop_back (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvPointVector_pop_back",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_pop_back" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + (arg1)->pop_back(); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_resize__SWIG_0 (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + std::vector< CvPoint >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvPointVector_resize",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_resize" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + ecode2 = SWIG_AsVal_size_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector_resize" "', argument " "2"" of type '" "std::vector< CvPoint >::size_type""'"); + } + arg2 = (std::vector< CvPoint >::size_type)(val2); + (arg1)->resize(arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_erase__SWIG_0 (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + std::vector< CvPoint >::iterator arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::OctSwigIterator *iter2 = 0 ; + int res2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint >::iterator result; + + if (!SWIG_check_num_args("CvPointVector_erase",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_erase" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), SWIG_as_voidptrptr(&iter2), swig::OctSwigIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_erase" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'"); + } else { + swig::OctSwigIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_erase" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'"); + } + } + result = (arg1)->erase(arg2); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< CvPoint >::iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_erase__SWIG_1 (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + std::vector< CvPoint >::iterator arg2 ; + std::vector< CvPoint >::iterator arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::OctSwigIterator *iter2 = 0 ; + int res2 ; + swig::OctSwigIterator *iter3 = 0 ; + int res3 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint >::iterator result; + + if (!SWIG_check_num_args("CvPointVector_erase",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_erase" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), SWIG_as_voidptrptr(&iter2), swig::OctSwigIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_erase" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'"); + } else { + swig::OctSwigIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_erase" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(args(2), SWIG_as_voidptrptr(&iter3), swig::OctSwigIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_erase" "', argument " "3"" of type '" "std::vector< CvPoint >::iterator""'"); + } else { + swig::OctSwigIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_erase" "', argument " "3"" of type '" "std::vector< CvPoint >::iterator""'"); + } + } + result = (arg1)->erase(arg2,arg3); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< CvPoint >::iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_erase (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; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::OctSwigIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_CvPointVector_erase__SWIG_0(args, nargout); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::OctSwigIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + swig::OctSwigIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_CvPointVector_erase__SWIG_1(args, nargout); + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_new_CvPointVector__SWIG_3 (const octave_value_list& args, int nargout) { + std::vector< CvPoint >::size_type arg1 ; + std::vector< CvPoint >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + void *argp2 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint > *result = 0 ; + + if (!SWIG_check_num_args("new_CvPointVector",args.length(),2,2,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_size_t(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CvPointVector" "', argument " "1"" of type '" "std::vector< CvPoint >::size_type""'"); + } + arg1 = (std::vector< CvPoint >::size_type)(val1); + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvPointVector" "', argument " "2"" of type '" "std::vector< CvPoint >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvPointVector" "', argument " "2"" of type '" "std::vector< CvPoint >::value_type const &""'"); + } + arg2 = (std::vector< CvPoint >::value_type *)(argp2); + result = (std::vector< CvPoint > *)new std::vector< CvPoint >(arg1,(std::vector< CvPoint >::value_type const &)*arg2); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvPointVector (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_CvPointVector__SWIG_0(args, nargout); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_CvPointVector__SWIG_2(args, nargout); + } + } + if (argc == 1) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvPointVector__SWIG_1(args, nargout); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvPointVector__SWIG_3(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvPointVector_push_back (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + std::vector< CvPoint >::value_type *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; + + if (!SWIG_check_num_args("CvPointVector_push_back",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_push_back" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvPointVector_push_back" "', argument " "2"" of type '" "std::vector< CvPoint >::value_type const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector_push_back" "', argument " "2"" of type '" "std::vector< CvPoint >::value_type const &""'"); + } + arg2 = (std::vector< CvPoint >::value_type *)(argp2); + (arg1)->push_back((std::vector< CvPoint >::value_type const &)*arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_front (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint >::value_type *result = 0 ; + + if (!SWIG_check_num_args("CvPointVector_front",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_front" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + result = (std::vector< CvPoint >::value_type *) &((std::vector< CvPoint > const *)arg1)->front(); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_back (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint >::value_type *result = 0 ; + + if (!SWIG_check_num_args("CvPointVector_back",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_back" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + result = (std::vector< CvPoint >::value_type *) &((std::vector< CvPoint > const *)arg1)->back(); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_assign (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + std::vector< CvPoint >::size_type arg2 ; + std::vector< CvPoint >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + void *argp3 ; + int res3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvPointVector_assign",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_assign" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + ecode2 = SWIG_AsVal_size_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector_assign" "', argument " "2"" of type '" "std::vector< CvPoint >::size_type""'"); + } + arg2 = (std::vector< CvPoint >::size_type)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvPointVector_assign" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector_assign" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'"); + } + arg3 = (std::vector< CvPoint >::value_type *)(argp3); + (arg1)->assign(arg2,(std::vector< CvPoint >::value_type const &)*arg3); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_resize__SWIG_1 (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + std::vector< CvPoint >::size_type arg2 ; + std::vector< CvPoint >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + void *argp3 ; + int res3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvPointVector_resize",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_resize" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + ecode2 = SWIG_AsVal_size_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector_resize" "', argument " "2"" of type '" "std::vector< CvPoint >::size_type""'"); + } + arg2 = (std::vector< CvPoint >::size_type)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvPointVector_resize" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector_resize" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'"); + } + arg3 = (std::vector< CvPoint >::value_type *)(argp3); + (arg1)->resize(arg2,(std::vector< CvPoint >::value_type const &)*arg3); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_resize (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; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvPointVector_resize__SWIG_0(args, nargout); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvPointVector_resize__SWIG_1(args, nargout); + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvPointVector_insert__SWIG_0 (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + std::vector< CvPoint >::iterator arg2 ; + std::vector< CvPoint >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::OctSwigIterator *iter2 = 0 ; + int res2 ; + void *argp3 ; + int res3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint >::iterator result; + + if (!SWIG_check_num_args("CvPointVector_insert",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_insert" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), SWIG_as_voidptrptr(&iter2), swig::OctSwigIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_insert" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'"); + } else { + swig::OctSwigIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_insert" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvPointVector_insert" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector_insert" "', argument " "3"" of type '" "std::vector< CvPoint >::value_type const &""'"); + } + arg3 = (std::vector< CvPoint >::value_type *)(argp3); + result = (arg1)->insert(arg2,(std::vector< CvPoint >::value_type const &)*arg3); + _outv = SWIG_NewPointerObj(swig::make_output_iterator((const std::vector< CvPoint >::iterator &)(result)), + swig::OctSwigIterator::descriptor(),SWIG_POINTER_OWN); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_insert__SWIG_1 (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + std::vector< CvPoint >::iterator arg2 ; + std::vector< CvPoint >::size_type arg3 ; + std::vector< CvPoint >::value_type *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::OctSwigIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + void *argp4 ; + int res4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvPointVector_insert",args.length(),4,4,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_insert" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), SWIG_as_voidptrptr(&iter2), swig::OctSwigIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_insert" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'"); + } else { + swig::OctSwigIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CvPointVector_insert" "', argument " "2"" of type '" "std::vector< CvPoint >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_size_t(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvPointVector_insert" "', argument " "3"" of type '" "std::vector< CvPoint >::size_type""'"); + } + arg3 = (std::vector< CvPoint >::size_type)(val3); + res4 = SWIG_ConvertPtr(args(3), &argp4, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvPointVector_insert" "', argument " "4"" of type '" "std::vector< CvPoint >::value_type const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvPointVector_insert" "', argument " "4"" of type '" "std::vector< CvPoint >::value_type const &""'"); + } + arg4 = (std::vector< CvPoint >::value_type *)(argp4); + (arg1)->insert(arg2,arg3,(std::vector< CvPoint >::value_type const &)*arg4); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_insert (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; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::OctSwigIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvPointVector_insert__SWIG_0(args, nargout); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::OctSwigIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::OctSwigIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvPointVector_insert__SWIG_1(args, nargout); + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvPointVector_reserve (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + std::vector< CvPoint >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvPointVector_reserve",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_reserve" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + ecode2 = SWIG_AsVal_size_t(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPointVector_reserve" "', argument " "2"" of type '" "std::vector< CvPoint >::size_type""'"); + } + arg2 = (std::vector< CvPoint >::size_type)(val2); + (arg1)->reserve(arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPointVector_capacity (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint >::size_type result; + + if (!SWIG_check_num_args("CvPointVector_capacity",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPointVector_capacity" "', argument " "1"" of type '" "std::vector< CvPoint > const *""'"); + } + arg1 = (std::vector< CvPoint > *)(argp1); + result = ((std::vector< CvPoint > const *)arg1)->capacity(); + _outv = SWIG_From_size_t((size_t)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvPointVector (const octave_value_list& args, int nargout) { + std::vector< CvPoint > *arg1 = (std::vector< CvPoint > *) 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_CvPointVector",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPointVector" "', argument " "1"" of type '" "std::vector< CvPoint > *""'"); + } + arg1 = (std::vector< CvPoint > *)(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_CvPointVector_members[] = { +{"pop",_wrap_CvPointVector_pop,0,0,0,0}, +{"__paren__",_wrap_CvPointVector___paren__,0,0,0,0}, +{"__paren_asgn__",_wrap_CvPointVector___paren_asgn__,0,0,0,0}, +{"append",_wrap_CvPointVector_append,0,0,0,0}, +{"empty",_wrap_CvPointVector_empty,0,0,0,0}, +{"size",_wrap_CvPointVector_size,0,0,0,0}, +{"clear",_wrap_CvPointVector_clear,0,0,0,0}, +{"swap",_wrap_CvPointVector_swap,0,0,0,0}, +{"get_allocator",_wrap_CvPointVector_get_allocator,0,0,0,0}, +{"begin",_wrap_CvPointVector_begin,0,0,0,0}, +{"end",_wrap_CvPointVector_end,0,0,0,0}, +{"rbegin",_wrap_CvPointVector_rbegin,0,0,0,0}, +{"rend",_wrap_CvPointVector_rend,0,0,0,0}, +{"pop_back",_wrap_CvPointVector_pop_back,0,0,0,0}, +{"erase",_wrap_CvPointVector_erase,0,0,0,0}, +{"push_back",_wrap_CvPointVector_push_back,0,0,0,0}, +{"front",_wrap_CvPointVector_front,0,0,0,0}, +{"back",_wrap_CvPointVector_back,0,0,0,0}, +{"assign",_wrap_CvPointVector_assign,0,0,0,0}, +{"resize",_wrap_CvPointVector_resize,0,0,0,0}, +{"insert",_wrap_CvPointVector_insert,0,0,0,0}, +{"reserve",_wrap_CvPointVector_reserve,0,0,0,0}, +{"capacity",_wrap_CvPointVector_capacity,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvPointVector_base_names[] = {0}; +static const swig_type_info *swig_CvPointVector_base[] = {0}; +static swig_octave_class _wrap_class_CvPointVector = {"CvPointVector", &SWIGTYPE_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t,0,_wrap_new_CvPointVector,0,_wrap_delete_CvPointVector,swig_CvPointVector_members,swig_CvPointVector_base_names,swig_CvPointVector_base }; + +static octave_value_list _wrap_cvCvtSeqToArray__SWIG_0 (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + CvSlice arg3 ; + void *ptr1 ; + bool freearg2 = false ; + void *argp3 ; + int res3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("cvCvtSeqToArray",args.length(),3,3,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_CvSlice, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCvtSeqToArray" "', argument " "3"" of type '" "CvSlice""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCvtSeqToArray" "', argument " "3"" of type '" "CvSlice""'"); + } else { + arg3 = *((CvSlice *)(argp3)); + } + } + result = (CvArr *)cvCvtSeqToArray_Shadow((CvSeq const *)arg1,arg2,arg3); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvCvtSeqToArray__SWIG_1 (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *ptr1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("cvCvtSeqToArray",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + result = (CvArr *)cvCvtSeqToArray_Shadow((CvSeq const *)arg1,arg2); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvCvtSeqToArray (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_CvSeq, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_cvCvtSeqToArray__SWIG_1(args, nargout); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSeq, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvSlice, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_cvCvtSeqToArray__SWIG_0(args, nargout); + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_cvArcLength__SWIG_0 (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + CvSlice arg2 ; + int arg3 ; + void *ptr1 ; + void *argp2 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + double result; + + if (!SWIG_check_num_args("cvArcLength",args.length(),3,3,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSlice, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'"); + } else { + arg2 = *((CvSlice *)(argp2)); + } + } + ecode3 = SWIG_AsVal_int(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvArcLength" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + result = (double)cvArcLength_Shadow((CvSeq const *)arg1,arg2,arg3); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvArcLength__SWIG_1 (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + CvSlice arg2 ; + void *ptr1 ; + void *argp2 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + double result; + + if (!SWIG_check_num_args("cvArcLength",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSlice, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'"); + } else { + arg2 = *((CvSlice *)(argp2)); + } + } + result = (double)cvArcLength_Shadow((CvSeq const *)arg1,arg2); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvArcLength__SWIG_2 (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + double result; + + if (!SWIG_check_num_args("cvArcLength",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (double)cvArcLength_Shadow((CvSeq const *)arg1); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvArcLength__SWIG_3 (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvSlice arg2 ; + int arg3 ; + bool freearg1 = false ; + void *argp2 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + double result; + + if (!SWIG_check_num_args("cvArcLength",args.length(),3,3,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSlice, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'"); + } else { + arg2 = *((CvSlice *)(argp2)); + } + } + ecode3 = SWIG_AsVal_int(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvArcLength" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + result = (double)cvArcLength_Shadow((void const *)arg1,arg2,arg3); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvArcLength__SWIG_4 (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvSlice arg2 ; + bool freearg1 = false ; + void *argp2 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + double result; + + if (!SWIG_check_num_args("cvArcLength",args.length(),2,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSlice, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvArcLength" "', argument " "2"" of type '" "CvSlice""'"); + } else { + arg2 = *((CvSlice *)(argp2)); + } + } + result = (double)cvArcLength_Shadow((void const *)arg1,arg2); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvArcLength__SWIG_5 (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + bool freearg1 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + double result; + + if (!SWIG_check_num_args("cvArcLength",args.length(),1,1,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + result = (double)cvArcLength_Shadow((void const *)arg1); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvArcLength (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 == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSeq, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_cvArcLength__SWIG_2(args, nargout); + } + } + if (argc == 1) { + int _v; + { + void *ptr; + if(OctList_Check(argv[0]) || OctTuple_Check(argv[0])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[0], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_cvArcLength__SWIG_5(args, nargout); + } + } + if (argc == 2) { + int _v; + { + void *ptr; + if(OctList_Check(argv[0]) || OctTuple_Check(argv[0])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[0], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvSlice, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_cvArcLength__SWIG_4(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSeq, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvSlice, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_cvArcLength__SWIG_1(args, nargout); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSeq, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvSlice, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_cvArcLength__SWIG_0(args, nargout); + } + } + } + } + if (argc == 3) { + int _v; + { + void *ptr; + if(OctList_Check(argv[0]) || OctTuple_Check(argv[0])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[0], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvSlice, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_cvArcLength__SWIG_3(args, nargout); + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_cvContourPerimeter__SWIG_0 (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + double result; + + if (!SWIG_check_num_args("cvContourPerimeter",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (double)cvContourPerimeter_Shadow(arg1); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvContourPerimeter__SWIG_1 (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + bool freearg1 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + double result; + + if (!SWIG_check_num_args("cvContourPerimeter",args.length(),1,1,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + result = (double)cvContourPerimeter_Shadow(arg1); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvContourPerimeter (const octave_value_list& args, int nargout) { + int argc = args.length(); + octave_value_ref argv[1]={ + octave_value_ref(args,0) + }; + + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvSeq, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_cvContourPerimeter__SWIG_0(args, nargout); + } + } + if (argc == 1) { + int _v; + { + void *ptr; + if(OctList_Check(argv[0]) || OctTuple_Check(argv[0])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[0], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_cvContourPerimeter__SWIG_1(args, nargout); + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_cvHaarDetectObjects__SWIG_0 (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvHaarClassifierCascade *arg2 = (CvHaarClassifierCascade *) 0 ; + CvMemStorage *arg3 = (CvMemStorage *) 0 ; + double arg4 ; + int arg5 ; + int arg6 ; + CvSize arg7 ; + bool freearg1 = false ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + void *argp7 ; + int res7 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvRect > *result = 0 ; + + if (!SWIG_check_num_args("cvHaarDetectObjects",args.length(),7,7,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvHaarDetectObjects" "', argument " "2"" of type '" "CvHaarClassifierCascade *""'"); + } + arg2 = (CvHaarClassifierCascade *)(argp2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvHaarDetectObjects" "', argument " "3"" of type '" "CvMemStorage *""'"); + } + arg3 = (CvMemStorage *)(argp3); + ecode4 = SWIG_AsVal_double(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvHaarDetectObjects" "', argument " "4"" of type '" "double""'"); + } + arg4 = (double)(val4); + ecode5 = SWIG_AsVal_int(args(4), &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvHaarDetectObjects" "', 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 '" "cvHaarDetectObjects" "', argument " "6"" of type '" "int""'"); + } + arg6 = (int)(val6); + { + res7 = SWIG_ConvertPtr(args(6), &argp7, SWIGTYPE_p_CvSize, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvHaarDetectObjects" "', argument " "7"" of type '" "CvSize""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvHaarDetectObjects" "', argument " "7"" of type '" "CvSize""'"); + } else { + arg7 = *((CvSize *)(argp7)); + } + } + result = (CvTypedSeq< CvRect > *)cvHaarDetectObjects_Shadow((void const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvHaarDetectObjects__SWIG_1 (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvHaarClassifierCascade *arg2 = (CvHaarClassifierCascade *) 0 ; + CvMemStorage *arg3 = (CvMemStorage *) 0 ; + double arg4 ; + int arg5 ; + int arg6 ; + bool freearg1 = false ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvRect > *result = 0 ; + + if (!SWIG_check_num_args("cvHaarDetectObjects",args.length(),6,6,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvHaarDetectObjects" "', argument " "2"" of type '" "CvHaarClassifierCascade *""'"); + } + arg2 = (CvHaarClassifierCascade *)(argp2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvHaarDetectObjects" "', argument " "3"" of type '" "CvMemStorage *""'"); + } + arg3 = (CvMemStorage *)(argp3); + ecode4 = SWIG_AsVal_double(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvHaarDetectObjects" "', argument " "4"" of type '" "double""'"); + } + arg4 = (double)(val4); + ecode5 = SWIG_AsVal_int(args(4), &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvHaarDetectObjects" "', 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 '" "cvHaarDetectObjects" "', argument " "6"" of type '" "int""'"); + } + arg6 = (int)(val6); + result = (CvTypedSeq< CvRect > *)cvHaarDetectObjects_Shadow((void const *)arg1,arg2,arg3,arg4,arg5,arg6); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvHaarDetectObjects__SWIG_2 (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvHaarClassifierCascade *arg2 = (CvHaarClassifierCascade *) 0 ; + CvMemStorage *arg3 = (CvMemStorage *) 0 ; + double arg4 ; + int arg5 ; + bool freearg1 = false ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvRect > *result = 0 ; + + if (!SWIG_check_num_args("cvHaarDetectObjects",args.length(),5,5,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvHaarDetectObjects" "', argument " "2"" of type '" "CvHaarClassifierCascade *""'"); + } + arg2 = (CvHaarClassifierCascade *)(argp2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvHaarDetectObjects" "', argument " "3"" of type '" "CvMemStorage *""'"); + } + arg3 = (CvMemStorage *)(argp3); + ecode4 = SWIG_AsVal_double(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvHaarDetectObjects" "', argument " "4"" of type '" "double""'"); + } + arg4 = (double)(val4); + ecode5 = SWIG_AsVal_int(args(4), &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvHaarDetectObjects" "', argument " "5"" of type '" "int""'"); + } + arg5 = (int)(val5); + result = (CvTypedSeq< CvRect > *)cvHaarDetectObjects_Shadow((void const *)arg1,arg2,arg3,arg4,arg5); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvHaarDetectObjects__SWIG_3 (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvHaarClassifierCascade *arg2 = (CvHaarClassifierCascade *) 0 ; + CvMemStorage *arg3 = (CvMemStorage *) 0 ; + double arg4 ; + bool freearg1 = false ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvRect > *result = 0 ; + + if (!SWIG_check_num_args("cvHaarDetectObjects",args.length(),4,4,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvHaarDetectObjects" "', argument " "2"" of type '" "CvHaarClassifierCascade *""'"); + } + arg2 = (CvHaarClassifierCascade *)(argp2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvHaarDetectObjects" "', argument " "3"" of type '" "CvMemStorage *""'"); + } + arg3 = (CvMemStorage *)(argp3); + ecode4 = SWIG_AsVal_double(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvHaarDetectObjects" "', argument " "4"" of type '" "double""'"); + } + arg4 = (double)(val4); + result = (CvTypedSeq< CvRect > *)cvHaarDetectObjects_Shadow((void const *)arg1,arg2,arg3,arg4); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvHaarDetectObjects__SWIG_4 (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvHaarClassifierCascade *arg2 = (CvHaarClassifierCascade *) 0 ; + CvMemStorage *arg3 = (CvMemStorage *) 0 ; + bool freearg1 = false ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvRect > *result = 0 ; + + if (!SWIG_check_num_args("cvHaarDetectObjects",args.length(),3,3,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvHaarDetectObjects" "', argument " "2"" of type '" "CvHaarClassifierCascade *""'"); + } + arg2 = (CvHaarClassifierCascade *)(argp2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvHaarDetectObjects" "', argument " "3"" of type '" "CvMemStorage *""'"); + } + arg3 = (CvMemStorage *)(argp3); + result = (CvTypedSeq< CvRect > *)cvHaarDetectObjects_Shadow((void const *)arg1,arg2,arg3); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvHaarDetectObjects (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 *ptr; + if(OctList_Check(argv[0]) || OctTuple_Check(argv[0])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[0], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvHaarClassifierCascade, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMemStorage, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_cvHaarDetectObjects__SWIG_4(args, nargout); + } + } + } + } + if (argc == 4) { + int _v; + { + void *ptr; + if(OctList_Check(argv[0]) || OctTuple_Check(argv[0])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[0], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvHaarClassifierCascade, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMemStorage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_cvHaarDetectObjects__SWIG_3(args, nargout); + } + } + } + } + } + if (argc == 5) { + int _v; + { + void *ptr; + if(OctList_Check(argv[0]) || OctTuple_Check(argv[0])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[0], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvHaarClassifierCascade, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMemStorage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(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_cvHaarDetectObjects__SWIG_2(args, nargout); + } + } + } + } + } + } + if (argc == 6) { + int _v; + { + void *ptr; + if(OctList_Check(argv[0]) || OctTuple_Check(argv[0])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[0], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvHaarClassifierCascade, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMemStorage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(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) { + return _wrap_cvHaarDetectObjects__SWIG_1(args, nargout); + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + { + void *ptr; + if(OctList_Check(argv[0]) || OctTuple_Check(argv[0])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[0], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvHaarClassifierCascade, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvMemStorage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(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) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvSize, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_cvHaarDetectObjects__SWIG_0(args, nargout); + } + } + } + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_cvSegmentMotion (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + CvMemStorage *arg3 = (CvMemStorage *) 0 ; + double arg4 ; + double arg5 ; + bool freearg1 = false ; + bool freearg2 = false ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvConnectedComp > *result = 0 ; + + if (!SWIG_check_num_args("cvSegmentMotion",args.length(),5,5,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvSegmentMotion" "', argument " "3"" of type '" "CvMemStorage *""'"); + } + arg3 = (CvMemStorage *)(argp3); + ecode4 = SWIG_AsVal_double(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvSegmentMotion" "', 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 '" "cvSegmentMotion" "', argument " "5"" of type '" "double""'"); + } + arg5 = (double)(val5); + result = (CvTypedSeq< CvConnectedComp > *)cvSegmentMotion_Shadow((void const *)arg1,arg2,arg3,arg4,arg5); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvApproxPoly__SWIG_0 (const octave_value_list& args, int nargout) { + void *arg1 = (void *) 0 ; + int arg2 ; + CvMemStorage *arg3 = (CvMemStorage *) 0 ; + int arg4 ; + double arg5 ; + int arg6 ; + int res1 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvPoint > *result = 0 ; + + if (!SWIG_check_num_args("cvApproxPoly",args.length(),6,6,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0),SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvApproxPoly" "', argument " "1"" of type '" "void const *""'"); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvApproxPoly" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvApproxPoly" "', argument " "3"" of type '" "CvMemStorage *""'"); + } + arg3 = (CvMemStorage *)(argp3); + ecode4 = SWIG_AsVal_int(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvApproxPoly" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + ecode5 = SWIG_AsVal_double(args(4), &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvApproxPoly" "', argument " "5"" of type '" "double""'"); + } + arg5 = (double)(val5); + ecode6 = SWIG_AsVal_int(args(5), &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvApproxPoly" "', argument " "6"" of type '" "int""'"); + } + arg6 = (int)(val6); + result = (CvTypedSeq< CvPoint > *)cvApproxPoly_Shadow((void const *)arg1,arg2,arg3,arg4,arg5,arg6); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvApproxPoly__SWIG_1 (const octave_value_list& args, int nargout) { + void *arg1 = (void *) 0 ; + int arg2 ; + CvMemStorage *arg3 = (CvMemStorage *) 0 ; + int arg4 ; + double arg5 ; + int res1 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvPoint > *result = 0 ; + + if (!SWIG_check_num_args("cvApproxPoly",args.length(),5,5,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0),SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvApproxPoly" "', argument " "1"" of type '" "void const *""'"); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvApproxPoly" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvApproxPoly" "', argument " "3"" of type '" "CvMemStorage *""'"); + } + arg3 = (CvMemStorage *)(argp3); + ecode4 = SWIG_AsVal_int(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvApproxPoly" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + ecode5 = SWIG_AsVal_double(args(4), &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvApproxPoly" "', argument " "5"" of type '" "double""'"); + } + arg5 = (double)(val5); + result = (CvTypedSeq< CvPoint > *)cvApproxPoly_Shadow((void const *)arg1,arg2,arg3,arg4,arg5); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvApproxPoly (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 *ptr = 0; + int res = SWIG_ConvertPtr(argv[0], &ptr, 0, 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_CvMemStorage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_cvApproxPoly__SWIG_1(args, nargout); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *ptr = 0; + int res = SWIG_ConvertPtr(argv[0], &ptr, 0, 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_CvMemStorage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(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_cvApproxPoly__SWIG_0(args, nargout); + } + } + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_cvConvexHull2__SWIG_0 (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + int arg2 ; + int arg3 ; + bool freearg1 = false ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("cvConvexHull2",args.length(),3,3,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvConvexHull2" "', 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 '" "cvConvexHull2" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + result = (CvMat *)cvConvexHull2_Shadow((void const *)arg1,arg2,arg3); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvConvexHull2__SWIG_1 (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + int arg2 ; + bool freearg1 = false ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("cvConvexHull2",args.length(),2,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvConvexHull2" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + result = (CvMat *)cvConvexHull2_Shadow((void const *)arg1,arg2); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvConvexHull2__SWIG_2 (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + bool freearg1 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("cvConvexHull2",args.length(),1,1,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + result = (CvMat *)cvConvexHull2_Shadow((void const *)arg1); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvConvexHull2 (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 == 1) { + int _v; + { + void *ptr; + if(OctList_Check(argv[0]) || OctTuple_Check(argv[0])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[0], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_cvConvexHull2__SWIG_2(args, nargout); + } + } + if (argc == 2) { + int _v; + { + void *ptr; + if(OctList_Check(argv[0]) || OctTuple_Check(argv[0])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[0], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_cvConvexHull2__SWIG_1(args, nargout); + } + } + } + if (argc == 3) { + int _v; + { + void *ptr; + if(OctList_Check(argv[0]) || OctTuple_Check(argv[0])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[0], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + 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_cvConvexHull2__SWIG_0(args, nargout); + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_cvSnakeImage__SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + std::vector< CvPoint,std::allocator< CvPoint > > arg2 ; + std::vector< float,std::allocator< float > > arg3 ; + std::vector< float,std::allocator< float > > arg4 ; + std::vector< float,std::allocator< float > > arg5 ; + CvSize arg6 ; + CvTermCriteria arg7 ; + int arg8 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp6 ; + int res6 = 0 ; + void *argp7 ; + int res7 = 0 ; + int val8 ; + int ecode8 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint,std::allocator< CvPoint > > result; + + if (!SWIG_check_num_args("cvSnakeImage",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 '" "cvSnakeImage" "', argument " "1"" of type '" "CvMat const *""'"); + } + arg1 = (CvMat *)(argp1); + { + std::vector > *ptr = (std::vector > *)0; + int res = swig::asptr(args(1), &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "2"" of type '" "std::vector< CvPoint,std::allocator< CvPoint > >""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + std::vector > *ptr = (std::vector > *)0; + int res = swig::asptr(args(2), &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "3"" of type '" "std::vector< float,std::allocator< float > >""'"); + } + arg3 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + std::vector > *ptr = (std::vector > *)0; + int res = swig::asptr(args(3), &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "4"" of type '" "std::vector< float,std::allocator< float > >""'"); + } + arg4 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + std::vector > *ptr = (std::vector > *)0; + int res = swig::asptr(args(4), &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "5"" of type '" "std::vector< float,std::allocator< float > >""'"); + } + arg5 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + res6 = SWIG_ConvertPtr(args(5), &argp6, SWIGTYPE_p_CvSize, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvSnakeImage" "', argument " "6"" of type '" "CvSize""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvSnakeImage" "', argument " "6"" of type '" "CvSize""'"); + } else { + arg6 = *((CvSize *)(argp6)); + } + } + { + res7 = SWIG_ConvertPtr(args(6), &argp7, SWIGTYPE_p_CvTermCriteria, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvSnakeImage" "', argument " "7"" of type '" "CvTermCriteria""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvSnakeImage" "', argument " "7"" of type '" "CvTermCriteria""'"); + } else { + arg7 = *((CvTermCriteria *)(argp7)); + } + } + ecode8 = SWIG_AsVal_int(args(7), &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "cvSnakeImage" "', argument " "8"" of type '" "int""'"); + } + arg8 = (int)(val8); + result = cvSnakeImage_Shadow((CvMat const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); + _outv = swig::from((std::vector >)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvSnakeImage__SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + std::vector< CvPoint,std::allocator< CvPoint > > arg2 ; + std::vector< float,std::allocator< float > > arg3 ; + std::vector< float,std::allocator< float > > arg4 ; + std::vector< float,std::allocator< float > > arg5 ; + CvSize arg6 ; + CvTermCriteria arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp6 ; + int res6 = 0 ; + void *argp7 ; + int res7 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + std::vector< CvPoint,std::allocator< CvPoint > > result; + + if (!SWIG_check_num_args("cvSnakeImage",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 '" "cvSnakeImage" "', argument " "1"" of type '" "CvMat const *""'"); + } + arg1 = (CvMat *)(argp1); + { + std::vector > *ptr = (std::vector > *)0; + int res = swig::asptr(args(1), &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "2"" of type '" "std::vector< CvPoint,std::allocator< CvPoint > >""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + std::vector > *ptr = (std::vector > *)0; + int res = swig::asptr(args(2), &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "3"" of type '" "std::vector< float,std::allocator< float > >""'"); + } + arg3 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + std::vector > *ptr = (std::vector > *)0; + int res = swig::asptr(args(3), &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "4"" of type '" "std::vector< float,std::allocator< float > >""'"); + } + arg4 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + std::vector > *ptr = (std::vector > *)0; + int res = swig::asptr(args(4), &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "cvSnakeImage" "', argument " "5"" of type '" "std::vector< float,std::allocator< float > >""'"); + } + arg5 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + res6 = SWIG_ConvertPtr(args(5), &argp6, SWIGTYPE_p_CvSize, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvSnakeImage" "', argument " "6"" of type '" "CvSize""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvSnakeImage" "', argument " "6"" of type '" "CvSize""'"); + } else { + arg6 = *((CvSize *)(argp6)); + } + } + { + res7 = SWIG_ConvertPtr(args(6), &argp7, SWIGTYPE_p_CvTermCriteria, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvSnakeImage" "', argument " "7"" of type '" "CvTermCriteria""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvSnakeImage" "', argument " "7"" of type '" "CvTermCriteria""'"); + } else { + arg7 = *((CvTermCriteria *)(argp7)); + } + } + result = cvSnakeImage_Shadow((CvMat const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7); + _outv = swig::from((std::vector >)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvSnakeImage (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 == 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::asptr(argv[1], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + int res = swig::asptr(argv[2], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + int res = swig::asptr(argv[3], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + int res = swig::asptr(argv[4], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvSize, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvTermCriteria, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_cvSnakeImage__SWIG_1(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::asptr(argv[1], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + int res = swig::asptr(argv[2], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + int res = swig::asptr(argv[3], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + int res = swig::asptr(argv[4], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CvSize, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_CvTermCriteria, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_cvSnakeImage__SWIG_0(args, nargout); + } + } + } + } + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_cvFree (const octave_value_list& args, int nargout) { + void **arg1 = (void **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvFree",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_p_void, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFree" "', argument " "1"" of type '" "void **""'"); + } + arg1 = (void **)(argp1); + cvFree(arg1); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_READ_CHAIN_POINT (const octave_value_list& args, int nargout) { + CvPoint arg1 ; + CvChainPtReader arg2 ; + void *argp2 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CV_READ_CHAIN_POINT",args.length(),2,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvPoint(args(0)); + } + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvChainPtReader, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_READ_CHAIN_POINT" "', argument " "2"" of type '" "CvChainPtReader""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_READ_CHAIN_POINT" "', argument " "2"" of type '" "CvChainPtReader""'"); + } else { + arg2 = *((CvChainPtReader *)(argp2)); + } + } + CV_READ_CHAIN_POINT(arg1,arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_MAT_ELEM_PTR (const octave_value_list& args, int nargout) { + CvMat arg1 ; + int arg2 ; + int arg3 ; + void *argp1 ; + 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; + void *result = 0 ; + + if (!SWIG_check_num_args("CV_MAT_ELEM_PTR",args.length(),3,3,0)) { + SWIG_fail; + } + { + res1 = SWIG_ConvertPtr(args(0), &argp1, SWIGTYPE_p_CvMat, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_MAT_ELEM_PTR" "', argument " "1"" of type '" "CvMat""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_MAT_ELEM_PTR" "', argument " "1"" of type '" "CvMat""'"); + } else { + arg1 = *((CvMat *)(argp1)); + } + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CV_MAT_ELEM_PTR" "', 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 '" "CV_MAT_ELEM_PTR" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + result = (void *)CV_MAT_ELEM_PTR(arg1,arg2,arg3); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_MAT_ELEM_PTR_FAST (const octave_value_list& args, int nargout) { + CvMat arg1 ; + int arg2 ; + int arg3 ; + int arg4 ; + void *argp1 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + void *result = 0 ; + + if (!SWIG_check_num_args("CV_MAT_ELEM_PTR_FAST",args.length(),4,4,0)) { + SWIG_fail; + } + { + res1 = SWIG_ConvertPtr(args(0), &argp1, SWIGTYPE_p_CvMat, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_MAT_ELEM_PTR_FAST" "', argument " "1"" of type '" "CvMat""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_MAT_ELEM_PTR_FAST" "', argument " "1"" of type '" "CvMat""'"); + } else { + arg1 = *((CvMat *)(argp1)); + } + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CV_MAT_ELEM_PTR_FAST" "', 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 '" "CV_MAT_ELEM_PTR_FAST" "', 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 '" "CV_MAT_ELEM_PTR_FAST" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + result = (void *)CV_MAT_ELEM_PTR_FAST(arg1,arg2,arg3,arg4); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_VAL (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 0 ; + CvSparseNode *arg2 = (CvSparseNode *) 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; + void *result = 0 ; + + if (!SWIG_check_num_args("CV_NODE_VAL",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_NODE_VAL" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSparseNode, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_NODE_VAL" "', argument " "2"" of type '" "CvSparseNode *""'"); + } + arg2 = (CvSparseNode *)(argp2); + result = (void *)CV_NODE_VAL(arg1,arg2); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_IDX (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 0 ; + CvSparseNode *arg2 = (CvSparseNode *) 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 = 0 ; + + if (!SWIG_check_num_args("CV_NODE_IDX",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_NODE_IDX" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSparseNode, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_NODE_IDX" "', argument " "2"" of type '" "CvSparseNode *""'"); + } + arg2 = (CvSparseNode *)(argp2); + result = (int *)CV_NODE_IDX(arg1,arg2); + _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_CV_SUBDIV2D_NEXT_EDGE (const octave_value_list& args, int nargout) { + CvSubdiv2DEdge arg1 ; + CvSubdiv2DEdge_Wrapper *wrapper1 ; + CvQuadEdge2D *qedge1 ; + void *vptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvQuadEdge2D *result = 0 ; + + if (!SWIG_check_num_args("CV_SUBDIV2D_NEXT_EDGE",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){ + wrapper1 = (CvSubdiv2DEdge_Wrapper *) vptr1; + arg1 = wrapper1->ref(); + } + else if( SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){ + qedge1 = (CvQuadEdge2D *) vptr1; + arg1 = (CvSubdiv2DEdge)qedge1; + } + else{ + SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge"); + SWIG_fail; + } + } + result = (CvQuadEdge2D *)CV_SUBDIV2D_NEXT_EDGE(arg1); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvQuadEdge2D, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_SWAP (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; + + if (!SWIG_check_num_args("CV_SWAP",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 '" "CV_SWAP" "', 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 '" "CV_SWAP" "', 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 '" "CV_SWAP" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + CV_SWAP(arg1,arg2,arg3); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IMIN (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; + int result; + + if (!SWIG_check_num_args("CV_IMIN",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 '" "CV_IMIN" "', 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 '" "CV_IMIN" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + result = (int)CV_IMIN(arg1,arg2); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IMAX (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; + int result; + + if (!SWIG_check_num_args("CV_IMAX",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 '" "CV_IMAX" "', 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 '" "CV_IMAX" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + result = (int)CV_IMAX(arg1,arg2); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IABS (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; + int result; + + if (!SWIG_check_num_args("CV_IABS",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 '" "CV_IABS" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_IABS(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_CMP (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; + + if (!SWIG_check_num_args("CV_CMP",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 '" "CV_CMP" "', 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 '" "CV_CMP" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + CV_CMP(arg1,arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_SIGN (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; + + if (!SWIG_check_num_args("CV_SIGN",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 '" "CV_SIGN" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + CV_SIGN(arg1); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvInvSqrt (const octave_value_list& args, int nargout) { + double arg1 ; + double val1 ; + int ecode1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvInvSqrt",args.length(),1,1,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvInvSqrt" "', argument " "1"" of type '" "double""'"); + } + arg1 = (double)(val1); + cvInvSqrt(arg1); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvSqrt (const octave_value_list& args, int nargout) { + double arg1 ; + double val1 ; + int ecode1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvSqrt",args.length(),1,1,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvSqrt" "', argument " "1"" of type '" "double""'"); + } + arg1 = (double)(val1); + cvSqrt(arg1); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_IMAGE_HDR (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + bool freearg1 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_IMAGE_HDR",args.length(),1,1,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + result = (int)CV_IS_IMAGE_HDR(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_IMAGE (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + bool freearg1 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_IMAGE",args.length(),1,1,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + result = (int)CV_IS_IMAGE(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CV_MAT_DEPTH (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; + int result; + + if (!SWIG_check_num_args("CV_MAT_DEPTH",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 '" "CV_MAT_DEPTH" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_MAT_DEPTH(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_MAKETYPE (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; + int result; + + if (!SWIG_check_num_args("CV_MAKETYPE",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 '" "CV_MAKETYPE" "', 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 '" "CV_MAKETYPE" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + result = (int)CV_MAKETYPE(arg1,arg2); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_8UC (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; + int result; + + if (!SWIG_check_num_args("CV_8UC",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 '" "CV_8UC" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_8UC(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_8SC (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; + int result; + + if (!SWIG_check_num_args("CV_8SC",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 '" "CV_8SC" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_8SC(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_16UC (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; + int result; + + if (!SWIG_check_num_args("CV_16UC",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 '" "CV_16UC" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_16UC(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_16SC (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; + int result; + + if (!SWIG_check_num_args("CV_16SC",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 '" "CV_16SC" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_16SC(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_32SC (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; + int result; + + if (!SWIG_check_num_args("CV_32SC",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 '" "CV_32SC" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_32SC(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_32FC (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; + int result; + + if (!SWIG_check_num_args("CV_32FC",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 '" "CV_32FC" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_32FC(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_64FC (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; + int result; + + if (!SWIG_check_num_args("CV_64FC",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 '" "CV_64FC" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_64FC(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_MAT_CN (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; + int result; + + if (!SWIG_check_num_args("CV_MAT_CN",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 '" "CV_MAT_CN" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_MAT_CN(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_MAT_TYPE (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; + int result; + + if (!SWIG_check_num_args("CV_MAT_TYPE",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 '" "CV_MAT_TYPE" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_MAT_TYPE(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_MAT_CONT (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; + int result; + + if (!SWIG_check_num_args("CV_IS_MAT_CONT",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 '" "CV_IS_MAT_CONT" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_IS_MAT_CONT(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_TEMP_MAT (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; + int result; + + if (!SWIG_check_num_args("CV_IS_TEMP_MAT",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 '" "CV_IS_TEMP_MAT" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_IS_TEMP_MAT(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_MAT_HDR (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; + int result; + + if (!SWIG_check_num_args("CV_IS_MAT_HDR",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 '" "CV_IS_MAT_HDR" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + result = (int)CV_IS_MAT_HDR(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_MAT (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; + int result; + + if (!SWIG_check_num_args("CV_IS_MAT",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 '" "CV_IS_MAT" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + result = (int)CV_IS_MAT(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_MASK_ARR (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; + int result; + + if (!SWIG_check_num_args("CV_IS_MASK_ARR",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 '" "CV_IS_MASK_ARR" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + result = (int)CV_IS_MASK_ARR(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_ARE_TYPES_EQ (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; + int result; + + if (!SWIG_check_num_args("CV_ARE_TYPES_EQ",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 '" "CV_ARE_TYPES_EQ" "', 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 '" "CV_ARE_TYPES_EQ" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + result = (int)CV_ARE_TYPES_EQ(arg1,arg2); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_ARE_CNS_EQ (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; + int result; + + if (!SWIG_check_num_args("CV_ARE_CNS_EQ",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 '" "CV_ARE_CNS_EQ" "', 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 '" "CV_ARE_CNS_EQ" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + result = (int)CV_ARE_CNS_EQ(arg1,arg2); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_ARE_DEPTHS_EQ (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; + int result; + + if (!SWIG_check_num_args("CV_ARE_DEPTHS_EQ",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 '" "CV_ARE_DEPTHS_EQ" "', 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 '" "CV_ARE_DEPTHS_EQ" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + result = (int)CV_ARE_DEPTHS_EQ(arg1,arg2); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_ARE_SIZES_EQ (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; + int result; + + if (!SWIG_check_num_args("CV_ARE_SIZES_EQ",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 '" "CV_ARE_SIZES_EQ" "', 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 '" "CV_ARE_SIZES_EQ" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + result = (int)CV_ARE_SIZES_EQ(arg1,arg2); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_MAT_CONST (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; + int result; + + if (!SWIG_check_num_args("CV_IS_MAT_CONST",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 '" "CV_IS_MAT_CONST" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + result = (int)CV_IS_MAT_CONST(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_ELEM_SIZE1 (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; + int result; + + if (!SWIG_check_num_args("CV_ELEM_SIZE1",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 '" "CV_ELEM_SIZE1" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_ELEM_SIZE1(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_ELEM_SIZE (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; + int result; + + if (!SWIG_check_num_args("CV_ELEM_SIZE",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 '" "CV_ELEM_SIZE" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_ELEM_SIZE(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_MATND_HDR (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; + int result; + + if (!SWIG_check_num_args("CV_IS_MATND_HDR",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 '" "CV_IS_MATND_HDR" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + result = (int)CV_IS_MATND_HDR(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_MATND (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; + int result; + + if (!SWIG_check_num_args("CV_IS_MATND",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 '" "CV_IS_MATND" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + result = (int)CV_IS_MATND(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SPARSE_MAT_HDR (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; + int result; + + if (!SWIG_check_num_args("CV_IS_SPARSE_MAT_HDR",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 '" "CV_IS_SPARSE_MAT_HDR" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + result = (int)CV_IS_SPARSE_MAT_HDR(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SPARSE_MAT (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; + int result; + + if (!SWIG_check_num_args("CV_IS_SPARSE_MAT",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 '" "CV_IS_SPARSE_MAT" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + result = (int)CV_IS_SPARSE_MAT(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_HIST (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 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("CV_IS_HIST",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_HIST" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + result = (int)CV_IS_HIST(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_UNIFORM_HIST (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 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("CV_IS_UNIFORM_HIST",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_UNIFORM_HIST" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + result = (int)CV_IS_UNIFORM_HIST(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SPARSE_HIST (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 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("CV_IS_SPARSE_HIST",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_SPARSE_HIST" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + result = (int)CV_IS_SPARSE_HIST(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_HIST_HAS_RANGES (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 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("CV_HIST_HAS_RANGES",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_HIST_HAS_RANGES" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + result = (int)CV_HIST_HAS_RANGES(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_STORAGE (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 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("CV_IS_STORAGE",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_STORAGE" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(argp1); + result = (int)CV_IS_STORAGE(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SET_ELEM (const octave_value_list& args, int nargout) { + void *arg1 = (void *) 0 ; + int res1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SET_ELEM",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0),SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_SET_ELEM" "', argument " "1"" of type '" "void *""'"); + } + result = (int)CV_IS_SET_ELEM(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SET (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SET",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (int)CV_IS_SET(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_SEQ_ELTYPE (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_SEQ_ELTYPE",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_SEQ_ELTYPE(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_SEQ_KIND (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_SEQ_KIND",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_SEQ_KIND(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_INDEX (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_INDEX",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_INDEX(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_CURVE (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_CURVE",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_CURVE(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_CLOSED (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_CLOSED",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_CLOSED(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_CONVEX (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_CONVEX",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_CONVEX(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_HOLE (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_HOLE",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_HOLE(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_SIMPLE (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_SIMPLE",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_SIMPLE(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_POINT_SET (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_POINT_SET",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_POINT_SET(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_POINT_SUBSET (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_POINT_SUBSET",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_POINT_SUBSET(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_POLYLINE (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_POLYLINE",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_POLYLINE(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_POLYGON (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_POLYGON",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_POLYGON(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_CHAIN (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_CHAIN",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_CHAIN(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_CONTOUR (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_CONTOUR",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_CONTOUR(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_CHAIN_CONTOUR (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_CHAIN_CONTOUR",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_CHAIN_CONTOUR(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SEQ_POLYGON_TREE (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SEQ_POLYGON_TREE",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SEQ_POLYGON_TREE(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_GRAPH (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_GRAPH",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_GRAPH(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_GRAPH_ORIENTED (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_GRAPH_ORIENTED",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_GRAPH_ORIENTED(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_SUBDIV2D (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_SUBDIV2D",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_IS_SUBDIV2D(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_WRITE_SEQ_ELEM_VAR (const octave_value_list& args, int nargout) { + void *arg1 = (void *) 0 ; + CvSeqWriter arg2 ; + int res1 ; + void *argp2 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CV_WRITE_SEQ_ELEM_VAR",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0),SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_WRITE_SEQ_ELEM_VAR" "', argument " "1"" of type '" "void *""'"); + } + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSeqWriter, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_WRITE_SEQ_ELEM_VAR" "', argument " "2"" of type '" "CvSeqWriter""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_WRITE_SEQ_ELEM_VAR" "', argument " "2"" of type '" "CvSeqWriter""'"); + } else { + arg2 = *((CvSeqWriter *)(argp2)); + } + } + CV_WRITE_SEQ_ELEM_VAR(arg1,arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_WRITE_SEQ_ELEM (const octave_value_list& args, int nargout) { + CvPoint arg1 ; + CvSeqWriter arg2 ; + void *argp2 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CV_WRITE_SEQ_ELEM",args.length(),2,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvPoint(args(0)); + } + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSeqWriter, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_WRITE_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqWriter""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_WRITE_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqWriter""'"); + } else { + arg2 = *((CvSeqWriter *)(argp2)); + } + } + CV_WRITE_SEQ_ELEM(arg1,arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NEXT_SEQ_ELEM (const octave_value_list& args, int nargout) { + int arg1 ; + CvSeqReader arg2 ; + int val1 ; + int ecode1 = 0 ; + void *argp2 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CV_NEXT_SEQ_ELEM",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 '" "CV_NEXT_SEQ_ELEM" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSeqReader, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_NEXT_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_NEXT_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'"); + } else { + arg2 = *((CvSeqReader *)(argp2)); + } + } + CV_NEXT_SEQ_ELEM(arg1,arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_PREV_SEQ_ELEM (const octave_value_list& args, int nargout) { + int arg1 ; + CvSeqReader arg2 ; + int val1 ; + int ecode1 = 0 ; + void *argp2 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CV_PREV_SEQ_ELEM",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 '" "CV_PREV_SEQ_ELEM" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSeqReader, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_PREV_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_PREV_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'"); + } else { + arg2 = *((CvSeqReader *)(argp2)); + } + } + CV_PREV_SEQ_ELEM(arg1,arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_READ_SEQ_ELEM (const octave_value_list& args, int nargout) { + CvPoint arg1 ; + CvSeqReader arg2 ; + void *argp2 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CV_READ_SEQ_ELEM",args.length(),2,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvPoint(args(0)); + } + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSeqReader, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_READ_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_READ_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'"); + } else { + arg2 = *((CvSeqReader *)(argp2)); + } + } + CV_READ_SEQ_ELEM(arg1,arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_REV_READ_SEQ_ELEM (const octave_value_list& args, int nargout) { + CvPoint arg1 ; + CvSeqReader arg2 ; + void *argp2 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CV_REV_READ_SEQ_ELEM",args.length(),2,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvPoint(args(0)); + } + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSeqReader, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_REV_READ_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_REV_READ_SEQ_ELEM" "', argument " "2"" of type '" "CvSeqReader""'"); + } else { + arg2 = *((CvSeqReader *)(argp2)); + } + } + CV_REV_READ_SEQ_ELEM(arg1,arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_CURRENT_POINT (const octave_value_list& args, int nargout) { + CvSeqReader arg1 ; + void *argp1 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint result; + + if (!SWIG_check_num_args("CV_CURRENT_POINT",args.length(),1,1,0)) { + SWIG_fail; + } + { + res1 = SWIG_ConvertPtr(args(0), &argp1, SWIGTYPE_p_CvSeqReader, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_CURRENT_POINT" "', argument " "1"" of type '" "CvSeqReader""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_CURRENT_POINT" "', argument " "1"" of type '" "CvSeqReader""'"); + } else { + arg1 = *((CvSeqReader *)(argp1)); + } + } + result = CV_CURRENT_POINT(arg1); + _outv = SWIG_NewPointerObj((new CvPoint((const CvPoint&)(result))), SWIGTYPE_p_CvPoint, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_PREV_POINT (const octave_value_list& args, int nargout) { + CvSeqReader arg1 ; + void *argp1 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint result; + + if (!SWIG_check_num_args("CV_PREV_POINT",args.length(),1,1,0)) { + SWIG_fail; + } + { + res1 = SWIG_ConvertPtr(args(0), &argp1, SWIGTYPE_p_CvSeqReader, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_PREV_POINT" "', argument " "1"" of type '" "CvSeqReader""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_PREV_POINT" "', argument " "1"" of type '" "CvSeqReader""'"); + } else { + arg1 = *((CvSeqReader *)(argp1)); + } + } + result = CV_PREV_POINT(arg1); + _outv = SWIG_NewPointerObj((new CvPoint((const CvPoint&)(result))), SWIGTYPE_p_CvPoint, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_READ_EDGE (const octave_value_list& args, int nargout) { + CvPoint arg1 ; + CvPoint arg2 ; + CvSeqReader arg3 ; + void *argp3 ; + int res3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CV_READ_EDGE",args.length(),3,3,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvPoint(args(0)); + } + { + arg2 = OctObject_to_CvPoint(args(1)); + } + { + res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_CvSeqReader, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CV_READ_EDGE" "', argument " "3"" of type '" "CvSeqReader""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_READ_EDGE" "', argument " "3"" of type '" "CvSeqReader""'"); + } else { + arg3 = *((CvSeqReader *)(argp3)); + } + } + CV_READ_EDGE(arg1,arg2,arg3); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NEXT_GRAPH_EDGE (const octave_value_list& args, int nargout) { + CvGraphEdge *arg1 = (CvGraphEdge *) 0 ; + CvGraphVtx *arg2 = (CvGraphVtx *) 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; + CvGraphEdge *result = 0 ; + + if (!SWIG_check_num_args("CV_NEXT_GRAPH_EDGE",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_NEXT_GRAPH_EDGE" "', argument " "1"" of type '" "CvGraphEdge *""'"); + } + arg1 = (CvGraphEdge *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvGraphVtx, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CV_NEXT_GRAPH_EDGE" "', argument " "2"" of type '" "CvGraphVtx *""'"); + } + arg2 = (CvGraphVtx *)(argp2); + result = (CvGraphEdge *)CV_NEXT_GRAPH_EDGE(arg1,arg2); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_TYPE (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; + int result; + + if (!SWIG_check_num_args("CV_NODE_TYPE",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 '" "CV_NODE_TYPE" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_NODE_TYPE(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_IS_INT (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; + int result; + + if (!SWIG_check_num_args("CV_NODE_IS_INT",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 '" "CV_NODE_IS_INT" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_NODE_IS_INT(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_IS_REAL (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; + int result; + + if (!SWIG_check_num_args("CV_NODE_IS_REAL",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 '" "CV_NODE_IS_REAL" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_NODE_IS_REAL(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_IS_STRING (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; + int result; + + if (!SWIG_check_num_args("CV_NODE_IS_STRING",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 '" "CV_NODE_IS_STRING" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_NODE_IS_STRING(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_IS_SEQ (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; + int result; + + if (!SWIG_check_num_args("CV_NODE_IS_SEQ",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 '" "CV_NODE_IS_SEQ" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_NODE_IS_SEQ(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_IS_MAP (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; + int result; + + if (!SWIG_check_num_args("CV_NODE_IS_MAP",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 '" "CV_NODE_IS_MAP" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_NODE_IS_MAP(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_IS_COLLECTION (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; + int result; + + if (!SWIG_check_num_args("CV_NODE_IS_COLLECTION",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 '" "CV_NODE_IS_COLLECTION" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_NODE_IS_COLLECTION(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_IS_FLOW (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; + int result; + + if (!SWIG_check_num_args("CV_NODE_IS_FLOW",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 '" "CV_NODE_IS_FLOW" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_NODE_IS_FLOW(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_IS_EMPTY (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; + int result; + + if (!SWIG_check_num_args("CV_NODE_IS_EMPTY",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 '" "CV_NODE_IS_EMPTY" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_NODE_IS_EMPTY(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_IS_USER (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; + int result; + + if (!SWIG_check_num_args("CV_NODE_IS_USER",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 '" "CV_NODE_IS_USER" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_NODE_IS_USER(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_HAS_NAME (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; + int result; + + if (!SWIG_check_num_args("CV_NODE_HAS_NAME",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 '" "CV_NODE_HAS_NAME" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + result = (int)CV_NODE_HAS_NAME(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NODE_SEQ_IS_SIMPLE (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_NODE_SEQ_IS_SIMPLE",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int)CV_NODE_SEQ_IS_SIMPLE(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvReshapeND (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvMat *arg2 = (CvMat *) 0 ; + int arg3 ; + int arg4 ; + int *arg5 = (int *) 0 ; + bool freearg1 = false ; + CvMat *header2 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + { + header2 = (CvMat *)cvAlloc(sizeof(CvMat)); + arg2 = header2; + } + if (!SWIG_check_num_args("cvReshapeND",args.length(),4,4,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + ecode3 = SWIG_AsVal_int(args(1), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvReshapeND" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + ecode4 = SWIG_AsVal_int(args(2), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvReshapeND" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + res5 = SWIG_ConvertPtr(args(3), &argp5,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvReshapeND" "', argument " "5"" of type '" "int *""'"); + } + arg5 = (int *)(argp5); + cvReshapeND(arg1,arg2,arg3,arg4,arg5); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvConvert (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + bool freearg1 = false ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvConvert",args.length(),2,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + cvConvert(arg1,arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvAXPY (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + double arg2 ; + CvArr *arg3 = (CvArr *) 0 ; + CvArr *arg4 = (CvArr *) 0 ; + bool freearg1 = false ; + double val2 ; + int ecode2 = 0 ; + bool freearg3 = false ; + bool freearg4 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvAXPY",args.length(),4,4,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvAXPY" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + arg3 = OctObject_to_CvArr(args(2), &freearg3); + } + { + arg4 = OctObject_to_CvArr(args(3), &freearg4); + } + cvAXPY(arg1,arg2,arg3,arg4); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } + { + if(arg3!=NULL && freearg3){ + cvReleaseData( arg3 ); + cvFree(&(arg3)); + } + } + { + if(arg4!=NULL && freearg4){ + cvReleaseData( arg4 ); + cvFree(&(arg4)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvAbs (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + bool freearg1 = false ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvAbs",args.length(),2,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + cvAbs(arg1,arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvMatMulAdd (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + CvArr *arg3 = (CvArr *) 0 ; + CvArr *arg4 = (CvArr *) 0 ; + bool freearg1 = false ; + bool freearg2 = false ; + bool freearg3 = false ; + bool freearg4 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvMatMulAdd",args.length(),4,4,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + arg3 = OctObject_to_CvArr(args(2), &freearg3); + } + { + arg4 = OctObject_to_CvArr(args(3), &freearg4); + } + cvMatMulAdd(arg1,arg2,arg3,arg4); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } + { + if(arg3!=NULL && freearg3){ + cvReleaseData( arg3 ); + cvFree(&(arg3)); + } + } + { + if(arg4!=NULL && freearg4){ + cvReleaseData( arg4 ); + cvFree(&(arg4)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvMatMul (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + CvArr *arg3 = (CvArr *) 0 ; + bool freearg1 = false ; + bool freearg2 = false ; + bool freearg3 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvMatMul",args.length(),3,3,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + arg3 = OctObject_to_CvArr(args(2), &freearg3); + } + cvMatMul(arg1,arg2,arg3); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } + { + if(arg3!=NULL && freearg3){ + cvReleaseData( arg3 ); + cvFree(&(arg3)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvGetGraphVtx (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvGetGraphVtx",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvGetGraphVtx" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + cvGetGraphVtx(arg1,arg2); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvGraphVtxIdx (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + CvGraphVtx *arg2 = (CvGraphVtx *) 0 ; + void *ptr1 ; + 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("cvGraphVtxIdx",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvGraphVtx, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGraphVtxIdx" "', argument " "2"" of type '" "CvGraphVtx *""'"); + } + arg2 = (CvGraphVtx *)(argp2); + result = (int)cvGraphVtxIdx(arg1,arg2); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvGraphEdgeIdx (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + CvGraphEdge *arg2 = (CvGraphEdge *) 0 ; + void *ptr1 ; + 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("cvGraphEdgeIdx",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvGraphEdgeIdx" "', argument " "2"" of type '" "CvGraphEdge *""'"); + } + arg2 = (CvGraphEdge *)(argp2); + result = (int)cvGraphEdgeIdx(arg1,arg2); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvGraphGetVtxCount (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("cvGraphGetVtxCount",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (int)cvGraphGetVtxCount(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvGraphGetEdgeCount (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("cvGraphGetEdgeCount",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (int)cvGraphGetEdgeCount(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_GRAPH_VERTEX_VISITED (const octave_value_list& args, int nargout) { + CvGraphVtx *arg1 = (CvGraphVtx *) 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("CV_IS_GRAPH_VERTEX_VISITED",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphVtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_GRAPH_VERTEX_VISITED" "', argument " "1"" of type '" "CvGraphVtx *""'"); + } + arg1 = (CvGraphVtx *)(argp1); + result = (int)CV_IS_GRAPH_VERTEX_VISITED(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_GRAPH_EDGE_VISITED (const octave_value_list& args, int nargout) { + CvGraphEdge *arg1 = (CvGraphEdge *) 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("CV_IS_GRAPH_EDGE_VISITED",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_GRAPH_EDGE_VISITED" "', argument " "1"" of type '" "CvGraphEdge *""'"); + } + arg1 = (CvGraphEdge *)(argp1); + result = (int)CV_IS_GRAPH_EDGE_VISITED(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_RGB (const octave_value_list& args, int nargout) { + double arg1 ; + double arg2 ; + int arg3 ; + double val1 ; + int ecode1 = 0 ; + double val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvScalar result; + + if (!SWIG_check_num_args("CV_RGB",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 '" "CV_RGB" "', 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 '" "CV_RGB" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + ecode3 = SWIG_AsVal_int(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CV_RGB" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + result = CV_RGB(arg1,arg2,arg3); + _outv = SWIG_NewPointerObj((new CvScalar((const CvScalar&)(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_NEXT_LINE_POINT (const octave_value_list& args, int nargout) { + CvLineIterator arg1 ; + void *argp1 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CV_NEXT_LINE_POINT",args.length(),1,1,0)) { + SWIG_fail; + } + { + res1 = SWIG_ConvertPtr(args(0), &argp1, SWIGTYPE_p_CvLineIterator, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_NEXT_LINE_POINT" "', argument " "1"" of type '" "CvLineIterator""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CV_NEXT_LINE_POINT" "', argument " "1"" of type '" "CvLineIterator""'"); + } else { + arg1 = *((CvLineIterator *)(argp1)); + } + } + CV_NEXT_LINE_POINT(arg1); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_INIT_3X3_DELTAS (const octave_value_list& args, int nargout) { + double *arg1 = (double *) 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("CV_INIT_3X3_DELTAS",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_INIT_3X3_DELTAS" "', argument " "1"" of type '" "double *""'"); + } + arg1 = (double *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CV_INIT_3X3_DELTAS" "', 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 '" "CV_INIT_3X3_DELTAS" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + CV_INIT_3X3_DELTAS(arg1,arg2,arg3); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CV_IS_HAAR_CLASSIFIER (const octave_value_list& args, int nargout) { + void *arg1 = (void *) 0 ; + int res1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CV_IS_HAAR_CLASSIFIER",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0),SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CV_IS_HAAR_CLASSIFIER" "', argument " "1"" of type '" "void *""'"); + } + result = (int)CV_IS_HAAR_CLASSIFIER(arg1); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvCalcBackProject (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + CvHistogram *arg3 = (CvHistogram *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + void *argp3 = 0 ; + int res3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvCalcBackProject",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCalcBackProject" "', argument " "1"" of type '" "IplImage *""'"); + } + arg1 = (IplImage *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCalcBackProject" "', argument " "3"" of type '" "CvHistogram *""'"); + } + arg3 = (CvHistogram *)(argp3); + cvCalcBackProject(arg1,arg2,arg3); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvCalcBackProjectPatch (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + CvSize arg3 ; + CvHistogram *arg4 = (CvHistogram *) 0 ; + int arg5 ; + double arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + void *argp3 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvCalcBackProjectPatch",args.length(),6,6,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCalcBackProjectPatch" "', argument " "1"" of type '" "IplImage *""'"); + } + arg1 = (IplImage *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + res3 = SWIG_ConvertPtr(args(2), &argp3, SWIGTYPE_p_CvSize, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvCalcBackProjectPatch" "', argument " "3"" of type '" "CvSize""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcBackProjectPatch" "', argument " "3"" of type '" "CvSize""'"); + } else { + arg3 = *((CvSize *)(argp3)); + } + } + res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvCalcBackProjectPatch" "', argument " "4"" of type '" "CvHistogram *""'"); + } + arg4 = (CvHistogram *)(argp4); + ecode5 = SWIG_AsVal_int(args(4), &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvCalcBackProjectPatch" "', argument " "5"" of type '" "int""'"); + } + arg5 = (int)(val5); + ecode6 = SWIG_AsVal_double(args(5), &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvCalcBackProjectPatch" "', argument " "6"" of type '" "double""'"); + } + arg6 = (double)(val6); + cvCalcBackProjectPatch(arg1,arg2,arg3,arg4,arg5,arg6); + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvCreateImage (const octave_value_list& args, int nargout) { + CvSize arg1 ; + int arg2 ; + int arg3 ; + void *argp1 ; + 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("cvCreateImage",args.length(),3,3,0)) { + SWIG_fail; + } + { + res1 = SWIG_ConvertPtr(args(0), &argp1, SWIGTYPE_p_CvSize, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvCreateImage" "', argument " "1"" of type '" "CvSize""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCreateImage" "', argument " "1"" of type '" "CvSize""'"); + } else { + arg1 = *((CvSize *)(argp1)); + } + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvCreateImage" "', 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 '" "cvCreateImage" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + { + try { + result = (CvMat *)cvCreateImageMat(arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvCloneImage (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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("cvCloneImage",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 '" "cvCloneImage" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = (CvMat *)cvCloneImageMat(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_Cv32suf_i_set (const octave_value_list& args, int nargout) { + Cv32suf *arg1 = (Cv32suf *) 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("Cv32suf_i_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv32suf, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv32suf_i_set" "', argument " "1"" of type '" "Cv32suf *""'"); + } + arg1 = (Cv32suf *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cv32suf_i_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + 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_Cv32suf_i_get (const octave_value_list& args, int nargout) { + Cv32suf *arg1 = (Cv32suf *) 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("Cv32suf_i_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv32suf, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv32suf_i_get" "', argument " "1"" of type '" "Cv32suf *""'"); + } + arg1 = (Cv32suf *)(argp1); + result = (int) ((arg1)->i); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_Cv32suf_u_set (const octave_value_list& args, int nargout) { + Cv32suf *arg1 = (Cv32suf *) 0 ; + unsigned int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("Cv32suf_u_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv32suf, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv32suf_u_set" "', argument " "1"" of type '" "Cv32suf *""'"); + } + arg1 = (Cv32suf *)(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cv32suf_u_set" "', argument " "2"" of type '" "unsigned int""'"); + } + arg2 = (unsigned int)(val2); + 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_Cv32suf_u_get (const octave_value_list& args, int nargout) { + Cv32suf *arg1 = (Cv32suf *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + unsigned int result; + + if (!SWIG_check_num_args("Cv32suf_u_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv32suf, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv32suf_u_get" "', argument " "1"" of type '" "Cv32suf *""'"); + } + arg1 = (Cv32suf *)(argp1); + result = (unsigned int) ((arg1)->u); + _outv = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_Cv32suf_f_set (const octave_value_list& args, int nargout) { + Cv32suf *arg1 = (Cv32suf *) 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("Cv32suf_f_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv32suf, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv32suf_f_set" "', argument " "1"" of type '" "Cv32suf *""'"); + } + arg1 = (Cv32suf *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cv32suf_f_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->f = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_Cv32suf_f_get (const octave_value_list& args, int nargout) { + Cv32suf *arg1 = (Cv32suf *) 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("Cv32suf_f_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv32suf, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv32suf_f_get" "', argument " "1"" of type '" "Cv32suf *""'"); + } + arg1 = (Cv32suf *)(argp1); + result = (float) ((arg1)->f); + _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_Cv32suf (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + Cv32suf *result = 0 ; + + if (!SWIG_check_num_args("new_Cv32suf",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (Cv32suf *)new Cv32suf(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Cv32suf, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_Cv32suf (const octave_value_list& args, int nargout) { + Cv32suf *arg1 = (Cv32suf *) 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_Cv32suf",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv32suf, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cv32suf" "', argument " "1"" of type '" "Cv32suf *""'"); + } + arg1 = (Cv32suf *)(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_Cv32suf_members[] = { +{"i",0,_wrap_Cv32suf_i_get,_wrap_Cv32suf_i_set,0,0}, +{"u",0,_wrap_Cv32suf_u_get,_wrap_Cv32suf_u_set,0,0}, +{"f",0,_wrap_Cv32suf_f_get,_wrap_Cv32suf_f_set,0,0}, +{0,0,0,0} +}; +static const char *swig_Cv32suf_base_names[] = {0}; +static const swig_type_info *swig_Cv32suf_base[] = {0}; +static swig_octave_class _wrap_class_Cv32suf = {"Cv32suf", &SWIGTYPE_p_Cv32suf,0,_wrap_new_Cv32suf,0,_wrap_delete_Cv32suf,swig_Cv32suf_members,swig_Cv32suf_base_names,swig_Cv32suf_base }; + +static octave_value_list _wrap_Cv64suf_i_set (const octave_value_list& args, int nargout) { + Cv64suf *arg1 = (Cv64suf *) 0 ; + int64 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("Cv64suf_i_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv64suf, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv64suf_i_set" "', argument " "1"" of type '" "Cv64suf *""'"); + } + arg1 = (Cv64suf *)(argp1); + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_int64_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cv64suf_i_set" "', argument " "2"" of type '" "int64""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cv64suf_i_set" "', argument " "2"" of type '" "int64""'"); + } else { + arg2 = *((int64 *)(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_Cv64suf_i_get (const octave_value_list& args, int nargout) { + Cv64suf *arg1 = (Cv64suf *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int64 result; + + if (!SWIG_check_num_args("Cv64suf_i_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv64suf, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv64suf_i_get" "', argument " "1"" of type '" "Cv64suf *""'"); + } + arg1 = (Cv64suf *)(argp1); + result = ((arg1)->i); + _outv = SWIG_NewPointerObj((new int64((const int64&)(result))), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_Cv64suf_u_set (const octave_value_list& args, int nargout) { + Cv64suf *arg1 = (Cv64suf *) 0 ; + uint64 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("Cv64suf_u_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv64suf, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv64suf_u_set" "', argument " "1"" of type '" "Cv64suf *""'"); + } + arg1 = (Cv64suf *)(argp1); + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_uint64_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cv64suf_u_set" "', argument " "2"" of type '" "uint64""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cv64suf_u_set" "', argument " "2"" of type '" "uint64""'"); + } else { + arg2 = *((uint64 *)(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_Cv64suf_u_get (const octave_value_list& args, int nargout) { + Cv64suf *arg1 = (Cv64suf *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + uint64 result; + + if (!SWIG_check_num_args("Cv64suf_u_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv64suf, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv64suf_u_get" "', argument " "1"" of type '" "Cv64suf *""'"); + } + arg1 = (Cv64suf *)(argp1); + result = ((arg1)->u); + _outv = SWIG_NewPointerObj((new uint64((const uint64&)(result))), SWIGTYPE_p_uint64_t, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_Cv64suf_f_set (const octave_value_list& args, int nargout) { + Cv64suf *arg1 = (Cv64suf *) 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("Cv64suf_f_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv64suf, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv64suf_f_set" "', argument " "1"" of type '" "Cv64suf *""'"); + } + arg1 = (Cv64suf *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cv64suf_f_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->f = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_Cv64suf_f_get (const octave_value_list& args, int nargout) { + Cv64suf *arg1 = (Cv64suf *) 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("Cv64suf_f_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv64suf, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cv64suf_f_get" "', argument " "1"" of type '" "Cv64suf *""'"); + } + arg1 = (Cv64suf *)(argp1); + result = (double) ((arg1)->f); + _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_Cv64suf (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + Cv64suf *result = 0 ; + + if (!SWIG_check_num_args("new_Cv64suf",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (Cv64suf *)new Cv64suf(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Cv64suf, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_Cv64suf (const octave_value_list& args, int nargout) { + Cv64suf *arg1 = (Cv64suf *) 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_Cv64suf",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_Cv64suf, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cv64suf" "', argument " "1"" of type '" "Cv64suf *""'"); + } + arg1 = (Cv64suf *)(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_Cv64suf_members[] = { +{"i",0,_wrap_Cv64suf_i_get,_wrap_Cv64suf_i_set,0,0}, +{"u",0,_wrap_Cv64suf_u_get,_wrap_Cv64suf_u_set,0,0}, +{"f",0,_wrap_Cv64suf_f_get,_wrap_Cv64suf_f_set,0,0}, +{0,0,0,0} +}; +static const char *swig_Cv64suf_base_names[] = {0}; +static const swig_type_info *swig_Cv64suf_base[] = {0}; +static swig_octave_class _wrap_class_Cv64suf = {"Cv64suf", &SWIGTYPE_p_Cv64suf,0,_wrap_new_Cv64suf,0,_wrap_delete_Cv64suf,swig_Cv64suf_members,swig_Cv64suf_base_names,swig_Cv64suf_base }; + +static octave_value_list _wrap_cvRound (const octave_value_list& args, int nargout) { + double arg1 ; + double val1 ; + int ecode1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("cvRound",args.length(),1,1,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvRound" "', argument " "1"" of type '" "double""'"); + } + arg1 = (double)(val1); + { + try { + result = (int)cvRound(arg1); + } + 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_cvFloor (const octave_value_list& args, int nargout) { + double arg1 ; + double val1 ; + int ecode1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("cvFloor",args.length(),1,1,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvFloor" "', argument " "1"" of type '" "double""'"); + } + arg1 = (double)(val1); + { + try { + result = (int)cvFloor(arg1); + } + 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_cvCeil (const octave_value_list& args, int nargout) { + double arg1 ; + double val1 ; + int ecode1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("cvCeil",args.length(),1,1,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvCeil" "', argument " "1"" of type '" "double""'"); + } + arg1 = (double)(val1); + { + try { + result = (int)cvCeil(arg1); + } + 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_cvIsNaN (const octave_value_list& args, int nargout) { + double arg1 ; + double val1 ; + int ecode1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("cvIsNaN",args.length(),1,1,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvIsNaN" "', argument " "1"" of type '" "double""'"); + } + arg1 = (double)(val1); + { + try { + result = (int)cvIsNaN(arg1); + } + 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_cvIsInf (const octave_value_list& args, int nargout) { + double arg1 ; + double val1 ; + int ecode1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("cvIsInf",args.length(),1,1,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvIsInf" "', argument " "1"" of type '" "double""'"); + } + arg1 = (double)(val1); + { + try { + result = (int)cvIsInf(arg1); + } + 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_cvRNG__SWIG_0 (const octave_value_list& args, int nargout) { + int64 arg1 ; + void *argp1 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvRNG result; + + if (!SWIG_check_num_args("cvRNG",args.length(),1,1,0)) { + SWIG_fail; + } + { + res1 = SWIG_ConvertPtr(args(0), &argp1, SWIGTYPE_p_int64_t, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRNG" "', argument " "1"" of type '" "int64""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvRNG" "', argument " "1"" of type '" "int64""'"); + } else { + arg1 = *((int64 *)(argp1)); + } + } + { + try { + result = cvRNG(arg1); + } + 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_cvRNG__SWIG_1 (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvRNG result; + + if (!SWIG_check_num_args("cvRNG",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = cvRNG(); + } + 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_cvRNG (const octave_value_list& args, int nargout) { + int argc = args.length(); + octave_value_ref argv[1]={ + octave_value_ref(args,0) + }; + + if (argc == 0) { + return _wrap_cvRNG__SWIG_1(args, nargout); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int64_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_cvRNG__SWIG_0(args, nargout); + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_cvRandInt (const octave_value_list& args, int nargout) { + CvRNG *arg1 = (CvRNG *) 0 ; + void *vptr1 ; + CvRNG_Wrapper *wrapper1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + unsigned int result; + + if (!SWIG_check_num_args("cvRandInt",args.length(),1,1,0)) { + SWIG_fail; + } + { + if(SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvRNG_Wrapper, 0)==-1){ + SWIG_exception( SWIG_TypeError, "could not convert Octave object to C value"); + SWIG_fail; + } + wrapper1 = (CvRNG_Wrapper *) vptr1; + arg1 = wrapper1->ptr(); + } + { + try { + result = (unsigned int)cvRandInt(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvRandReal (const octave_value_list& args, int nargout) { + CvRNG *arg1 = (CvRNG *) 0 ; + void *vptr1 ; + CvRNG_Wrapper *wrapper1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + double result; + + if (!SWIG_check_num_args("cvRandReal",args.length(),1,1,0)) { + SWIG_fail; + } + { + if(SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvRNG_Wrapper, 0)==-1){ + SWIG_exception( SWIG_TypeError, "could not convert Octave object to C value"); + SWIG_fail; + } + wrapper1 = (CvRNG_Wrapper *) vptr1; + arg1 = wrapper1->ptr(); + } + { + try { + result = (double)cvRandReal(arg1); + } + 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_IplImage_ID_set (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + int arg2 ; + IplImage header1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage_ID_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_ID_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->ID = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_ID_get (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("IplImage_ID_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + result = (int) ((arg1)->ID); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_nChannels_set (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + int arg2 ; + IplImage header1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage_nChannels_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_nChannels_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->nChannels = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_nChannels_get (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("IplImage_nChannels_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + result = (int) ((arg1)->nChannels); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_depth_set (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + int arg2 ; + IplImage header1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage_depth_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_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_IplImage_depth_get (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("IplImage_depth_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + 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_IplImage_dataOrder_set (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + int arg2 ; + IplImage header1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage_dataOrder_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_dataOrder_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->dataOrder = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_dataOrder_get (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("IplImage_dataOrder_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + result = (int) ((arg1)->dataOrder); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_origin_set (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + int arg2 ; + IplImage header1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage_origin_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_origin_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->origin = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_origin_get (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("IplImage_origin_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + result = (int) ((arg1)->origin); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_align_set (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + int arg2 ; + IplImage header1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage_align_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_align_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->align = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_align_get (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("IplImage_align_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + result = (int) ((arg1)->align); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_width_set (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + int arg2 ; + IplImage header1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage_width_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_width_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->width = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_width_get (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("IplImage_width_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + result = (int) ((arg1)->width); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_height_set (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + int arg2 ; + IplImage header1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage_height_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_height_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->height = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_height_get (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("IplImage_height_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + result = (int) ((arg1)->height); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_roi_set (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + _IplROI *arg2 = (_IplROI *) 0 ; + IplImage header1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage_roi_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p__IplROI, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IplImage_roi_set" "', argument " "2"" of type '" "_IplROI *""'"); + } + arg2 = (_IplROI *)(argp2); + if (arg1) (arg1)->roi = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_roi_get (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + _IplROI *result = 0 ; + + if (!SWIG_check_num_args("IplImage_roi_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + result = (_IplROI *) ((arg1)->roi); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__IplROI, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_imageSize_set (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + int arg2 ; + IplImage header1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage_imageSize_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_imageSize_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->imageSize = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_imageSize_get (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("IplImage_imageSize_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + result = (int) ((arg1)->imageSize); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_widthStep_set (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + int arg2 ; + IplImage header1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage_widthStep_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage_widthStep_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->widthStep = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage_widthStep_get (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("IplImage_widthStep_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + result = (int) ((arg1)->widthStep); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_IplImage (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("delete_IplImage",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + try { + delete_IplImage(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_IplImage___add____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___add__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage_operator_Sa___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___mul____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___mul__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage_operator_Sm___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___sub____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___sub__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage_operator_Ss___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___div____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___div__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage_operator_Sd___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___xor____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___xor__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage_operator_Sx___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___add____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvScalar arg2 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___add__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (IplImage *)IplImage_operator_Sa___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___add__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___add____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IplImage___add____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___xor____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvScalar arg2 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___xor__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (IplImage *)IplImage_operator_Sx___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___xor__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___xor____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IplImage___xor____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___sub____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvScalar arg2 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___sub__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (IplImage *)IplImage_operator_Ss___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___sub__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___sub____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IplImage___sub____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___ge____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___ge__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage_operator_Sg__Se___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___ge____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___ge__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___ge__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage_operator_Sg__Se___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___ge__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___ge____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___ge____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___eq____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___eq__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage_operator_Se__Se___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___eq____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___eq__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___eq__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage_operator_Se__Se___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___eq__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___eq____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___eq____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___le____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___le__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage_operator_Sl__Se___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___le____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___le__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___le__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage_operator_Sl__Se___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___le__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___le____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___le____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___ne____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___ne__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage_operator_SN__Se___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___ne____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___ne__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___ne__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage_operator_SN__Se___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___ne__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___ne____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___ne____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___lt____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___lt__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage_operator_Sl___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___lt____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___lt__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___lt__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage_operator_Sl___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___lt__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___lt____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___lt____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___gt____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___gt__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage_operator_Sg___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___gt____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___gt__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___gt__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage_operator_Sg___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___gt__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___gt____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___gt____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___mul____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___mul__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___mul__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage_operator_Sm___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___mul__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___mul____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___mul____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___div____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___div__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___div__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage_operator_Sd___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___div__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___div____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___div____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___radd____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___radd__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage___radd____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rsub____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rsub__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage___rsub____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rdiv____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rdiv__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage___rdiv____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rmul____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rmul__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (IplImage *)IplImage___rmul____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___radd____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvScalar arg2 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___radd__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (IplImage *)IplImage___radd____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___radd____SWIG_2 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___radd__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___radd__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage___radd____SWIG_2(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___radd__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___radd____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IplImage___radd____SWIG_1(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___radd____SWIG_2(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___rsub____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvScalar arg2 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rsub__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (IplImage *)IplImage___rsub____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rsub____SWIG_2 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rsub__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rsub__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage___rsub____SWIG_2(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rsub__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___rsub____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IplImage___rsub____SWIG_1(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___rsub____SWIG_2(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___rmul____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rmul__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rmul__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)IplImage___rmul____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rmul__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___rmul____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___rmul____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___rdiv____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rdiv__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rdiv__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)IplImage___rdiv____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rdiv__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___rdiv____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___rdiv____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___ror____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvScalar arg2 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___ror__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (IplImage *)IplImage___ror____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___ror____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___ror__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___ror__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage___ror____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___ror__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IplImage___ror____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___ror____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___rand____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvScalar arg2 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rand__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (IplImage *)IplImage___rand____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rand____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rand__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rand__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage___rand____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rand__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IplImage___rand____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___rand____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___rxor____SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + CvScalar arg2 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rxor__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (IplImage *)IplImage___rxor____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rxor____SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rxor__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rxor__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage___rxor____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rxor__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IplImage___rxor____SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___rxor____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___req__ (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("IplImage___req__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___req__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)IplImage___req__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rgt__ (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rgt__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rgt__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)IplImage___rgt__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rge__ (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rge__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rge__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)IplImage___rge__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rlt__ (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rlt__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rlt__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)IplImage___rlt__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rle__ (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rle__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rle__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)IplImage___rle__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___rne__ (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("IplImage___rne__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___rne__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)IplImage___rne__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___pow__ (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + double arg2 ; + IplImage header1 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("IplImage___pow__",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplImage___pow__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (IplImage *)IplImage___pow__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___str (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + char *result = 0 ; + + if (!SWIG_check_num_args("IplImage___str",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + try { + result = (char *)IplImage___str(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_FromCharPtr((const char *)result); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___paren_asgn__SWIG_0 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + octave_value arg2 ; + double arg3 ; + IplImage header1 ; + double val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + arg2 = args(1); + ecode3 = SWIG_AsVal_double(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IplImage___paren_asgn" "', argument " "3"" of type '" "double""'"); + } + arg3 = (double)(val3); + { + try { + IplImage___paren_asgn__SWIG_0(arg1,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_IplImage___paren_asgn__SWIG_1 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + octave_value arg2 ; + CvPoint arg3 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + arg2 = args(1); + { + arg3 = OctObject_to_CvPoint(args(2)); + } + { + try { + IplImage___paren_asgn__SWIG_1(arg1,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_IplImage___paren_asgn__SWIG_2 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + octave_value arg2 ; + CvPoint2D32f arg3 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + arg2 = args(1); + { + arg3 = OctObject_to_CvPoint2D32f(args(2)); + } + { + try { + IplImage___paren_asgn__SWIG_2(arg1,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_IplImage___paren_asgn__SWIG_3 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + octave_value arg2 ; + CvScalar arg3 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + arg2 = args(1); + { + arg3 = OctObject_to_CvScalar( args(2) ); + } + { + try { + IplImage___paren_asgn__SWIG_3(arg1,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_IplImage___paren_asgn__SWIG_4 (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + octave_value arg2 ; + CvArr *arg3 = (CvArr *) 0 ; + IplImage header1 ; + bool freearg3 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("IplImage___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + arg2 = args(1); + { + arg3 = OctObject_to_CvArr(args(2), &freearg3); + } + { + try { + IplImage___paren_asgn__SWIG_4(arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg3!=NULL && freearg3){ + cvReleaseData( arg3 ); + cvFree(&(arg3)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_IplImage___paren_asgn (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 == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + _v = (*argv[1]).is_defined(); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvPoint, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IplImage___paren_asgn__SWIG_1(args, nargout); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + _v = (*argv[1]).is_defined(); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvPoint2D32f, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IplImage___paren_asgn__SWIG_2(args, nargout); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + _v = (*argv[1]).is_defined(); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IplImage___paren_asgn__SWIG_3(args, nargout); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + _v = (*argv[1]).is_defined(); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[2]) || OctTuple_Check(argv[2])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[2], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_IplImage___paren_asgn__SWIG_4(args, nargout); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + _v = (*argv[1]).is_defined(); + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IplImage___paren_asgn__SWIG_0(args, nargout); + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_IplImage___paren (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + octave_value arg2 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + octave_value result; + + if (!SWIG_check_num_args("IplImage___paren",args.length(),2,2,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + arg2 = args(1); + { + try { + result = IplImage___paren(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = result; + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static swig_octave_member swig_IplImage_members[] = { +{"ID",0,_wrap_IplImage_ID_get,_wrap_IplImage_ID_set,0,0}, +{"nChannels",0,_wrap_IplImage_nChannels_get,_wrap_IplImage_nChannels_set,0,0}, +{"depth",0,_wrap_IplImage_depth_get,_wrap_IplImage_depth_set,0,0}, +{"dataOrder",0,_wrap_IplImage_dataOrder_get,_wrap_IplImage_dataOrder_set,0,0}, +{"origin",0,_wrap_IplImage_origin_get,_wrap_IplImage_origin_set,0,0}, +{"align",0,_wrap_IplImage_align_get,_wrap_IplImage_align_set,0,0}, +{"width",0,_wrap_IplImage_width_get,_wrap_IplImage_width_set,0,0}, +{"height",0,_wrap_IplImage_height_get,_wrap_IplImage_height_set,0,0}, +{"roi",0,_wrap_IplImage_roi_get,_wrap_IplImage_roi_set,0,0}, +{"imageSize",0,_wrap_IplImage_imageSize_get,_wrap_IplImage_imageSize_set,0,0}, +{"widthStep",0,_wrap_IplImage_widthStep_get,_wrap_IplImage_widthStep_set,0,0}, +{"__add__",_wrap_IplImage___add__,0,0,0,0}, +{"__xor__",_wrap_IplImage___xor__,0,0,0,0}, +{"__sub__",_wrap_IplImage___sub__,0,0,0,0}, +{"__ge__",_wrap_IplImage___ge__,0,0,0,0}, +{"__eq__",_wrap_IplImage___eq__,0,0,0,0}, +{"__le__",_wrap_IplImage___le__,0,0,0,0}, +{"__ne__",_wrap_IplImage___ne__,0,0,0,0}, +{"__lt__",_wrap_IplImage___lt__,0,0,0,0}, +{"__gt__",_wrap_IplImage___gt__,0,0,0,0}, +{"__mul__",_wrap_IplImage___mul__,0,0,0,0}, +{"__div__",_wrap_IplImage___div__,0,0,0,0}, +{"__radd__",_wrap_IplImage___radd__,0,0,0,0}, +{"__rsub__",_wrap_IplImage___rsub__,0,0,0,0}, +{"__rmul__",_wrap_IplImage___rmul__,0,0,0,0}, +{"__rdiv__",_wrap_IplImage___rdiv__,0,0,0,0}, +{"__ror__",_wrap_IplImage___ror__,0,0,0,0}, +{"__rand__",_wrap_IplImage___rand__,0,0,0,0}, +{"__rxor__",_wrap_IplImage___rxor__,0,0,0,0}, +{"__req__",_wrap_IplImage___req__,0,0,0,0}, +{"__rgt__",_wrap_IplImage___rgt__,0,0,0,0}, +{"__rge__",_wrap_IplImage___rge__,0,0,0,0}, +{"__rlt__",_wrap_IplImage___rlt__,0,0,0,0}, +{"__rle__",_wrap_IplImage___rle__,0,0,0,0}, +{"__rne__",_wrap_IplImage___rne__,0,0,0,0}, +{"__pow__",_wrap_IplImage___pow__,0,0,0,0}, +{"__str",_wrap_IplImage___str,0,0,0,0}, +{"__paren_asgn",_wrap_IplImage___paren_asgn,0,0,0,0}, +{"__paren",_wrap_IplImage___paren,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_IplImage_base_names[] = {0}; +static const swig_type_info *swig_IplImage_base[] = {0}; +static swig_octave_class _wrap_class_IplImage = {"IplImage", &SWIGTYPE_p__IplImage,0,0,0,_wrap_delete_IplImage,swig_IplImage_members,swig_IplImage_base_names,swig_IplImage_base }; + +static octave_value_list _wrap_IplROI_coi_set (const octave_value_list& args, int nargout) { + IplROI *arg1 = (IplROI *) 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("IplROI_coi_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplROI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_coi_set" "', argument " "1"" of type '" "IplROI *""'"); + } + arg1 = (IplROI *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplROI_coi_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->coi = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplROI_coi_get (const octave_value_list& args, int nargout) { + IplROI *arg1 = (IplROI *) 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("IplROI_coi_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplROI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_coi_get" "', argument " "1"" of type '" "IplROI *""'"); + } + arg1 = (IplROI *)(argp1); + result = (int) ((arg1)->coi); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplROI_xOffset_set (const octave_value_list& args, int nargout) { + IplROI *arg1 = (IplROI *) 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("IplROI_xOffset_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplROI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_xOffset_set" "', argument " "1"" of type '" "IplROI *""'"); + } + arg1 = (IplROI *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplROI_xOffset_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->xOffset = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplROI_xOffset_get (const octave_value_list& args, int nargout) { + IplROI *arg1 = (IplROI *) 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("IplROI_xOffset_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplROI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_xOffset_get" "', argument " "1"" of type '" "IplROI *""'"); + } + arg1 = (IplROI *)(argp1); + result = (int) ((arg1)->xOffset); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplROI_yOffset_set (const octave_value_list& args, int nargout) { + IplROI *arg1 = (IplROI *) 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("IplROI_yOffset_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplROI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_yOffset_set" "', argument " "1"" of type '" "IplROI *""'"); + } + arg1 = (IplROI *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplROI_yOffset_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->yOffset = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplROI_yOffset_get (const octave_value_list& args, int nargout) { + IplROI *arg1 = (IplROI *) 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("IplROI_yOffset_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplROI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_yOffset_get" "', argument " "1"" of type '" "IplROI *""'"); + } + arg1 = (IplROI *)(argp1); + result = (int) ((arg1)->yOffset); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplROI_width_set (const octave_value_list& args, int nargout) { + IplROI *arg1 = (IplROI *) 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("IplROI_width_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplROI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_width_set" "', argument " "1"" of type '" "IplROI *""'"); + } + arg1 = (IplROI *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplROI_width_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->width = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplROI_width_get (const octave_value_list& args, int nargout) { + IplROI *arg1 = (IplROI *) 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("IplROI_width_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplROI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_width_get" "', argument " "1"" of type '" "IplROI *""'"); + } + arg1 = (IplROI *)(argp1); + result = (int) ((arg1)->width); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplROI_height_set (const octave_value_list& args, int nargout) { + IplROI *arg1 = (IplROI *) 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("IplROI_height_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplROI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_height_set" "', argument " "1"" of type '" "IplROI *""'"); + } + arg1 = (IplROI *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplROI_height_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->height = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplROI_height_get (const octave_value_list& args, int nargout) { + IplROI *arg1 = (IplROI *) 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("IplROI_height_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplROI, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplROI_height_get" "', argument " "1"" of type '" "IplROI *""'"); + } + arg1 = (IplROI *)(argp1); + result = (int) ((arg1)->height); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_IplROI (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplROI *result = 0 ; + + if (!SWIG_check_num_args("new_IplROI",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (IplROI *)new IplROI(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__IplROI, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_IplROI (const octave_value_list& args, int nargout) { + IplROI *arg1 = (IplROI *) 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_IplROI",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplROI, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IplROI" "', argument " "1"" of type '" "IplROI *""'"); + } + arg1 = (IplROI *)(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_IplROI_members[] = { +{"coi",0,_wrap_IplROI_coi_get,_wrap_IplROI_coi_set,0,0}, +{"xOffset",0,_wrap_IplROI_xOffset_get,_wrap_IplROI_xOffset_set,0,0}, +{"yOffset",0,_wrap_IplROI_yOffset_get,_wrap_IplROI_yOffset_set,0,0}, +{"width",0,_wrap_IplROI_width_get,_wrap_IplROI_width_set,0,0}, +{"height",0,_wrap_IplROI_height_get,_wrap_IplROI_height_set,0,0}, +{0,0,0,0} +}; +static const char *swig_IplROI_base_names[] = {0}; +static const swig_type_info *swig_IplROI_base[] = {0}; +static swig_octave_class _wrap_class_IplROI = {"IplROI", &SWIGTYPE_p__IplROI,0,_wrap_new_IplROI,0,_wrap_delete_IplROI,swig_IplROI_members,swig_IplROI_base_names,swig_IplROI_base }; + +static octave_value_list _wrap_IplConvKernel_nCols_set (const octave_value_list& args, int nargout) { + IplConvKernel *arg1 = (IplConvKernel *) 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("IplConvKernel_nCols_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_nCols_set" "', argument " "1"" of type '" "IplConvKernel *""'"); + } + arg1 = (IplConvKernel *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernel_nCols_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->nCols = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernel_nCols_get (const octave_value_list& args, int nargout) { + IplConvKernel *arg1 = (IplConvKernel *) 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("IplConvKernel_nCols_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_nCols_get" "', argument " "1"" of type '" "IplConvKernel *""'"); + } + arg1 = (IplConvKernel *)(argp1); + result = (int) ((arg1)->nCols); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernel_nRows_set (const octave_value_list& args, int nargout) { + IplConvKernel *arg1 = (IplConvKernel *) 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("IplConvKernel_nRows_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_nRows_set" "', argument " "1"" of type '" "IplConvKernel *""'"); + } + arg1 = (IplConvKernel *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernel_nRows_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->nRows = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernel_nRows_get (const octave_value_list& args, int nargout) { + IplConvKernel *arg1 = (IplConvKernel *) 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("IplConvKernel_nRows_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_nRows_get" "', argument " "1"" of type '" "IplConvKernel *""'"); + } + arg1 = (IplConvKernel *)(argp1); + result = (int) ((arg1)->nRows); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernel_anchorX_set (const octave_value_list& args, int nargout) { + IplConvKernel *arg1 = (IplConvKernel *) 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("IplConvKernel_anchorX_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_anchorX_set" "', argument " "1"" of type '" "IplConvKernel *""'"); + } + arg1 = (IplConvKernel *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernel_anchorX_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->anchorX = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernel_anchorX_get (const octave_value_list& args, int nargout) { + IplConvKernel *arg1 = (IplConvKernel *) 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("IplConvKernel_anchorX_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_anchorX_get" "', argument " "1"" of type '" "IplConvKernel *""'"); + } + arg1 = (IplConvKernel *)(argp1); + result = (int) ((arg1)->anchorX); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernel_anchorY_set (const octave_value_list& args, int nargout) { + IplConvKernel *arg1 = (IplConvKernel *) 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("IplConvKernel_anchorY_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_anchorY_set" "', argument " "1"" of type '" "IplConvKernel *""'"); + } + arg1 = (IplConvKernel *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernel_anchorY_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->anchorY = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernel_anchorY_get (const octave_value_list& args, int nargout) { + IplConvKernel *arg1 = (IplConvKernel *) 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("IplConvKernel_anchorY_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_anchorY_get" "', argument " "1"" of type '" "IplConvKernel *""'"); + } + arg1 = (IplConvKernel *)(argp1); + result = (int) ((arg1)->anchorY); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernel_values_set (const octave_value_list& args, int nargout) { + IplConvKernel *arg1 = (IplConvKernel *) 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("IplConvKernel_values_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_values_set" "', argument " "1"" of type '" "IplConvKernel *""'"); + } + arg1 = (IplConvKernel *)(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 '" "IplConvKernel_values_set" "', argument " "2"" of type '" "int *""'"); + } + arg2 = (int *)(argp2); + if (arg1) (arg1)->values = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernel_values_get (const octave_value_list& args, int nargout) { + IplConvKernel *arg1 = (IplConvKernel *) 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("IplConvKernel_values_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_values_get" "', argument " "1"" of type '" "IplConvKernel *""'"); + } + arg1 = (IplConvKernel *)(argp1); + result = (int *) ((arg1)->values); + _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_IplConvKernel_nShiftR_set (const octave_value_list& args, int nargout) { + IplConvKernel *arg1 = (IplConvKernel *) 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("IplConvKernel_nShiftR_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_nShiftR_set" "', argument " "1"" of type '" "IplConvKernel *""'"); + } + arg1 = (IplConvKernel *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernel_nShiftR_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->nShiftR = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernel_nShiftR_get (const octave_value_list& args, int nargout) { + IplConvKernel *arg1 = (IplConvKernel *) 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("IplConvKernel_nShiftR_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernel, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernel_nShiftR_get" "', argument " "1"" of type '" "IplConvKernel *""'"); + } + arg1 = (IplConvKernel *)(argp1); + result = (int) ((arg1)->nShiftR); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_IplConvKernel (const octave_value_list& args, int nargout) { + IplConvKernel *arg1 = (IplConvKernel *) 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_IplConvKernel",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernel, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IplConvKernel" "', argument " "1"" of type '" "IplConvKernel *""'"); + } + arg1 = (IplConvKernel *)(argp1); + { + try { + delete_IplConvKernel(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_IplConvKernel_members[] = { +{"nCols",0,_wrap_IplConvKernel_nCols_get,_wrap_IplConvKernel_nCols_set,0,0}, +{"nRows",0,_wrap_IplConvKernel_nRows_get,_wrap_IplConvKernel_nRows_set,0,0}, +{"anchorX",0,_wrap_IplConvKernel_anchorX_get,_wrap_IplConvKernel_anchorX_set,0,0}, +{"anchorY",0,_wrap_IplConvKernel_anchorY_get,_wrap_IplConvKernel_anchorY_set,0,0}, +{"values",0,_wrap_IplConvKernel_values_get,_wrap_IplConvKernel_values_set,0,0}, +{"nShiftR",0,_wrap_IplConvKernel_nShiftR_get,_wrap_IplConvKernel_nShiftR_set,0,0}, +{0,0,0,0} +}; +static const char *swig_IplConvKernel_base_names[] = {0}; +static const swig_type_info *swig_IplConvKernel_base[] = {0}; +static swig_octave_class _wrap_class_IplConvKernel = {"IplConvKernel", &SWIGTYPE_p__IplConvKernel,0,0,0,_wrap_delete_IplConvKernel,swig_IplConvKernel_members,swig_IplConvKernel_base_names,swig_IplConvKernel_base }; + +static octave_value_list _wrap_IplConvKernelFP_nCols_set (const octave_value_list& args, int nargout) { + IplConvKernelFP *arg1 = (IplConvKernelFP *) 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("IplConvKernelFP_nCols_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_nCols_set" "', argument " "1"" of type '" "IplConvKernelFP *""'"); + } + arg1 = (IplConvKernelFP *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernelFP_nCols_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->nCols = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernelFP_nCols_get (const octave_value_list& args, int nargout) { + IplConvKernelFP *arg1 = (IplConvKernelFP *) 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("IplConvKernelFP_nCols_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_nCols_get" "', argument " "1"" of type '" "IplConvKernelFP *""'"); + } + arg1 = (IplConvKernelFP *)(argp1); + result = (int) ((arg1)->nCols); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernelFP_nRows_set (const octave_value_list& args, int nargout) { + IplConvKernelFP *arg1 = (IplConvKernelFP *) 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("IplConvKernelFP_nRows_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_nRows_set" "', argument " "1"" of type '" "IplConvKernelFP *""'"); + } + arg1 = (IplConvKernelFP *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernelFP_nRows_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->nRows = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernelFP_nRows_get (const octave_value_list& args, int nargout) { + IplConvKernelFP *arg1 = (IplConvKernelFP *) 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("IplConvKernelFP_nRows_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_nRows_get" "', argument " "1"" of type '" "IplConvKernelFP *""'"); + } + arg1 = (IplConvKernelFP *)(argp1); + result = (int) ((arg1)->nRows); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernelFP_anchorX_set (const octave_value_list& args, int nargout) { + IplConvKernelFP *arg1 = (IplConvKernelFP *) 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("IplConvKernelFP_anchorX_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_anchorX_set" "', argument " "1"" of type '" "IplConvKernelFP *""'"); + } + arg1 = (IplConvKernelFP *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernelFP_anchorX_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->anchorX = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernelFP_anchorX_get (const octave_value_list& args, int nargout) { + IplConvKernelFP *arg1 = (IplConvKernelFP *) 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("IplConvKernelFP_anchorX_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_anchorX_get" "', argument " "1"" of type '" "IplConvKernelFP *""'"); + } + arg1 = (IplConvKernelFP *)(argp1); + result = (int) ((arg1)->anchorX); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernelFP_anchorY_set (const octave_value_list& args, int nargout) { + IplConvKernelFP *arg1 = (IplConvKernelFP *) 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("IplConvKernelFP_anchorY_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_anchorY_set" "', argument " "1"" of type '" "IplConvKernelFP *""'"); + } + arg1 = (IplConvKernelFP *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IplConvKernelFP_anchorY_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->anchorY = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernelFP_anchorY_get (const octave_value_list& args, int nargout) { + IplConvKernelFP *arg1 = (IplConvKernelFP *) 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("IplConvKernelFP_anchorY_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_anchorY_get" "', argument " "1"" of type '" "IplConvKernelFP *""'"); + } + arg1 = (IplConvKernelFP *)(argp1); + result = (int) ((arg1)->anchorY); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernelFP_values_set (const octave_value_list& args, int nargout) { + IplConvKernelFP *arg1 = (IplConvKernelFP *) 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("IplConvKernelFP_values_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_values_set" "', argument " "1"" of type '" "IplConvKernelFP *""'"); + } + arg1 = (IplConvKernelFP *)(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 '" "IplConvKernelFP_values_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->values = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_IplConvKernelFP_values_get (const octave_value_list& args, int nargout) { + IplConvKernelFP *arg1 = (IplConvKernelFP *) 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("IplConvKernelFP_values_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernelFP, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IplConvKernelFP_values_get" "', argument " "1"" of type '" "IplConvKernelFP *""'"); + } + arg1 = (IplConvKernelFP *)(argp1); + result = (float *) ((arg1)->values); + _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_IplConvKernelFP (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplConvKernelFP *result = 0 ; + + if (!SWIG_check_num_args("new_IplConvKernelFP",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (IplConvKernelFP *)new IplConvKernelFP(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__IplConvKernelFP, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_IplConvKernelFP (const octave_value_list& args, int nargout) { + IplConvKernelFP *arg1 = (IplConvKernelFP *) 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_IplConvKernelFP",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p__IplConvKernelFP, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IplConvKernelFP" "', argument " "1"" of type '" "IplConvKernelFP *""'"); + } + arg1 = (IplConvKernelFP *)(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_IplConvKernelFP_members[] = { +{"nCols",0,_wrap_IplConvKernelFP_nCols_get,_wrap_IplConvKernelFP_nCols_set,0,0}, +{"nRows",0,_wrap_IplConvKernelFP_nRows_get,_wrap_IplConvKernelFP_nRows_set,0,0}, +{"anchorX",0,_wrap_IplConvKernelFP_anchorX_get,_wrap_IplConvKernelFP_anchorX_set,0,0}, +{"anchorY",0,_wrap_IplConvKernelFP_anchorY_get,_wrap_IplConvKernelFP_anchorY_set,0,0}, +{"values",0,_wrap_IplConvKernelFP_values_get,_wrap_IplConvKernelFP_values_set,0,0}, +{0,0,0,0} +}; +static const char *swig_IplConvKernelFP_base_names[] = {0}; +static const swig_type_info *swig_IplConvKernelFP_base[] = {0}; +static swig_octave_class _wrap_class_IplConvKernelFP = {"IplConvKernelFP", &SWIGTYPE_p__IplConvKernelFP,0,_wrap_new_IplConvKernelFP,0,_wrap_delete_IplConvKernelFP,swig_IplConvKernelFP_members,swig_IplConvKernelFP_base_names,swig_IplConvKernelFP_base }; + +static octave_value_list _wrap_CvMat_type_set (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; + + if (!SWIG_check_num_args("CvMat_type_set",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 '" "CvMat_type_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_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_CvMat_type_get (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; + int result; + + if (!SWIG_check_num_args("CvMat_type_get",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 '" "CvMat_type_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(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_CvMat_step_set (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; + + if (!SWIG_check_num_args("CvMat_step_set",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 '" "CvMat_step_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_step_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(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_CvMat_step_get (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; + int result; + + if (!SWIG_check_num_args("CvMat_step_get",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 '" "CvMat_step_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + result = (int) ((arg1)->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_CvMat_refcount_set (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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("CvMat_refcount_set",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 '" "CvMat_refcount_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(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 '" "CvMat_refcount_set" "', argument " "2"" of type '" "int *""'"); + } + arg2 = (int *)(argp2); + if (arg1) (arg1)->refcount = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat_refcount_get (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; + int *result = 0 ; + + if (!SWIG_check_num_args("CvMat_refcount_get",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 '" "CvMat_refcount_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + result = (int *) ((arg1)->refcount); + _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_CvMat_hdr_refcount_set (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; + + if (!SWIG_check_num_args("CvMat_hdr_refcount_set",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 '" "CvMat_hdr_refcount_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_hdr_refcount_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->hdr_refcount = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat_hdr_refcount_get (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; + int result; + + if (!SWIG_check_num_args("CvMat_hdr_refcount_get",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 '" "CvMat_hdr_refcount_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + result = (int) ((arg1)->hdr_refcount); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat_data_get (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; + CvMat_data *result = 0 ; + + if (!SWIG_check_num_args("CvMat_data_get",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 '" "CvMat_data_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + result = (CvMat_data *)& ((arg1)->data); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat_data, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvMat (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; + + if (!SWIG_check_num_args("delete_CvMat",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMat" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + delete_CvMat(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_CvMat_depth_set (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; + + if (!SWIG_check_num_args("CvMat_depth_set",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 '" "CvMat_depth_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_depth_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + CvMat_depth_set(arg1,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_CvMat_depth_get (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; + int result; + + if (!SWIG_check_num_args("CvMat_depth_get",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 '" "CvMat_depth_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = (int)CvMat_depth_get(arg1); + } + 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_CvMat_nChannels_set (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; + + if (!SWIG_check_num_args("CvMat_nChannels_set",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 '" "CvMat_nChannels_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_nChannels_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + CvMat_nChannels_set(arg1,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_CvMat_nChannels_get (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; + int result; + + if (!SWIG_check_num_args("CvMat_nChannels_get",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 '" "CvMat_nChannels_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = (int)CvMat_nChannels_get(arg1); + } + 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_CvMat_dataOrder_set (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; + + if (!SWIG_check_num_args("CvMat_dataOrder_set",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 '" "CvMat_dataOrder_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_dataOrder_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + CvMat_dataOrder_set(arg1,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_CvMat_dataOrder_get (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; + int result; + + if (!SWIG_check_num_args("CvMat_dataOrder_get",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 '" "CvMat_dataOrder_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = (int)CvMat_dataOrder_get(arg1); + } + 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_CvMat_origin_set (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; + + if (!SWIG_check_num_args("CvMat_origin_set",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 '" "CvMat_origin_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_origin_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + CvMat_origin_set(arg1,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_CvMat_origin_get (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; + int result; + + if (!SWIG_check_num_args("CvMat_origin_get",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 '" "CvMat_origin_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = (int)CvMat_origin_get(arg1); + } + 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_CvMat_width_set (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; + + if (!SWIG_check_num_args("CvMat_width_set",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 '" "CvMat_width_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_width_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + CvMat_width_set(arg1,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_CvMat_width_get (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; + int result; + + if (!SWIG_check_num_args("CvMat_width_get",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 '" "CvMat_width_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = (int)CvMat_width_get(arg1); + } + 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_CvMat_height_set (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; + + if (!SWIG_check_num_args("CvMat_height_set",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 '" "CvMat_height_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_height_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + CvMat_height_set(arg1,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_CvMat_height_get (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; + int result; + + if (!SWIG_check_num_args("CvMat_height_get",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 '" "CvMat_height_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = (int)CvMat_height_get(arg1); + } + 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_CvMat_imageSize_set (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; + + if (!SWIG_check_num_args("CvMat_imageSize_set",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 '" "CvMat_imageSize_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_imageSize_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + CvMat_imageSize_set(arg1,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_CvMat_imageSize_get (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; + int result; + + if (!SWIG_check_num_args("CvMat_imageSize_get",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 '" "CvMat_imageSize_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = (int)CvMat_imageSize_get(arg1); + } + 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_CvMat_widthStep_set (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; + + if (!SWIG_check_num_args("CvMat_widthStep_set",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 '" "CvMat_widthStep_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_widthStep_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + CvMat_widthStep_set(arg1,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_CvMat_widthStep_get (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; + int result; + + if (!SWIG_check_num_args("CvMat_widthStep_get",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 '" "CvMat_widthStep_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = (int)CvMat_widthStep_get(arg1); + } + 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_CvMat_rows_set (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; + + if (!SWIG_check_num_args("CvMat_rows_set",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 '" "CvMat_rows_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_rows_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + CvMat_rows_set(arg1,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_CvMat_rows_get (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; + int result; + + if (!SWIG_check_num_args("CvMat_rows_get",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 '" "CvMat_rows_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = (int)CvMat_rows_get(arg1); + } + 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_CvMat_cols_set (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; + + if (!SWIG_check_num_args("CvMat_cols_set",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 '" "CvMat_cols_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat_cols_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + CvMat_cols_set(arg1,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_CvMat_cols_get (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; + int result; + + if (!SWIG_check_num_args("CvMat_cols_get",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 '" "CvMat_cols_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = (int)CvMat_cols_get(arg1); + } + 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_CvMat___add____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___add__",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 '" "CvMat___add__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat_operator_Sa___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___mul____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___mul__",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 '" "CvMat___mul__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat_operator_Sm___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___sub____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___sub__",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 '" "CvMat___sub__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat_operator_Ss___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___div____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___div__",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 '" "CvMat___div__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat_operator_Sd___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___xor____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___xor__",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 '" "CvMat___xor__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat_operator_Sx___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___add____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvScalar arg2 ; + 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("CvMat___add__",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 '" "CvMat___add__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (CvMat *)CvMat_operator_Sa___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___add__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___add____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_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMat___add____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___xor____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvScalar arg2 ; + 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("CvMat___xor__",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 '" "CvMat___xor__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (CvMat *)CvMat_operator_Sx___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___xor__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___xor____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_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMat___xor____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___sub____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvScalar arg2 ; + 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("CvMat___sub__",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 '" "CvMat___sub__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (CvMat *)CvMat_operator_Ss___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___sub__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___sub____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_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMat___sub____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___ge____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___ge__",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 '" "CvMat___ge__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat_operator_Sg__Se___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___ge____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___ge__",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 '" "CvMat___ge__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___ge__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat_operator_Sg__Se___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___ge__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___ge____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) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___ge____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___eq____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___eq__",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 '" "CvMat___eq__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat_operator_Se__Se___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___eq____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___eq__",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 '" "CvMat___eq__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___eq__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat_operator_Se__Se___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___eq__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___eq____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) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___eq____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___le____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___le__",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 '" "CvMat___le__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat_operator_Sl__Se___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___le____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___le__",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 '" "CvMat___le__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___le__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat_operator_Sl__Se___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___le__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___le____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) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___le____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___ne____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___ne__",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 '" "CvMat___ne__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat_operator_SN__Se___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___ne____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___ne__",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 '" "CvMat___ne__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___ne__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat_operator_SN__Se___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___ne__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___ne____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) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___ne____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___lt____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___lt__",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 '" "CvMat___lt__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat_operator_Sl___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___lt____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___lt__",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 '" "CvMat___lt__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___lt__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat_operator_Sl___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___lt__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___lt____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) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___lt____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___gt____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___gt__",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 '" "CvMat___gt__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat_operator_Sg___SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___gt____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___gt__",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 '" "CvMat___gt__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___gt__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat_operator_Sg___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___gt__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___gt____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) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___gt____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___mul____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___mul__",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 '" "CvMat___mul__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___mul__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat_operator_Sm___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___mul__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___mul____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) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___mul____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___div____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___div__",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 '" "CvMat___div__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___div__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat_operator_Sd___SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___div__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___div____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) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___div____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___radd____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___radd__",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 '" "CvMat___radd__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat___radd____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rsub____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___rsub__",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 '" "CvMat___rsub__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat___rsub____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rdiv____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___rdiv__",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 '" "CvMat___rdiv__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat___rdiv____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rmul____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___rmul__",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 '" "CvMat___rmul__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + result = (CvMat *)CvMat___rmul____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___radd____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvScalar arg2 ; + 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("CvMat___radd__",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 '" "CvMat___radd__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (CvMat *)CvMat___radd____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___radd____SWIG_2 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___radd__",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 '" "CvMat___radd__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___radd__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat___radd____SWIG_2(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___radd__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___radd____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_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMat___radd____SWIG_1(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_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___radd____SWIG_2(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___rsub____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvScalar arg2 ; + 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("CvMat___rsub__",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 '" "CvMat___rsub__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (CvMat *)CvMat___rsub____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rsub____SWIG_2 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___rsub__",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 '" "CvMat___rsub__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rsub__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat___rsub____SWIG_2(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rsub__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___rsub____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_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMat___rsub____SWIG_1(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_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___rsub____SWIG_2(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___rmul____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("CvMat___rmul__",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 '" "CvMat___rmul__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rmul__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)CvMat___rmul____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rmul__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___rmul____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) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___rmul____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___rdiv____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("CvMat___rdiv__",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 '" "CvMat___rdiv__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rdiv__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)CvMat___rdiv____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rdiv__ (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[1]) || OctTuple_Check(argv[1])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[1], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___rdiv____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) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___rdiv____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___ror____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvScalar arg2 ; + 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("CvMat___ror__",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 '" "CvMat___ror__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (CvMat *)CvMat___ror____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___ror____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___ror__",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 '" "CvMat___ror__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___ror__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat___ror____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___ror__ (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 == 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_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMat___ror____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) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___ror____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___rand____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvScalar arg2 ; + 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("CvMat___rand__",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 '" "CvMat___rand__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (CvMat *)CvMat___rand____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rand____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___rand__",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 '" "CvMat___rand__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rand__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat___rand____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rand__ (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 == 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_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMat___rand____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) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___rand____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___rxor____SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvScalar arg2 ; + 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("CvMat___rxor__",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 '" "CvMat___rxor__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + arg2 = OctObject_to_CvScalar( args(1) ); + } + { + try { + result = (CvMat *)CvMat___rxor____SWIG_0(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rxor____SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___rxor__",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 '" "CvMat___rxor__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rxor__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat___rxor____SWIG_1(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rxor__ (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 == 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_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMat___rxor____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) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___rxor____SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___req__ (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("CvMat___req__",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 '" "CvMat___req__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___req__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)CvMat___req__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rgt__ (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("CvMat___rgt__",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 '" "CvMat___rgt__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rgt__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)CvMat___rgt__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rge__ (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("CvMat___rge__",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 '" "CvMat___rge__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rge__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)CvMat___rge__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rlt__ (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("CvMat___rlt__",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 '" "CvMat___rlt__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rlt__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)CvMat___rlt__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rle__ (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("CvMat___rle__",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 '" "CvMat___rle__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rle__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)CvMat___rle__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___rne__ (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("CvMat___rne__",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 '" "CvMat___rne__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___rne__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvArr *)CvMat___rne__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___pow__ (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("CvMat___pow__",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 '" "CvMat___pow__" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMat___pow__" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = (CvMat *)CvMat___pow__(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___str (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; + char *result = 0 ; + + if (!SWIG_check_num_args("CvMat___str",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 '" "CvMat___str" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = (char *)CvMat___str(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_FromCharPtr((const char *)result); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___paren_asgn__SWIG_0 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + octave_value arg2 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvMat___paren_asgn",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 '" "CvMat___paren_asgn" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + arg2 = args(1); + ecode3 = SWIG_AsVal_double(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMat___paren_asgn" "', argument " "3"" of type '" "double""'"); + } + arg3 = (double)(val3); + { + try { + CvMat___paren_asgn__SWIG_0(arg1,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_CvMat___paren_asgn__SWIG_1 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + octave_value arg2 ; + CvPoint arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvMat___paren_asgn",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 '" "CvMat___paren_asgn" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + arg2 = args(1); + { + arg3 = OctObject_to_CvPoint(args(2)); + } + { + try { + CvMat___paren_asgn__SWIG_1(arg1,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_CvMat___paren_asgn__SWIG_2 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + octave_value arg2 ; + CvPoint2D32f arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvMat___paren_asgn",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 '" "CvMat___paren_asgn" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + arg2 = args(1); + { + arg3 = OctObject_to_CvPoint2D32f(args(2)); + } + { + try { + CvMat___paren_asgn__SWIG_2(arg1,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_CvMat___paren_asgn__SWIG_3 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + octave_value arg2 ; + CvScalar arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvMat___paren_asgn",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 '" "CvMat___paren_asgn" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + arg2 = args(1); + { + arg3 = OctObject_to_CvScalar( args(2) ); + } + { + try { + CvMat___paren_asgn__SWIG_3(arg1,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_CvMat___paren_asgn__SWIG_4 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + octave_value arg2 ; + CvArr *arg3 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg3 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvMat___paren_asgn",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 '" "CvMat___paren_asgn" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + arg2 = args(1); + { + arg3 = OctObject_to_CvArr(args(2), &freearg3); + } + { + try { + CvMat___paren_asgn__SWIG_4(arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg3!=NULL && freearg3){ + cvReleaseData( arg3 ); + cvFree(&(arg3)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat___paren_asgn (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 == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + _v = (*argv[1]).is_defined(); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvPoint, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMat___paren_asgn__SWIG_1(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) { + _v = (*argv[1]).is_defined(); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvPoint2D32f, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMat___paren_asgn__SWIG_2(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) { + _v = (*argv[1]).is_defined(); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CvScalar, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMat___paren_asgn__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) { + _v = (*argv[1]).is_defined(); + if (_v) { + { + void *ptr; + if(OctList_Check(argv[2]) || OctTuple_Check(argv[2])) { + _v = 1; + } + else if (SWIG_ConvertPtr(argv[2], &ptr, 0, 0) == -1) { + _v = 0; + } + else{ + _v = 1; + } + } + if (_v) { + return _wrap_CvMat___paren_asgn__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) { + _v = (*argv[1]).is_defined(); + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMat___paren_asgn__SWIG_0(args, nargout); + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMat___paren (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + octave_value arg2 ; + 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("CvMat___paren",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 '" "CvMat___paren" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + arg2 = args(1); + { + try { + result = CvMat___paren(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = result; + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat_imageData_set (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + octave_value arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvMat_imageData_set",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 '" "CvMat_imageData_set" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + arg2 = args(1); + { + try { + CvMat_imageData_set(arg1,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_CvMat_imageData_get (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; + octave_value result; + + if (!SWIG_check_num_args("CvMat_imageData_get",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 '" "CvMat_imageData_get" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = CvMat_imageData_get(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = result; + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static swig_octave_member swig_CvMat_members[] = { +{"type",0,_wrap_CvMat_type_get,_wrap_CvMat_type_set,0,0}, +{"step",0,_wrap_CvMat_step_get,_wrap_CvMat_step_set,0,0}, +{"refcount",0,_wrap_CvMat_refcount_get,_wrap_CvMat_refcount_set,0,0}, +{"hdr_refcount",0,_wrap_CvMat_hdr_refcount_get,_wrap_CvMat_hdr_refcount_set,0,0}, +{"data",0,_wrap_CvMat_data_get,octave_set_immutable,0,0}, +{"depth",0,_wrap_CvMat_depth_get,_wrap_CvMat_depth_set,0,0}, +{"nChannels",0,_wrap_CvMat_nChannels_get,_wrap_CvMat_nChannels_set,0,0}, +{"dataOrder",0,_wrap_CvMat_dataOrder_get,_wrap_CvMat_dataOrder_set,0,0}, +{"origin",0,_wrap_CvMat_origin_get,_wrap_CvMat_origin_set,0,0}, +{"width",0,_wrap_CvMat_width_get,_wrap_CvMat_width_set,0,0}, +{"height",0,_wrap_CvMat_height_get,_wrap_CvMat_height_set,0,0}, +{"imageSize",0,_wrap_CvMat_imageSize_get,_wrap_CvMat_imageSize_set,0,0}, +{"widthStep",0,_wrap_CvMat_widthStep_get,_wrap_CvMat_widthStep_set,0,0}, +{"rows",0,_wrap_CvMat_rows_get,_wrap_CvMat_rows_set,0,0}, +{"cols",0,_wrap_CvMat_cols_get,_wrap_CvMat_cols_set,0,0}, +{"__add__",_wrap_CvMat___add__,0,0,0,0}, +{"__xor__",_wrap_CvMat___xor__,0,0,0,0}, +{"__sub__",_wrap_CvMat___sub__,0,0,0,0}, +{"__ge__",_wrap_CvMat___ge__,0,0,0,0}, +{"__eq__",_wrap_CvMat___eq__,0,0,0,0}, +{"__le__",_wrap_CvMat___le__,0,0,0,0}, +{"__ne__",_wrap_CvMat___ne__,0,0,0,0}, +{"__lt__",_wrap_CvMat___lt__,0,0,0,0}, +{"__gt__",_wrap_CvMat___gt__,0,0,0,0}, +{"__mul__",_wrap_CvMat___mul__,0,0,0,0}, +{"__div__",_wrap_CvMat___div__,0,0,0,0}, +{"__radd__",_wrap_CvMat___radd__,0,0,0,0}, +{"__rsub__",_wrap_CvMat___rsub__,0,0,0,0}, +{"__rmul__",_wrap_CvMat___rmul__,0,0,0,0}, +{"__rdiv__",_wrap_CvMat___rdiv__,0,0,0,0}, +{"__ror__",_wrap_CvMat___ror__,0,0,0,0}, +{"__rand__",_wrap_CvMat___rand__,0,0,0,0}, +{"__rxor__",_wrap_CvMat___rxor__,0,0,0,0}, +{"__req__",_wrap_CvMat___req__,0,0,0,0}, +{"__rgt__",_wrap_CvMat___rgt__,0,0,0,0}, +{"__rge__",_wrap_CvMat___rge__,0,0,0,0}, +{"__rlt__",_wrap_CvMat___rlt__,0,0,0,0}, +{"__rle__",_wrap_CvMat___rle__,0,0,0,0}, +{"__rne__",_wrap_CvMat___rne__,0,0,0,0}, +{"__pow__",_wrap_CvMat___pow__,0,0,0,0}, +{"__str",_wrap_CvMat___str,0,0,0,0}, +{"__paren_asgn",_wrap_CvMat___paren_asgn,0,0,0,0}, +{"__paren",_wrap_CvMat___paren,0,0,0,0}, +{"imageData",0,_wrap_CvMat_imageData_get,_wrap_CvMat_imageData_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvMat_base_names[] = {0}; +static const swig_type_info *swig_CvMat_base[] = {0}; +static swig_octave_class _wrap_class_CvMat = {"CvMat", &SWIGTYPE_p_CvMat,0,0,0,_wrap_delete_CvMat,swig_CvMat_members,swig_CvMat_base_names,swig_CvMat_base }; + +static octave_value_list _wrap_CvMat_data_ptr_set (const octave_value_list& args, int nargout) { + CvMat_data *arg1 = (CvMat_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("CvMat_data_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_ptr_set" "', argument " "1"" of type '" "CvMat_data *""'"); + } + arg1 = (CvMat_data *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMat_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_CvMat_data_ptr_get (const octave_value_list& args, int nargout) { + CvMat_data *arg1 = (CvMat_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("CvMat_data_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_ptr_get" "', argument " "1"" of type '" "CvMat_data *""'"); + } + arg1 = (CvMat_data *)(argp1); + result = (uchar *) ((arg1)->ptr); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat_data_s_set (const octave_value_list& args, int nargout) { + CvMat_data *arg1 = (CvMat_data *) 0 ; + short *arg2 = (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("CvMat_data_s_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_s_set" "', argument " "1"" of type '" "CvMat_data *""'"); + } + arg1 = (CvMat_data *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_short, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMat_data_s_set" "', argument " "2"" of type '" "short *""'"); + } + arg2 = (short *)(argp2); + if (arg1) (arg1)->s = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat_data_s_get (const octave_value_list& args, int nargout) { + CvMat_data *arg1 = (CvMat_data *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + short *result = 0 ; + + if (!SWIG_check_num_args("CvMat_data_s_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_s_get" "', argument " "1"" of type '" "CvMat_data *""'"); + } + arg1 = (CvMat_data *)(argp1); + result = (short *) ((arg1)->s); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMat_data_i_set (const octave_value_list& args, int nargout) { + CvMat_data *arg1 = (CvMat_data *) 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("CvMat_data_i_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_i_set" "', argument " "1"" of type '" "CvMat_data *""'"); + } + arg1 = (CvMat_data *)(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 '" "CvMat_data_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_CvMat_data_i_get (const octave_value_list& args, int nargout) { + CvMat_data *arg1 = (CvMat_data *) 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("CvMat_data_i_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_i_get" "', argument " "1"" of type '" "CvMat_data *""'"); + } + arg1 = (CvMat_data *)(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_CvMat_data_fl_set (const octave_value_list& args, int nargout) { + CvMat_data *arg1 = (CvMat_data *) 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("CvMat_data_fl_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_fl_set" "', argument " "1"" of type '" "CvMat_data *""'"); + } + arg1 = (CvMat_data *)(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 '" "CvMat_data_fl_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + 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_CvMat_data_fl_get (const octave_value_list& args, int nargout) { + CvMat_data *arg1 = (CvMat_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("CvMat_data_fl_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_fl_get" "', argument " "1"" of type '" "CvMat_data *""'"); + } + arg1 = (CvMat_data *)(argp1); + result = (float *) ((arg1)->fl); + _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_CvMat_data_db_set (const octave_value_list& args, int nargout) { + CvMat_data *arg1 = (CvMat_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("CvMat_data_db_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_db_set" "', argument " "1"" of type '" "CvMat_data *""'"); + } + arg1 = (CvMat_data *)(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 '" "CvMat_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_CvMat_data_db_get (const octave_value_list& args, int nargout) { + CvMat_data *arg1 = (CvMat_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("CvMat_data_db_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMat_data_db_get" "', argument " "1"" of type '" "CvMat_data *""'"); + } + arg1 = (CvMat_data *)(argp1); + result = (double *) ((arg1)->db); + _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_new_CvMat_data (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat_data *result = 0 ; + + if (!SWIG_check_num_args("new_CvMat_data",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvMat_data *)new CvMat_data(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat_data, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvMat_data (const octave_value_list& args, int nargout) { + CvMat_data *arg1 = (CvMat_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_CvMat_data",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMat_data, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMat_data" "', argument " "1"" of type '" "CvMat_data *""'"); + } + arg1 = (CvMat_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_CvMat_data_members[] = { +{"ptr",0,_wrap_CvMat_data_ptr_get,_wrap_CvMat_data_ptr_set,0,0}, +{"s",0,_wrap_CvMat_data_s_get,_wrap_CvMat_data_s_set,0,0}, +{"i",0,_wrap_CvMat_data_i_get,_wrap_CvMat_data_i_set,0,0}, +{"fl",0,_wrap_CvMat_data_fl_get,_wrap_CvMat_data_fl_set,0,0}, +{"db",0,_wrap_CvMat_data_db_get,_wrap_CvMat_data_db_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvMat_data_base_names[] = {0}; +static const swig_type_info *swig_CvMat_data_base[] = {0}; +static swig_octave_class _wrap_class_CvMat_data = {"CvMat_data", &SWIGTYPE_p_CvMat_data,0,_wrap_new_CvMat_data,0,_wrap_delete_CvMat_data,swig_CvMat_data_members,swig_CvMat_data_base_names,swig_CvMat_data_base }; + +static octave_value_list _wrap_cvMat__SWIG_0 (const octave_value_list& args, int nargout) { + int arg1 ; + int arg2 ; + int arg3 ; + void *arg4 = (void *) 0 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int res4 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat result; + + if (!SWIG_check_num_args("cvMat",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 '" "cvMat" "', 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 '" "cvMat" "', 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 '" "cvMat" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + res4 = SWIG_ConvertPtr(args(3),SWIG_as_voidptrptr(&arg4), 0, 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvMat" "', argument " "4"" of type '" "void *""'"); + } + { + try { + result = cvMat(arg1,arg2,arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvMat((const CvMat&)(result))), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvMat__SWIG_1 (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; + CvMat result; + + if (!SWIG_check_num_args("cvMat",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 '" "cvMat" "', 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 '" "cvMat" "', 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 '" "cvMat" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + { + try { + result = cvMat(arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvMat((const CvMat&)(result))), SWIGTYPE_p_CvMat, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvMat (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; + { + 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_cvMat__SWIG_1(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 *ptr = 0; + int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_cvMat__SWIG_0(args, nargout); + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_cvmGet (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 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; + double result; + + if (!SWIG_check_num_args("cvmGet",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 '" "cvmGet" "', 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 '" "cvmGet" "', 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 '" "cvmGet" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + { + try { + result = (double)cvmGet((CvMat const *)arg1,arg2,arg3); + } + 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_cvmSet (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + int arg2 ; + int arg3 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 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("cvmSet",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 '" "cvmSet" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvmSet" "', 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 '" "cvmSet" "', 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 '" "cvmSet" "', argument " "4"" of type '" "double""'"); + } + arg4 = (double)(val4); + { + try { + cvmSet(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_cvIplDepth (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; + int result; + + if (!SWIG_check_num_args("cvIplDepth",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 '" "cvIplDepth" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + { + try { + result = (int)cvIplDepth(arg1); + } + 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_CvMatND_type_set (const octave_value_list& args, int nargout) { + CvMatND *arg1 = (CvMatND *) 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("CvMatND_type_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_type_set" "', argument " "1"" of type '" "CvMatND *""'"); + } + arg1 = (CvMatND *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatND_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_CvMatND_type_get (const octave_value_list& args, int nargout) { + CvMatND *arg1 = (CvMatND *) 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("CvMatND_type_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_type_get" "', argument " "1"" of type '" "CvMatND *""'"); + } + arg1 = (CvMatND *)(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_CvMatND_dims_set (const octave_value_list& args, int nargout) { + CvMatND *arg1 = (CvMatND *) 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("CvMatND_dims_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dims_set" "', argument " "1"" of type '" "CvMatND *""'"); + } + arg1 = (CvMatND *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatND_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_CvMatND_dims_get (const octave_value_list& args, int nargout) { + CvMatND *arg1 = (CvMatND *) 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("CvMatND_dims_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dims_get" "', argument " "1"" of type '" "CvMatND *""'"); + } + arg1 = (CvMatND *)(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_CvMatND_refcount_set (const octave_value_list& args, int nargout) { + CvMatND *arg1 = (CvMatND *) 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("CvMatND_refcount_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_refcount_set" "', argument " "1"" of type '" "CvMatND *""'"); + } + arg1 = (CvMatND *)(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 '" "CvMatND_refcount_set" "', argument " "2"" of type '" "int *""'"); + } + arg2 = (int *)(argp2); + if (arg1) (arg1)->refcount = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatND_refcount_get (const octave_value_list& args, int nargout) { + CvMatND *arg1 = (CvMatND *) 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("CvMatND_refcount_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_refcount_get" "', argument " "1"" of type '" "CvMatND *""'"); + } + arg1 = (CvMatND *)(argp1); + result = (int *) ((arg1)->refcount); + _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_CvMatND_hdr_refcount_set (const octave_value_list& args, int nargout) { + CvMatND *arg1 = (CvMatND *) 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("CvMatND_hdr_refcount_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_hdr_refcount_set" "', argument " "1"" of type '" "CvMatND *""'"); + } + arg1 = (CvMatND *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatND_hdr_refcount_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->hdr_refcount = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatND_hdr_refcount_get (const octave_value_list& args, int nargout) { + CvMatND *arg1 = (CvMatND *) 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("CvMatND_hdr_refcount_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_hdr_refcount_get" "', argument " "1"" of type '" "CvMatND *""'"); + } + arg1 = (CvMatND *)(argp1); + result = (int) ((arg1)->hdr_refcount); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatND_dim_get (const octave_value_list& args, int nargout) { + CvMatND *arg1 = (CvMatND *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatND_dim *result = 0 ; + + if (!SWIG_check_num_args("CvMatND_dim_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dim_get" "', argument " "1"" of type '" "CvMatND *""'"); + } + arg1 = (CvMatND *)(argp1); + result = (CvMatND_dim *)(CvMatND_dim *) ((arg1)->dim); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND_dim, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatND_data_get (const octave_value_list& args, int nargout) { + CvMatND *arg1 = (CvMatND *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatND_data *result = 0 ; + + if (!SWIG_check_num_args("CvMatND_data_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_get" "', argument " "1"" of type '" "CvMatND *""'"); + } + arg1 = (CvMatND *)(argp1); + result = (CvMatND_data *)& ((arg1)->data); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND_data, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvMatND (const octave_value_list& args, int nargout) { + CvMatND *arg1 = (CvMatND *) 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_CvMatND",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMatND" "', argument " "1"" of type '" "CvMatND *""'"); + } + arg1 = (CvMatND *)(argp1); + { + try { + delete_CvMatND(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_CvMatND_members[] = { +{"type",0,_wrap_CvMatND_type_get,_wrap_CvMatND_type_set,0,0}, +{"dims",0,_wrap_CvMatND_dims_get,_wrap_CvMatND_dims_set,0,0}, +{"refcount",0,_wrap_CvMatND_refcount_get,_wrap_CvMatND_refcount_set,0,0}, +{"hdr_refcount",0,_wrap_CvMatND_hdr_refcount_get,_wrap_CvMatND_hdr_refcount_set,0,0}, +{"dim",0,_wrap_CvMatND_dim_get,octave_set_immutable,0,0}, +{"data",0,_wrap_CvMatND_data_get,octave_set_immutable,0,0}, +{0,0,0,0} +}; +static const char *swig_CvMatND_base_names[] = {0}; +static const swig_type_info *swig_CvMatND_base[] = {0}; +static swig_octave_class _wrap_class_CvMatND = {"CvMatND", &SWIGTYPE_p_CvMatND,0,0,0,_wrap_delete_CvMatND,swig_CvMatND_members,swig_CvMatND_base_names,swig_CvMatND_base }; + +static octave_value_list _wrap_CvMatND_dim_size_set (const octave_value_list& args, int nargout) { + CvMatND_dim *arg1 = (CvMatND_dim *) 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("CvMatND_dim_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_dim, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dim_size_set" "', argument " "1"" of type '" "CvMatND_dim *""'"); + } + arg1 = (CvMatND_dim *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatND_dim_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatND_dim_size_get (const octave_value_list& args, int nargout) { + CvMatND_dim *arg1 = (CvMatND_dim *) 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("CvMatND_dim_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_dim, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dim_size_get" "', argument " "1"" of type '" "CvMatND_dim *""'"); + } + arg1 = (CvMatND_dim *)(argp1); + result = (int) ((arg1)->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_CvMatND_dim_step_set (const octave_value_list& args, int nargout) { + CvMatND_dim *arg1 = (CvMatND_dim *) 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("CvMatND_dim_step_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_dim, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dim_step_set" "', argument " "1"" of type '" "CvMatND_dim *""'"); + } + arg1 = (CvMatND_dim *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatND_dim_step_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(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_CvMatND_dim_step_get (const octave_value_list& args, int nargout) { + CvMatND_dim *arg1 = (CvMatND_dim *) 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("CvMatND_dim_step_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_dim, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_dim_step_get" "', argument " "1"" of type '" "CvMatND_dim *""'"); + } + arg1 = (CvMatND_dim *)(argp1); + result = (int) ((arg1)->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_new_CvMatND_dim (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatND_dim *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatND_dim",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvMatND_dim *)new CvMatND_dim(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND_dim, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvMatND_dim (const octave_value_list& args, int nargout) { + CvMatND_dim *arg1 = (CvMatND_dim *) 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_CvMatND_dim",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_dim, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMatND_dim" "', argument " "1"" of type '" "CvMatND_dim *""'"); + } + arg1 = (CvMatND_dim *)(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_CvMatND_dim_members[] = { +{"size",0,_wrap_CvMatND_dim_size_get,_wrap_CvMatND_dim_size_set,0,0}, +{"step",0,_wrap_CvMatND_dim_step_get,_wrap_CvMatND_dim_step_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvMatND_dim_base_names[] = {0}; +static const swig_type_info *swig_CvMatND_dim_base[] = {0}; +static swig_octave_class _wrap_class_CvMatND_dim = {"CvMatND_dim", &SWIGTYPE_p_CvMatND_dim,0,_wrap_new_CvMatND_dim,0,_wrap_delete_CvMatND_dim,swig_CvMatND_dim_members,swig_CvMatND_dim_base_names,swig_CvMatND_dim_base }; + +static octave_value_list _wrap_CvMatND_data_ptr_set (const octave_value_list& args, int nargout) { + CvMatND_data *arg1 = (CvMatND_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("CvMatND_data_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_ptr_set" "', argument " "1"" of type '" "CvMatND_data *""'"); + } + arg1 = (CvMatND_data *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatND_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_CvMatND_data_ptr_get (const octave_value_list& args, int nargout) { + CvMatND_data *arg1 = (CvMatND_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("CvMatND_data_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_ptr_get" "', argument " "1"" of type '" "CvMatND_data *""'"); + } + arg1 = (CvMatND_data *)(argp1); + result = (uchar *) ((arg1)->ptr); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatND_data_fl_set (const octave_value_list& args, int nargout) { + CvMatND_data *arg1 = (CvMatND_data *) 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("CvMatND_data_fl_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_fl_set" "', argument " "1"" of type '" "CvMatND_data *""'"); + } + arg1 = (CvMatND_data *)(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 '" "CvMatND_data_fl_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + 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_CvMatND_data_fl_get (const octave_value_list& args, int nargout) { + CvMatND_data *arg1 = (CvMatND_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("CvMatND_data_fl_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_fl_get" "', argument " "1"" of type '" "CvMatND_data *""'"); + } + arg1 = (CvMatND_data *)(argp1); + result = (float *) ((arg1)->fl); + _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_CvMatND_data_db_set (const octave_value_list& args, int nargout) { + CvMatND_data *arg1 = (CvMatND_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("CvMatND_data_db_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_db_set" "', argument " "1"" of type '" "CvMatND_data *""'"); + } + arg1 = (CvMatND_data *)(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 '" "CvMatND_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_CvMatND_data_db_get (const octave_value_list& args, int nargout) { + CvMatND_data *arg1 = (CvMatND_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("CvMatND_data_db_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_db_get" "', argument " "1"" of type '" "CvMatND_data *""'"); + } + arg1 = (CvMatND_data *)(argp1); + result = (double *) ((arg1)->db); + _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_CvMatND_data_i_set (const octave_value_list& args, int nargout) { + CvMatND_data *arg1 = (CvMatND_data *) 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("CvMatND_data_i_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_i_set" "', argument " "1"" of type '" "CvMatND_data *""'"); + } + arg1 = (CvMatND_data *)(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 '" "CvMatND_data_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_CvMatND_data_i_get (const octave_value_list& args, int nargout) { + CvMatND_data *arg1 = (CvMatND_data *) 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("CvMatND_data_i_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_i_get" "', argument " "1"" of type '" "CvMatND_data *""'"); + } + arg1 = (CvMatND_data *)(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_CvMatND_data_s_set (const octave_value_list& args, int nargout) { + CvMatND_data *arg1 = (CvMatND_data *) 0 ; + short *arg2 = (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("CvMatND_data_s_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_s_set" "', argument " "1"" of type '" "CvMatND_data *""'"); + } + arg1 = (CvMatND_data *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_short, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatND_data_s_set" "', argument " "2"" of type '" "short *""'"); + } + arg2 = (short *)(argp2); + if (arg1) (arg1)->s = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatND_data_s_get (const octave_value_list& args, int nargout) { + CvMatND_data *arg1 = (CvMatND_data *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + short *result = 0 ; + + if (!SWIG_check_num_args("CvMatND_data_s_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatND_data_s_get" "', argument " "1"" of type '" "CvMatND_data *""'"); + } + arg1 = (CvMatND_data *)(argp1); + result = (short *) ((arg1)->s); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatND_data (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatND_data *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatND_data",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvMatND_data *)new CvMatND_data(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND_data, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvMatND_data (const octave_value_list& args, int nargout) { + CvMatND_data *arg1 = (CvMatND_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_CvMatND_data",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatND_data, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMatND_data" "', argument " "1"" of type '" "CvMatND_data *""'"); + } + arg1 = (CvMatND_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_CvMatND_data_members[] = { +{"ptr",0,_wrap_CvMatND_data_ptr_get,_wrap_CvMatND_data_ptr_set,0,0}, +{"fl",0,_wrap_CvMatND_data_fl_get,_wrap_CvMatND_data_fl_set,0,0}, +{"db",0,_wrap_CvMatND_data_db_get,_wrap_CvMatND_data_db_set,0,0}, +{"i",0,_wrap_CvMatND_data_i_get,_wrap_CvMatND_data_i_set,0,0}, +{"s",0,_wrap_CvMatND_data_s_get,_wrap_CvMatND_data_s_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvMatND_data_base_names[] = {0}; +static const swig_type_info *swig_CvMatND_data_base[] = {0}; +static swig_octave_class _wrap_class_CvMatND_data = {"CvMatND_data", &SWIGTYPE_p_CvMatND_data,0,_wrap_new_CvMatND_data,0,_wrap_delete_CvMatND_data,swig_CvMatND_data_members,swig_CvMatND_data_base_names,swig_CvMatND_data_base }; + +static octave_value_list _wrap_CvSparseMat_type_set (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_type_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_type_set" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMat_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_CvSparseMat_type_get (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_type_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_type_get" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(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_CvSparseMat_dims_set (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_dims_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_dims_set" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMat_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_CvSparseMat_dims_get (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_dims_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_dims_get" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(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_CvSparseMat_refcount_set (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_refcount_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_refcount_set" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(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 '" "CvSparseMat_refcount_set" "', argument " "2"" of type '" "int *""'"); + } + arg2 = (int *)(argp2); + if (arg1) (arg1)->refcount = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMat_refcount_get (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_refcount_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_refcount_get" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + result = (int *) ((arg1)->refcount); + _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_CvSparseMat_hdr_refcount_set (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_hdr_refcount_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_hdr_refcount_set" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMat_hdr_refcount_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->hdr_refcount = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMat_hdr_refcount_get (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_hdr_refcount_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_hdr_refcount_get" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + result = (int) ((arg1)->hdr_refcount); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMat_heap_set (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_heap_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_heap_set" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(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)->heap = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMat_heap_get (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_heap_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_heap_get" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + result = (CvSet *) ((arg1)->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_CvSparseMat_hashtable_set (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 0 ; + void **arg2 = (void **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *vptr2 ; + void *buffer2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSparseMat_hashtable_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_hashtable_set" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + { + if ((SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_void, 1)) == -1){ + SWIG_fail; + } + buffer2 = (void *) vptr2; + arg2=&buffer2; + } + if (arg1) (arg1)->hashtable = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMat_hashtable_get (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + void **result = 0 ; + + if (!SWIG_check_num_args("CvSparseMat_hashtable_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_hashtable_get" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + result = (void **) ((arg1)->hashtable); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMat_hashsize_set (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_hashsize_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_hashsize_set" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMat_hashsize_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->hashsize = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMat_hashsize_get (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_hashsize_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_hashsize_get" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + result = (int) ((arg1)->hashsize); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMat_valoffset_set (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_valoffset_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_valoffset_set" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMat_valoffset_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->valoffset = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMat_valoffset_get (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_valoffset_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_valoffset_get" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + result = (int) ((arg1)->valoffset); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMat_idxoffset_set (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_idxoffset_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_idxoffset_set" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMat_idxoffset_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->idxoffset = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMat_idxoffset_get (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_idxoffset_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_idxoffset_get" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + result = (int) ((arg1)->idxoffset); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMat_size_set (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 0 ; + int *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("CvSparseMat_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_size_set" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSparseMat_size_set" "', argument " "2"" of type '" "int [32]""'"); + } + arg2 = (int *)(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)32; ++ii) arg1->size[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""size""' of type '""int [32]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMat_size_get (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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("CvSparseMat_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMat_size_get" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + result = (int *)(int *) ((arg1)->size); + _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_delete_CvSparseMat (const octave_value_list& args, int nargout) { + CvSparseMat *arg1 = (CvSparseMat *) 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_CvSparseMat",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMat, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSparseMat" "', argument " "1"" of type '" "CvSparseMat *""'"); + } + arg1 = (CvSparseMat *)(argp1); + { + try { + delete_CvSparseMat(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_CvSparseMat_members[] = { +{"type",0,_wrap_CvSparseMat_type_get,_wrap_CvSparseMat_type_set,0,0}, +{"dims",0,_wrap_CvSparseMat_dims_get,_wrap_CvSparseMat_dims_set,0,0}, +{"refcount",0,_wrap_CvSparseMat_refcount_get,_wrap_CvSparseMat_refcount_set,0,0}, +{"hdr_refcount",0,_wrap_CvSparseMat_hdr_refcount_get,_wrap_CvSparseMat_hdr_refcount_set,0,0}, +{"heap",0,_wrap_CvSparseMat_heap_get,_wrap_CvSparseMat_heap_set,0,0}, +{"hashtable",0,_wrap_CvSparseMat_hashtable_get,_wrap_CvSparseMat_hashtable_set,0,0}, +{"hashsize",0,_wrap_CvSparseMat_hashsize_get,_wrap_CvSparseMat_hashsize_set,0,0}, +{"valoffset",0,_wrap_CvSparseMat_valoffset_get,_wrap_CvSparseMat_valoffset_set,0,0}, +{"idxoffset",0,_wrap_CvSparseMat_idxoffset_get,_wrap_CvSparseMat_idxoffset_set,0,0}, +{"size",0,_wrap_CvSparseMat_size_get,_wrap_CvSparseMat_size_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSparseMat_base_names[] = {0}; +static const swig_type_info *swig_CvSparseMat_base[] = {0}; +static swig_octave_class _wrap_class_CvSparseMat = {"CvSparseMat", &SWIGTYPE_p_CvSparseMat,0,0,0,_wrap_delete_CvSparseMat,swig_CvSparseMat_members,swig_CvSparseMat_base_names,swig_CvSparseMat_base }; + +static octave_value_list _wrap_CvSparseNode_hashval_set (const octave_value_list& args, int nargout) { + CvSparseNode *arg1 = (CvSparseNode *) 0 ; + unsigned int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSparseNode_hashval_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseNode_hashval_set" "', argument " "1"" of type '" "CvSparseNode *""'"); + } + arg1 = (CvSparseNode *)(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseNode_hashval_set" "', argument " "2"" of type '" "unsigned int""'"); + } + arg2 = (unsigned int)(val2); + if (arg1) (arg1)->hashval = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseNode_hashval_get (const octave_value_list& args, int nargout) { + CvSparseNode *arg1 = (CvSparseNode *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + unsigned int result; + + if (!SWIG_check_num_args("CvSparseNode_hashval_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseNode_hashval_get" "', argument " "1"" of type '" "CvSparseNode *""'"); + } + arg1 = (CvSparseNode *)(argp1); + result = (unsigned int) ((arg1)->hashval); + _outv = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseNode_next_set (const octave_value_list& args, int nargout) { + CvSparseNode *arg1 = (CvSparseNode *) 0 ; + CvSparseNode *arg2 = (CvSparseNode *) 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("CvSparseNode_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseNode_next_set" "', argument " "1"" of type '" "CvSparseNode *""'"); + } + arg1 = (CvSparseNode *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSparseNode, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSparseNode_next_set" "', argument " "2"" of type '" "CvSparseNode *""'"); + } + arg2 = (CvSparseNode *)(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_CvSparseNode_next_get (const octave_value_list& args, int nargout) { + CvSparseNode *arg1 = (CvSparseNode *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSparseNode *result = 0 ; + + if (!SWIG_check_num_args("CvSparseNode_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseNode_next_get" "', argument " "1"" of type '" "CvSparseNode *""'"); + } + arg1 = (CvSparseNode *)(argp1); + result = (CvSparseNode *) ((arg1)->next); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseNode, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSparseNode (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSparseNode *result = 0 ; + + if (!SWIG_check_num_args("new_CvSparseNode",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSparseNode *)new CvSparseNode(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseNode, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSparseNode (const octave_value_list& args, int nargout) { + CvSparseNode *arg1 = (CvSparseNode *) 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_CvSparseNode",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseNode, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSparseNode" "', argument " "1"" of type '" "CvSparseNode *""'"); + } + arg1 = (CvSparseNode *)(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_CvSparseNode_members[] = { +{"hashval",0,_wrap_CvSparseNode_hashval_get,_wrap_CvSparseNode_hashval_set,0,0}, +{"next",0,_wrap_CvSparseNode_next_get,_wrap_CvSparseNode_next_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSparseNode_base_names[] = {0}; +static const swig_type_info *swig_CvSparseNode_base[] = {0}; +static swig_octave_class _wrap_class_CvSparseNode = {"CvSparseNode", &SWIGTYPE_p_CvSparseNode,0,_wrap_new_CvSparseNode,0,_wrap_delete_CvSparseNode,swig_CvSparseNode_members,swig_CvSparseNode_base_names,swig_CvSparseNode_base }; + +static octave_value_list _wrap_CvSparseMatIterator_mat_set (const octave_value_list& args, int nargout) { + CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 0 ; + CvSparseMat *arg2 = (CvSparseMat *) 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("CvSparseMatIterator_mat_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMatIterator_mat_set" "', argument " "1"" of type '" "CvSparseMatIterator *""'"); + } + arg1 = (CvSparseMatIterator *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSparseMat, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSparseMatIterator_mat_set" "', argument " "2"" of type '" "CvSparseMat *""'"); + } + arg2 = (CvSparseMat *)(argp2); + if (arg1) (arg1)->mat = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMatIterator_mat_get (const octave_value_list& args, int nargout) { + CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSparseMat *result = 0 ; + + if (!SWIG_check_num_args("CvSparseMatIterator_mat_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMatIterator_mat_get" "', argument " "1"" of type '" "CvSparseMatIterator *""'"); + } + arg1 = (CvSparseMatIterator *)(argp1); + result = (CvSparseMat *) ((arg1)->mat); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseMat, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMatIterator_node_set (const octave_value_list& args, int nargout) { + CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 0 ; + CvSparseNode *arg2 = (CvSparseNode *) 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("CvSparseMatIterator_node_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMatIterator_node_set" "', argument " "1"" of type '" "CvSparseMatIterator *""'"); + } + arg1 = (CvSparseMatIterator *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSparseNode, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSparseMatIterator_node_set" "', argument " "2"" of type '" "CvSparseNode *""'"); + } + arg2 = (CvSparseNode *)(argp2); + if (arg1) (arg1)->node = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMatIterator_node_get (const octave_value_list& args, int nargout) { + CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSparseNode *result = 0 ; + + if (!SWIG_check_num_args("CvSparseMatIterator_node_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMatIterator_node_get" "', argument " "1"" of type '" "CvSparseMatIterator *""'"); + } + arg1 = (CvSparseMatIterator *)(argp1); + result = (CvSparseNode *) ((arg1)->node); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseNode, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMatIterator_curidx_set (const octave_value_list& args, int nargout) { + CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 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("CvSparseMatIterator_curidx_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMatIterator_curidx_set" "', argument " "1"" of type '" "CvSparseMatIterator *""'"); + } + arg1 = (CvSparseMatIterator *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSparseMatIterator_curidx_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->curidx = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSparseMatIterator_curidx_get (const octave_value_list& args, int nargout) { + CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 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("CvSparseMatIterator_curidx_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMatIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSparseMatIterator_curidx_get" "', argument " "1"" of type '" "CvSparseMatIterator *""'"); + } + arg1 = (CvSparseMatIterator *)(argp1); + result = (int) ((arg1)->curidx); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSparseMatIterator (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSparseMatIterator *result = 0 ; + + if (!SWIG_check_num_args("new_CvSparseMatIterator",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSparseMatIterator *)new CvSparseMatIterator(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSparseMatIterator, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSparseMatIterator (const octave_value_list& args, int nargout) { + CvSparseMatIterator *arg1 = (CvSparseMatIterator *) 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_CvSparseMatIterator",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSparseMatIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSparseMatIterator" "', argument " "1"" of type '" "CvSparseMatIterator *""'"); + } + arg1 = (CvSparseMatIterator *)(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_CvSparseMatIterator_members[] = { +{"mat",0,_wrap_CvSparseMatIterator_mat_get,_wrap_CvSparseMatIterator_mat_set,0,0}, +{"node",0,_wrap_CvSparseMatIterator_node_get,_wrap_CvSparseMatIterator_node_set,0,0}, +{"curidx",0,_wrap_CvSparseMatIterator_curidx_get,_wrap_CvSparseMatIterator_curidx_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSparseMatIterator_base_names[] = {0}; +static const swig_type_info *swig_CvSparseMatIterator_base[] = {0}; +static swig_octave_class _wrap_class_CvSparseMatIterator = {"CvSparseMatIterator", &SWIGTYPE_p_CvSparseMatIterator,0,_wrap_new_CvSparseMatIterator,0,_wrap_delete_CvSparseMatIterator,swig_CvSparseMatIterator_members,swig_CvSparseMatIterator_base_names,swig_CvSparseMatIterator_base }; + +static octave_value_list _wrap_CvHistogram_type_set (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 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("CvHistogram_type_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_type_set" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHistogram_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_CvHistogram_type_get (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 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("CvHistogram_type_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_type_get" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(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_CvHistogram_bins_set (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvHistogram_bins_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_bins_set" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + if (arg1) (arg1)->bins = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_CvHistogram_bins_get (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("CvHistogram_bins_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_bins_get" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + result = (CvArr *) ((arg1)->bins); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHistogram_thresh_set (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 0 ; + float (*arg2)[2] ; + 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("CvHistogram_thresh_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_thresh_set" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_a_2__float, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHistogram_thresh_set" "', argument " "2"" of type '" "float [32][2]""'"); + } + arg2 = (float (*)[2])(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)32; ++ii) { + if (arg2[ii]) { + size_t jj = 0; + for (; jj < (size_t)2; ++jj) arg1->thresh[ii][jj] = arg2[ii][jj]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""thresh""' of type '""float [32][2]""'"); + } + } + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""thresh""' of type '""float [32][2]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHistogram_thresh_get (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + float (*result)[2] = 0 ; + + if (!SWIG_check_num_args("CvHistogram_thresh_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_thresh_get" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + result = (float (*)[2])(float (*)[2]) ((arg1)->thresh); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_2__float, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHistogram_thresh2_set (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 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("CvHistogram_thresh2_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_thresh2_set" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + { + if ((SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_float, 1)) == -1){ + SWIG_fail; + } + buffer2 = (float *) vptr2; + arg2=&buffer2; + } + if (arg1) (arg1)->thresh2 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHistogram_thresh2_get (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 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("CvHistogram_thresh2_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_thresh2_get" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + result = (float **) ((arg1)->thresh2); + _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_CvHistogram_mat_set (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 0 ; + CvMatND *arg2 = (CvMatND *) 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("CvHistogram_mat_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_mat_set" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMatND, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHistogram_mat_set" "', argument " "2"" of type '" "CvMatND *""'"); + } + arg2 = (CvMatND *)(argp2); + if (arg1) (arg1)->mat = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHistogram_mat_get (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatND *result = 0 ; + + if (!SWIG_check_num_args("CvHistogram_mat_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHistogram_mat_get" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + result = (CvMatND *)& ((arg1)->mat); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatND, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvHistogram (const octave_value_list& args, int nargout) { + CvHistogram *arg1 = (CvHistogram *) 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_CvHistogram",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHistogram, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHistogram" "', argument " "1"" of type '" "CvHistogram *""'"); + } + arg1 = (CvHistogram *)(argp1); + { + try { + delete_CvHistogram(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_CvHistogram_members[] = { +{"type",0,_wrap_CvHistogram_type_get,_wrap_CvHistogram_type_set,0,0}, +{"bins",0,_wrap_CvHistogram_bins_get,_wrap_CvHistogram_bins_set,0,0}, +{"thresh",0,_wrap_CvHistogram_thresh_get,_wrap_CvHistogram_thresh_set,0,0}, +{"thresh2",0,_wrap_CvHistogram_thresh2_get,_wrap_CvHistogram_thresh2_set,0,0}, +{"mat",0,_wrap_CvHistogram_mat_get,_wrap_CvHistogram_mat_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvHistogram_base_names[] = {0}; +static const swig_type_info *swig_CvHistogram_base[] = {0}; +static swig_octave_class _wrap_class_CvHistogram = {"CvHistogram", &SWIGTYPE_p_CvHistogram,0,0,0,_wrap_delete_CvHistogram,swig_CvHistogram_members,swig_CvHistogram_base_names,swig_CvHistogram_base }; + +static octave_value_list _wrap_CvRect_x_set (const octave_value_list& args, int nargout) { + CvRect *arg1 = (CvRect *) 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("CvRect_x_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_x_set" "', argument " "1"" of type '" "CvRect *""'"); + } + arg1 = (CvRect *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvRect_x_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->x = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvRect_x_get (const octave_value_list& args, int nargout) { + CvRect *arg1 = (CvRect *) 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("CvRect_x_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_x_get" "', argument " "1"" of type '" "CvRect *""'"); + } + arg1 = (CvRect *)(argp1); + result = (int) ((arg1)->x); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvRect_y_set (const octave_value_list& args, int nargout) { + CvRect *arg1 = (CvRect *) 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("CvRect_y_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_y_set" "', argument " "1"" of type '" "CvRect *""'"); + } + arg1 = (CvRect *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvRect_y_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + 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_CvRect_y_get (const octave_value_list& args, int nargout) { + CvRect *arg1 = (CvRect *) 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("CvRect_y_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_y_get" "', argument " "1"" of type '" "CvRect *""'"); + } + arg1 = (CvRect *)(argp1); + result = (int) ((arg1)->y); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvRect_width_set (const octave_value_list& args, int nargout) { + CvRect *arg1 = (CvRect *) 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("CvRect_width_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_width_set" "', argument " "1"" of type '" "CvRect *""'"); + } + arg1 = (CvRect *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvRect_width_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->width = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvRect_width_get (const octave_value_list& args, int nargout) { + CvRect *arg1 = (CvRect *) 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("CvRect_width_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_width_get" "', argument " "1"" of type '" "CvRect *""'"); + } + arg1 = (CvRect *)(argp1); + result = (int) ((arg1)->width); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvRect_height_set (const octave_value_list& args, int nargout) { + CvRect *arg1 = (CvRect *) 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("CvRect_height_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_height_set" "', argument " "1"" of type '" "CvRect *""'"); + } + arg1 = (CvRect *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvRect_height_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->height = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvRect_height_get (const octave_value_list& args, int nargout) { + CvRect *arg1 = (CvRect *) 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("CvRect_height_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvRect_height_get" "', argument " "1"" of type '" "CvRect *""'"); + } + arg1 = (CvRect *)(argp1); + result = (int) ((arg1)->height); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvRect (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvRect *result = 0 ; + + if (!SWIG_check_num_args("new_CvRect",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvRect *)new CvRect(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvRect (const octave_value_list& args, int nargout) { + CvRect *arg1 = (CvRect *) 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_CvRect",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvRect, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvRect" "', argument " "1"" of type '" "CvRect *""'"); + } + arg1 = (CvRect *)(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_CvRect_members[] = { +{"x",0,_wrap_CvRect_x_get,_wrap_CvRect_x_set,0,0}, +{"y",0,_wrap_CvRect_y_get,_wrap_CvRect_y_set,0,0}, +{"width",0,_wrap_CvRect_width_get,_wrap_CvRect_width_set,0,0}, +{"height",0,_wrap_CvRect_height_get,_wrap_CvRect_height_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvRect_base_names[] = {0}; +static const swig_type_info *swig_CvRect_base[] = {0}; +static swig_octave_class _wrap_class_CvRect = {"CvRect", &SWIGTYPE_p_CvRect,0,_wrap_new_CvRect,0,_wrap_delete_CvRect,swig_CvRect_members,swig_CvRect_base_names,swig_CvRect_base }; + +static octave_value_list _wrap_cvRect (const octave_value_list& args, int nargout) { + int arg1 ; + int arg2 ; + int arg3 ; + int arg4 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvRect result; + + if (!SWIG_check_num_args("cvRect",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 '" "cvRect" "', 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 '" "cvRect" "', 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 '" "cvRect" "', 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 '" "cvRect" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + { + try { + result = cvRect(arg1,arg2,arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvRect((const CvRect&)(result))), SWIGTYPE_p_CvRect, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvRectToROI (const octave_value_list& args, int nargout) { + CvRect arg1 ; + int arg2 ; + void *argp1 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplROI result; + + if (!SWIG_check_num_args("cvRectToROI",args.length(),2,2,0)) { + SWIG_fail; + } + { + res1 = SWIG_ConvertPtr(args(0), &argp1, SWIGTYPE_p_CvRect, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRectToROI" "', argument " "1"" of type '" "CvRect""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvRectToROI" "', argument " "1"" of type '" "CvRect""'"); + } else { + arg1 = *((CvRect *)(argp1)); + } + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvRectToROI" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = cvRectToROI(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new IplROI((const IplROI&)(result))), SWIGTYPE_p__IplROI, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvROIToRect (const octave_value_list& args, int nargout) { + IplROI arg1 ; + void *argp1 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvRect result; + + if (!SWIG_check_num_args("cvROIToRect",args.length(),1,1,0)) { + SWIG_fail; + } + { + res1 = SWIG_ConvertPtr(args(0), &argp1, SWIGTYPE_p__IplROI, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvROIToRect" "', argument " "1"" of type '" "IplROI""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvROIToRect" "', argument " "1"" of type '" "IplROI""'"); + } else { + arg1 = *((IplROI *)(argp1)); + } + } + { + try { + result = cvROIToRect(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvRect((const CvRect&)(result))), SWIGTYPE_p_CvRect, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTermCriteria_type_set (const octave_value_list& args, int nargout) { + CvTermCriteria *arg1 = (CvTermCriteria *) 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("CvTermCriteria_type_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTermCriteria, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTermCriteria_type_set" "', argument " "1"" of type '" "CvTermCriteria *""'"); + } + arg1 = (CvTermCriteria *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTermCriteria_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_CvTermCriteria_type_get (const octave_value_list& args, int nargout) { + CvTermCriteria *arg1 = (CvTermCriteria *) 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("CvTermCriteria_type_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTermCriteria, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTermCriteria_type_get" "', argument " "1"" of type '" "CvTermCriteria *""'"); + } + arg1 = (CvTermCriteria *)(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_CvTermCriteria_max_iter_set (const octave_value_list& args, int nargout) { + CvTermCriteria *arg1 = (CvTermCriteria *) 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("CvTermCriteria_max_iter_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTermCriteria, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTermCriteria_max_iter_set" "', argument " "1"" of type '" "CvTermCriteria *""'"); + } + arg1 = (CvTermCriteria *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTermCriteria_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_CvTermCriteria_max_iter_get (const octave_value_list& args, int nargout) { + CvTermCriteria *arg1 = (CvTermCriteria *) 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("CvTermCriteria_max_iter_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTermCriteria, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTermCriteria_max_iter_get" "', argument " "1"" of type '" "CvTermCriteria *""'"); + } + arg1 = (CvTermCriteria *)(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_CvTermCriteria_epsilon_set (const octave_value_list& args, int nargout) { + CvTermCriteria *arg1 = (CvTermCriteria *) 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("CvTermCriteria_epsilon_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTermCriteria, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTermCriteria_epsilon_set" "', argument " "1"" of type '" "CvTermCriteria *""'"); + } + arg1 = (CvTermCriteria *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTermCriteria_epsilon_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->epsilon = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTermCriteria_epsilon_get (const octave_value_list& args, int nargout) { + CvTermCriteria *arg1 = (CvTermCriteria *) 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("CvTermCriteria_epsilon_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTermCriteria, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTermCriteria_epsilon_get" "', argument " "1"" of type '" "CvTermCriteria *""'"); + } + arg1 = (CvTermCriteria *)(argp1); + result = (double) ((arg1)->epsilon); + _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_CvTermCriteria (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTermCriteria *result = 0 ; + + if (!SWIG_check_num_args("new_CvTermCriteria",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTermCriteria *)new CvTermCriteria(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTermCriteria, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvTermCriteria (const octave_value_list& args, int nargout) { + CvTermCriteria *arg1 = (CvTermCriteria *) 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_CvTermCriteria",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTermCriteria, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTermCriteria" "', argument " "1"" of type '" "CvTermCriteria *""'"); + } + arg1 = (CvTermCriteria *)(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_CvTermCriteria_members[] = { +{"type",0,_wrap_CvTermCriteria_type_get,_wrap_CvTermCriteria_type_set,0,0}, +{"max_iter",0,_wrap_CvTermCriteria_max_iter_get,_wrap_CvTermCriteria_max_iter_set,0,0}, +{"epsilon",0,_wrap_CvTermCriteria_epsilon_get,_wrap_CvTermCriteria_epsilon_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvTermCriteria_base_names[] = {0}; +static const swig_type_info *swig_CvTermCriteria_base[] = {0}; +static swig_octave_class _wrap_class_CvTermCriteria = {"CvTermCriteria", &SWIGTYPE_p_CvTermCriteria,0,_wrap_new_CvTermCriteria,0,_wrap_delete_CvTermCriteria,swig_CvTermCriteria_members,swig_CvTermCriteria_base_names,swig_CvTermCriteria_base }; + +static octave_value_list _wrap_cvTermCriteria (const octave_value_list& args, int nargout) { + int arg1 ; + int arg2 ; + double arg3 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTermCriteria result; + + if (!SWIG_check_num_args("cvTermCriteria",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 '" "cvTermCriteria" "', 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 '" "cvTermCriteria" "', 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 '" "cvTermCriteria" "', argument " "3"" of type '" "double""'"); + } + arg3 = (double)(val3); + { + try { + result = cvTermCriteria(arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvTermCriteria((const CvTermCriteria&)(result))), SWIGTYPE_p_CvTermCriteria, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint_x_set (const octave_value_list& args, int nargout) { + CvPoint *arg1 = (CvPoint *) 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("CvPoint_x_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint_x_set" "', argument " "1"" of type '" "CvPoint *""'"); + } + arg1 = (CvPoint *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint_x_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->x = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint_x_get (const octave_value_list& args, int nargout) { + CvPoint *arg1 = (CvPoint *) 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("CvPoint_x_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint_x_get" "', argument " "1"" of type '" "CvPoint *""'"); + } + arg1 = (CvPoint *)(argp1); + result = (int) ((arg1)->x); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint_y_set (const octave_value_list& args, int nargout) { + CvPoint *arg1 = (CvPoint *) 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("CvPoint_y_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint_y_set" "', argument " "1"" of type '" "CvPoint *""'"); + } + arg1 = (CvPoint *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint_y_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + 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_CvPoint_y_get (const octave_value_list& args, int nargout) { + CvPoint *arg1 = (CvPoint *) 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("CvPoint_y_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint_y_get" "', argument " "1"" of type '" "CvPoint *""'"); + } + arg1 = (CvPoint *)(argp1); + result = (int) ((arg1)->y); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint___str__ (const octave_value_list& args, int nargout) { + CvPoint *arg1 = (CvPoint *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + char *result = 0 ; + + if (!SWIG_check_num_args("CvPoint___str__",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint___str__" "', argument " "1"" of type '" "CvPoint *""'"); + } + arg1 = (CvPoint *)(argp1); + { + try { + result = (char *)CvPoint___str__(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_FromCharPtr((const char *)result); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint___repr__ (const octave_value_list& args, int nargout) { + CvPoint *arg1 = (CvPoint *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + char *result = 0 ; + + if (!SWIG_check_num_args("CvPoint___repr__",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint___repr__" "', argument " "1"" of type '" "CvPoint *""'"); + } + arg1 = (CvPoint *)(argp1); + { + try { + result = (char *)CvPoint___repr__(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_FromCharPtr((const char *)result); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvPoint (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("new_CvPoint",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvPoint *)new CvPoint(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvPoint (const octave_value_list& args, int nargout) { + CvPoint *arg1 = (CvPoint *) 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_CvPoint",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPoint" "', argument " "1"" of type '" "CvPoint *""'"); + } + arg1 = (CvPoint *)(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_CvPoint_members[] = { +{"x",0,_wrap_CvPoint_x_get,_wrap_CvPoint_x_set,0,0}, +{"y",0,_wrap_CvPoint_y_get,_wrap_CvPoint_y_set,0,0}, +{"__str__",_wrap_CvPoint___str__,0,0,0,0}, +{"__repr__",_wrap_CvPoint___repr__,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvPoint_base_names[] = {0}; +static const swig_type_info *swig_CvPoint_base[] = {0}; +static swig_octave_class _wrap_class_CvPoint = {"CvPoint", &SWIGTYPE_p_CvPoint,0,_wrap_new_CvPoint,0,_wrap_delete_CvPoint,swig_CvPoint_members,swig_CvPoint_base_names,swig_CvPoint_base }; + +static octave_value_list _wrap_cvPoint (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; + CvPoint result; + + if (!SWIG_check_num_args("cvPoint",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 '" "cvPoint" "', 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 '" "cvPoint" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = cvPoint(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvPoint((const CvPoint&)(result))), SWIGTYPE_p_CvPoint, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint2D32f_x_set (const octave_value_list& args, int nargout) { + CvPoint2D32f *arg1 = (CvPoint2D32f *) 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("CvPoint2D32f_x_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D32f_x_set" "', argument " "1"" of type '" "CvPoint2D32f *""'"); + } + arg1 = (CvPoint2D32f *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint2D32f_x_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->x = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint2D32f_x_get (const octave_value_list& args, int nargout) { + CvPoint2D32f *arg1 = (CvPoint2D32f *) 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("CvPoint2D32f_x_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D32f_x_get" "', argument " "1"" of type '" "CvPoint2D32f *""'"); + } + arg1 = (CvPoint2D32f *)(argp1); + result = (float) ((arg1)->x); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint2D32f_y_set (const octave_value_list& args, int nargout) { + CvPoint2D32f *arg1 = (CvPoint2D32f *) 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("CvPoint2D32f_y_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D32f_y_set" "', argument " "1"" of type '" "CvPoint2D32f *""'"); + } + arg1 = (CvPoint2D32f *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint2D32f_y_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + 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_CvPoint2D32f_y_get (const octave_value_list& args, int nargout) { + CvPoint2D32f *arg1 = (CvPoint2D32f *) 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("CvPoint2D32f_y_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D32f_y_get" "', argument " "1"" of type '" "CvPoint2D32f *""'"); + } + arg1 = (CvPoint2D32f *)(argp1); + result = (float) ((arg1)->y); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint2D32f___str__ (const octave_value_list& args, int nargout) { + CvPoint2D32f *arg1 = (CvPoint2D32f *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + char *result = 0 ; + + if (!SWIG_check_num_args("CvPoint2D32f___str__",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D32f___str__" "', argument " "1"" of type '" "CvPoint2D32f *""'"); + } + arg1 = (CvPoint2D32f *)(argp1); + { + try { + result = (char *)CvPoint2D32f___str__(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_FromCharPtr((const char *)result); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint2D32f___repr__ (const octave_value_list& args, int nargout) { + CvPoint2D32f *arg1 = (CvPoint2D32f *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + char *result = 0 ; + + if (!SWIG_check_num_args("CvPoint2D32f___repr__",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D32f___repr__" "', argument " "1"" of type '" "CvPoint2D32f *""'"); + } + arg1 = (CvPoint2D32f *)(argp1); + { + try { + result = (char *)CvPoint2D32f___repr__(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_FromCharPtr((const char *)result); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvPoint2D32f (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint2D32f *result = 0 ; + + if (!SWIG_check_num_args("new_CvPoint2D32f",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvPoint2D32f *)new CvPoint2D32f(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvPoint2D32f (const octave_value_list& args, int nargout) { + CvPoint2D32f *arg1 = (CvPoint2D32f *) 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_CvPoint2D32f",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint2D32f, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPoint2D32f" "', argument " "1"" of type '" "CvPoint2D32f *""'"); + } + arg1 = (CvPoint2D32f *)(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_CvPoint2D32f_members[] = { +{"x",0,_wrap_CvPoint2D32f_x_get,_wrap_CvPoint2D32f_x_set,0,0}, +{"y",0,_wrap_CvPoint2D32f_y_get,_wrap_CvPoint2D32f_y_set,0,0}, +{"__str__",_wrap_CvPoint2D32f___str__,0,0,0,0}, +{"__repr__",_wrap_CvPoint2D32f___repr__,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvPoint2D32f_base_names[] = {0}; +static const swig_type_info *swig_CvPoint2D32f_base[] = {0}; +static swig_octave_class _wrap_class_CvPoint2D32f = {"CvPoint2D32f", &SWIGTYPE_p_CvPoint2D32f,0,_wrap_new_CvPoint2D32f,0,_wrap_delete_CvPoint2D32f,swig_CvPoint2D32f_members,swig_CvPoint2D32f_base_names,swig_CvPoint2D32f_base }; + +static octave_value_list _wrap_cvPoint2D32f (const octave_value_list& args, int nargout) { + double arg1 ; + double arg2 ; + double val1 ; + int ecode1 = 0 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint2D32f result; + + if (!SWIG_check_num_args("cvPoint2D32f",args.length(),2,2,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvPoint2D32f" "', 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 '" "cvPoint2D32f" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = cvPoint2D32f(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvPoint2D32f((const CvPoint2D32f&)(result))), SWIGTYPE_p_CvPoint2D32f, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvPointTo32f (const octave_value_list& args, int nargout) { + CvPoint arg1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint2D32f result; + + if (!SWIG_check_num_args("cvPointTo32f",args.length(),1,1,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvPoint(args(0)); + } + { + try { + result = cvPointTo32f(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvPoint2D32f((const CvPoint2D32f&)(result))), SWIGTYPE_p_CvPoint2D32f, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvPointFrom32f (const octave_value_list& args, int nargout) { + CvPoint2D32f arg1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint result; + + if (!SWIG_check_num_args("cvPointFrom32f",args.length(),1,1,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvPoint2D32f(args(0)); + } + { + try { + result = cvPointFrom32f(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvPoint((const CvPoint&)(result))), SWIGTYPE_p_CvPoint, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint3D32f_x_set (const octave_value_list& args, int nargout) { + CvPoint3D32f *arg1 = (CvPoint3D32f *) 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("CvPoint3D32f_x_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D32f_x_set" "', argument " "1"" of type '" "CvPoint3D32f *""'"); + } + arg1 = (CvPoint3D32f *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint3D32f_x_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->x = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint3D32f_x_get (const octave_value_list& args, int nargout) { + CvPoint3D32f *arg1 = (CvPoint3D32f *) 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("CvPoint3D32f_x_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D32f_x_get" "', argument " "1"" of type '" "CvPoint3D32f *""'"); + } + arg1 = (CvPoint3D32f *)(argp1); + result = (float) ((arg1)->x); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint3D32f_y_set (const octave_value_list& args, int nargout) { + CvPoint3D32f *arg1 = (CvPoint3D32f *) 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("CvPoint3D32f_y_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D32f_y_set" "', argument " "1"" of type '" "CvPoint3D32f *""'"); + } + arg1 = (CvPoint3D32f *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint3D32f_y_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + 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_CvPoint3D32f_y_get (const octave_value_list& args, int nargout) { + CvPoint3D32f *arg1 = (CvPoint3D32f *) 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("CvPoint3D32f_y_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D32f_y_get" "', argument " "1"" of type '" "CvPoint3D32f *""'"); + } + arg1 = (CvPoint3D32f *)(argp1); + result = (float) ((arg1)->y); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint3D32f_z_set (const octave_value_list& args, int nargout) { + CvPoint3D32f *arg1 = (CvPoint3D32f *) 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("CvPoint3D32f_z_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D32f_z_set" "', argument " "1"" of type '" "CvPoint3D32f *""'"); + } + arg1 = (CvPoint3D32f *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint3D32f_z_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->z = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint3D32f_z_get (const octave_value_list& args, int nargout) { + CvPoint3D32f *arg1 = (CvPoint3D32f *) 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("CvPoint3D32f_z_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D32f_z_get" "', argument " "1"" of type '" "CvPoint3D32f *""'"); + } + arg1 = (CvPoint3D32f *)(argp1); + result = (float) ((arg1)->z); + _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_CvPoint3D32f (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint3D32f *result = 0 ; + + if (!SWIG_check_num_args("new_CvPoint3D32f",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvPoint3D32f *)new CvPoint3D32f(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint3D32f, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvPoint3D32f (const octave_value_list& args, int nargout) { + CvPoint3D32f *arg1 = (CvPoint3D32f *) 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_CvPoint3D32f",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D32f, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPoint3D32f" "', argument " "1"" of type '" "CvPoint3D32f *""'"); + } + arg1 = (CvPoint3D32f *)(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_CvPoint3D32f_members[] = { +{"x",0,_wrap_CvPoint3D32f_x_get,_wrap_CvPoint3D32f_x_set,0,0}, +{"y",0,_wrap_CvPoint3D32f_y_get,_wrap_CvPoint3D32f_y_set,0,0}, +{"z",0,_wrap_CvPoint3D32f_z_get,_wrap_CvPoint3D32f_z_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvPoint3D32f_base_names[] = {0}; +static const swig_type_info *swig_CvPoint3D32f_base[] = {0}; +static swig_octave_class _wrap_class_CvPoint3D32f = {"CvPoint3D32f", &SWIGTYPE_p_CvPoint3D32f,0,_wrap_new_CvPoint3D32f,0,_wrap_delete_CvPoint3D32f,swig_CvPoint3D32f_members,swig_CvPoint3D32f_base_names,swig_CvPoint3D32f_base }; + +static octave_value_list _wrap_cvPoint3D32f (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; + CvPoint3D32f result; + + if (!SWIG_check_num_args("cvPoint3D32f",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 '" "cvPoint3D32f" "', 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 '" "cvPoint3D32f" "', 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 '" "cvPoint3D32f" "', argument " "3"" of type '" "double""'"); + } + arg3 = (double)(val3); + { + try { + result = cvPoint3D32f(arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvPoint3D32f((const CvPoint3D32f&)(result))), SWIGTYPE_p_CvPoint3D32f, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint2D64f_x_set (const octave_value_list& args, int nargout) { + CvPoint2D64f *arg1 = (CvPoint2D64f *) 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("CvPoint2D64f_x_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint2D64f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D64f_x_set" "', argument " "1"" of type '" "CvPoint2D64f *""'"); + } + arg1 = (CvPoint2D64f *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint2D64f_x_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->x = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint2D64f_x_get (const octave_value_list& args, int nargout) { + CvPoint2D64f *arg1 = (CvPoint2D64f *) 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("CvPoint2D64f_x_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint2D64f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D64f_x_get" "', argument " "1"" of type '" "CvPoint2D64f *""'"); + } + arg1 = (CvPoint2D64f *)(argp1); + result = (double) ((arg1)->x); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint2D64f_y_set (const octave_value_list& args, int nargout) { + CvPoint2D64f *arg1 = (CvPoint2D64f *) 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("CvPoint2D64f_y_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint2D64f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D64f_y_set" "', argument " "1"" of type '" "CvPoint2D64f *""'"); + } + arg1 = (CvPoint2D64f *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint2D64f_y_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + 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_CvPoint2D64f_y_get (const octave_value_list& args, int nargout) { + CvPoint2D64f *arg1 = (CvPoint2D64f *) 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("CvPoint2D64f_y_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint2D64f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint2D64f_y_get" "', argument " "1"" of type '" "CvPoint2D64f *""'"); + } + arg1 = (CvPoint2D64f *)(argp1); + result = (double) ((arg1)->y); + _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_CvPoint2D64f (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint2D64f *result = 0 ; + + if (!SWIG_check_num_args("new_CvPoint2D64f",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvPoint2D64f *)new CvPoint2D64f(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D64f, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvPoint2D64f (const octave_value_list& args, int nargout) { + CvPoint2D64f *arg1 = (CvPoint2D64f *) 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_CvPoint2D64f",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint2D64f, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPoint2D64f" "', argument " "1"" of type '" "CvPoint2D64f *""'"); + } + arg1 = (CvPoint2D64f *)(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_CvPoint2D64f_members[] = { +{"x",0,_wrap_CvPoint2D64f_x_get,_wrap_CvPoint2D64f_x_set,0,0}, +{"y",0,_wrap_CvPoint2D64f_y_get,_wrap_CvPoint2D64f_y_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvPoint2D64f_base_names[] = {0}; +static const swig_type_info *swig_CvPoint2D64f_base[] = {0}; +static swig_octave_class _wrap_class_CvPoint2D64f = {"CvPoint2D64f", &SWIGTYPE_p_CvPoint2D64f,0,_wrap_new_CvPoint2D64f,0,_wrap_delete_CvPoint2D64f,swig_CvPoint2D64f_members,swig_CvPoint2D64f_base_names,swig_CvPoint2D64f_base }; + +static octave_value_list _wrap_cvPoint2D64f (const octave_value_list& args, int nargout) { + double arg1 ; + double arg2 ; + double val1 ; + int ecode1 = 0 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint2D64f result; + + if (!SWIG_check_num_args("cvPoint2D64f",args.length(),2,2,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvPoint2D64f" "', 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 '" "cvPoint2D64f" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = cvPoint2D64f(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvPoint2D64f((const CvPoint2D64f&)(result))), SWIGTYPE_p_CvPoint2D64f, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint3D64f_x_set (const octave_value_list& args, int nargout) { + CvPoint3D64f *arg1 = (CvPoint3D64f *) 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("CvPoint3D64f_x_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D64f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D64f_x_set" "', argument " "1"" of type '" "CvPoint3D64f *""'"); + } + arg1 = (CvPoint3D64f *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint3D64f_x_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->x = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint3D64f_x_get (const octave_value_list& args, int nargout) { + CvPoint3D64f *arg1 = (CvPoint3D64f *) 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("CvPoint3D64f_x_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D64f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D64f_x_get" "', argument " "1"" of type '" "CvPoint3D64f *""'"); + } + arg1 = (CvPoint3D64f *)(argp1); + result = (double) ((arg1)->x); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint3D64f_y_set (const octave_value_list& args, int nargout) { + CvPoint3D64f *arg1 = (CvPoint3D64f *) 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("CvPoint3D64f_y_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D64f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D64f_y_set" "', argument " "1"" of type '" "CvPoint3D64f *""'"); + } + arg1 = (CvPoint3D64f *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint3D64f_y_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + 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_CvPoint3D64f_y_get (const octave_value_list& args, int nargout) { + CvPoint3D64f *arg1 = (CvPoint3D64f *) 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("CvPoint3D64f_y_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D64f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D64f_y_get" "', argument " "1"" of type '" "CvPoint3D64f *""'"); + } + arg1 = (CvPoint3D64f *)(argp1); + result = (double) ((arg1)->y); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint3D64f_z_set (const octave_value_list& args, int nargout) { + CvPoint3D64f *arg1 = (CvPoint3D64f *) 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("CvPoint3D64f_z_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D64f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D64f_z_set" "', argument " "1"" of type '" "CvPoint3D64f *""'"); + } + arg1 = (CvPoint3D64f *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPoint3D64f_z_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->z = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPoint3D64f_z_get (const octave_value_list& args, int nargout) { + CvPoint3D64f *arg1 = (CvPoint3D64f *) 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("CvPoint3D64f_z_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D64f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPoint3D64f_z_get" "', argument " "1"" of type '" "CvPoint3D64f *""'"); + } + arg1 = (CvPoint3D64f *)(argp1); + result = (double) ((arg1)->z); + _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_CvPoint3D64f (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint3D64f *result = 0 ; + + if (!SWIG_check_num_args("new_CvPoint3D64f",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvPoint3D64f *)new CvPoint3D64f(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint3D64f, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvPoint3D64f (const octave_value_list& args, int nargout) { + CvPoint3D64f *arg1 = (CvPoint3D64f *) 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_CvPoint3D64f",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPoint3D64f, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPoint3D64f" "', argument " "1"" of type '" "CvPoint3D64f *""'"); + } + arg1 = (CvPoint3D64f *)(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_CvPoint3D64f_members[] = { +{"x",0,_wrap_CvPoint3D64f_x_get,_wrap_CvPoint3D64f_x_set,0,0}, +{"y",0,_wrap_CvPoint3D64f_y_get,_wrap_CvPoint3D64f_y_set,0,0}, +{"z",0,_wrap_CvPoint3D64f_z_get,_wrap_CvPoint3D64f_z_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvPoint3D64f_base_names[] = {0}; +static const swig_type_info *swig_CvPoint3D64f_base[] = {0}; +static swig_octave_class _wrap_class_CvPoint3D64f = {"CvPoint3D64f", &SWIGTYPE_p_CvPoint3D64f,0,_wrap_new_CvPoint3D64f,0,_wrap_delete_CvPoint3D64f,swig_CvPoint3D64f_members,swig_CvPoint3D64f_base_names,swig_CvPoint3D64f_base }; + +static octave_value_list _wrap_cvPoint3D64f (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; + CvPoint3D64f result; + + if (!SWIG_check_num_args("cvPoint3D64f",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 '" "cvPoint3D64f" "', 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 '" "cvPoint3D64f" "', 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 '" "cvPoint3D64f" "', argument " "3"" of type '" "double""'"); + } + arg3 = (double)(val3); + { + try { + result = cvPoint3D64f(arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvPoint3D64f((const CvPoint3D64f&)(result))), SWIGTYPE_p_CvPoint3D64f, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSize_width_set (const octave_value_list& args, int nargout) { + CvSize *arg1 = (CvSize *) 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("CvSize_width_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSize, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize_width_set" "', argument " "1"" of type '" "CvSize *""'"); + } + arg1 = (CvSize *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSize_width_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->width = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSize_width_get (const octave_value_list& args, int nargout) { + CvSize *arg1 = (CvSize *) 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("CvSize_width_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSize, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize_width_get" "', argument " "1"" of type '" "CvSize *""'"); + } + arg1 = (CvSize *)(argp1); + result = (int) ((arg1)->width); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSize_height_set (const octave_value_list& args, int nargout) { + CvSize *arg1 = (CvSize *) 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("CvSize_height_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSize, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize_height_set" "', argument " "1"" of type '" "CvSize *""'"); + } + arg1 = (CvSize *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSize_height_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->height = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSize_height_get (const octave_value_list& args, int nargout) { + CvSize *arg1 = (CvSize *) 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("CvSize_height_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSize, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize_height_get" "', argument " "1"" of type '" "CvSize *""'"); + } + arg1 = (CvSize *)(argp1); + result = (int) ((arg1)->height); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSize (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSize *result = 0 ; + + if (!SWIG_check_num_args("new_CvSize",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSize *)new CvSize(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSize, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSize (const octave_value_list& args, int nargout) { + CvSize *arg1 = (CvSize *) 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_CvSize",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSize, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSize" "', argument " "1"" of type '" "CvSize *""'"); + } + arg1 = (CvSize *)(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_CvSize_members[] = { +{"width",0,_wrap_CvSize_width_get,_wrap_CvSize_width_set,0,0}, +{"height",0,_wrap_CvSize_height_get,_wrap_CvSize_height_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSize_base_names[] = {0}; +static const swig_type_info *swig_CvSize_base[] = {0}; +static swig_octave_class _wrap_class_CvSize = {"CvSize", &SWIGTYPE_p_CvSize,0,_wrap_new_CvSize,0,_wrap_delete_CvSize,swig_CvSize_members,swig_CvSize_base_names,swig_CvSize_base }; + +static octave_value_list _wrap_cvSize (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; + CvSize result; + + if (!SWIG_check_num_args("cvSize",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 '" "cvSize" "', 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 '" "cvSize" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = cvSize(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvSize((const CvSize&)(result))), SWIGTYPE_p_CvSize, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSize2D32f_width_set (const octave_value_list& args, int nargout) { + CvSize2D32f *arg1 = (CvSize2D32f *) 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("CvSize2D32f_width_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSize2D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize2D32f_width_set" "', argument " "1"" of type '" "CvSize2D32f *""'"); + } + arg1 = (CvSize2D32f *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSize2D32f_width_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->width = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSize2D32f_width_get (const octave_value_list& args, int nargout) { + CvSize2D32f *arg1 = (CvSize2D32f *) 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("CvSize2D32f_width_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSize2D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize2D32f_width_get" "', argument " "1"" of type '" "CvSize2D32f *""'"); + } + arg1 = (CvSize2D32f *)(argp1); + result = (float) ((arg1)->width); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSize2D32f_height_set (const octave_value_list& args, int nargout) { + CvSize2D32f *arg1 = (CvSize2D32f *) 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("CvSize2D32f_height_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSize2D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize2D32f_height_set" "', argument " "1"" of type '" "CvSize2D32f *""'"); + } + arg1 = (CvSize2D32f *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSize2D32f_height_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->height = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSize2D32f_height_get (const octave_value_list& args, int nargout) { + CvSize2D32f *arg1 = (CvSize2D32f *) 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("CvSize2D32f_height_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSize2D32f, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSize2D32f_height_get" "', argument " "1"" of type '" "CvSize2D32f *""'"); + } + arg1 = (CvSize2D32f *)(argp1); + result = (float) ((arg1)->height); + _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_CvSize2D32f (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSize2D32f *result = 0 ; + + if (!SWIG_check_num_args("new_CvSize2D32f",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSize2D32f *)new CvSize2D32f(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSize2D32f, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSize2D32f (const octave_value_list& args, int nargout) { + CvSize2D32f *arg1 = (CvSize2D32f *) 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_CvSize2D32f",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSize2D32f, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSize2D32f" "', argument " "1"" of type '" "CvSize2D32f *""'"); + } + arg1 = (CvSize2D32f *)(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_CvSize2D32f_members[] = { +{"width",0,_wrap_CvSize2D32f_width_get,_wrap_CvSize2D32f_width_set,0,0}, +{"height",0,_wrap_CvSize2D32f_height_get,_wrap_CvSize2D32f_height_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSize2D32f_base_names[] = {0}; +static const swig_type_info *swig_CvSize2D32f_base[] = {0}; +static swig_octave_class _wrap_class_CvSize2D32f = {"CvSize2D32f", &SWIGTYPE_p_CvSize2D32f,0,_wrap_new_CvSize2D32f,0,_wrap_delete_CvSize2D32f,swig_CvSize2D32f_members,swig_CvSize2D32f_base_names,swig_CvSize2D32f_base }; + +static octave_value_list _wrap_cvSize2D32f (const octave_value_list& args, int nargout) { + double arg1 ; + double arg2 ; + double val1 ; + int ecode1 = 0 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSize2D32f result; + + if (!SWIG_check_num_args("cvSize2D32f",args.length(),2,2,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvSize2D32f" "', 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 '" "cvSize2D32f" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = cvSize2D32f(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvSize2D32f((const CvSize2D32f&)(result))), SWIGTYPE_p_CvSize2D32f, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvBox2D_center_set (const octave_value_list& args, int nargout) { + CvBox2D *arg1 = (CvBox2D *) 0 ; + CvPoint2D32f *arg2 = (CvPoint2D32f *) 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("CvBox2D_center_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBox2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBox2D_center_set" "', argument " "1"" of type '" "CvBox2D *""'"); + } + arg1 = (CvBox2D *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBox2D_center_set" "', argument " "2"" of type '" "CvPoint2D32f *""'"); + } + arg2 = (CvPoint2D32f *)(argp2); + if (arg1) (arg1)->center = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvBox2D_center_get (const octave_value_list& args, int nargout) { + CvBox2D *arg1 = (CvBox2D *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint2D32f *result = 0 ; + + if (!SWIG_check_num_args("CvBox2D_center_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBox2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBox2D_center_get" "', argument " "1"" of type '" "CvBox2D *""'"); + } + arg1 = (CvBox2D *)(argp1); + result = (CvPoint2D32f *)& ((arg1)->center); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvBox2D_size_set (const octave_value_list& args, int nargout) { + CvBox2D *arg1 = (CvBox2D *) 0 ; + CvSize2D32f *arg2 = (CvSize2D32f *) 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("CvBox2D_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBox2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBox2D_size_set" "', argument " "1"" of type '" "CvBox2D *""'"); + } + arg1 = (CvBox2D *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSize2D32f, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvBox2D_size_set" "', argument " "2"" of type '" "CvSize2D32f *""'"); + } + arg2 = (CvSize2D32f *)(argp2); + if (arg1) (arg1)->size = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvBox2D_size_get (const octave_value_list& args, int nargout) { + CvBox2D *arg1 = (CvBox2D *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSize2D32f *result = 0 ; + + if (!SWIG_check_num_args("CvBox2D_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBox2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBox2D_size_get" "', argument " "1"" of type '" "CvBox2D *""'"); + } + arg1 = (CvBox2D *)(argp1); + result = (CvSize2D32f *)& ((arg1)->size); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSize2D32f, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvBox2D_angle_set (const octave_value_list& args, int nargout) { + CvBox2D *arg1 = (CvBox2D *) 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("CvBox2D_angle_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBox2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBox2D_angle_set" "', argument " "1"" of type '" "CvBox2D *""'"); + } + arg1 = (CvBox2D *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvBox2D_angle_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->angle = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvBox2D_angle_get (const octave_value_list& args, int nargout) { + CvBox2D *arg1 = (CvBox2D *) 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("CvBox2D_angle_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBox2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvBox2D_angle_get" "', argument " "1"" of type '" "CvBox2D *""'"); + } + arg1 = (CvBox2D *)(argp1); + result = (float) ((arg1)->angle); + _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_CvBox2D (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvBox2D *result = 0 ; + + if (!SWIG_check_num_args("new_CvBox2D",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvBox2D *)new CvBox2D(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvBox2D, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvBox2D (const octave_value_list& args, int nargout) { + CvBox2D *arg1 = (CvBox2D *) 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_CvBox2D",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvBox2D, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvBox2D" "', argument " "1"" of type '" "CvBox2D *""'"); + } + arg1 = (CvBox2D *)(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_CvBox2D_members[] = { +{"center",0,_wrap_CvBox2D_center_get,_wrap_CvBox2D_center_set,0,0}, +{"size",0,_wrap_CvBox2D_size_get,_wrap_CvBox2D_size_set,0,0}, +{"angle",0,_wrap_CvBox2D_angle_get,_wrap_CvBox2D_angle_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvBox2D_base_names[] = {0}; +static const swig_type_info *swig_CvBox2D_base[] = {0}; +static swig_octave_class _wrap_class_CvBox2D = {"CvBox2D", &SWIGTYPE_p_CvBox2D,0,_wrap_new_CvBox2D,0,_wrap_delete_CvBox2D,swig_CvBox2D_members,swig_CvBox2D_base_names,swig_CvBox2D_base }; + +static octave_value_list _wrap_CvLineIterator_ptr_set (const octave_value_list& args, int nargout) { + CvLineIterator *arg1 = (CvLineIterator *) 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("CvLineIterator_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_ptr_set" "', argument " "1"" of type '" "CvLineIterator *""'"); + } + arg1 = (CvLineIterator *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvLineIterator_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_CvLineIterator_ptr_get (const octave_value_list& args, int nargout) { + CvLineIterator *arg1 = (CvLineIterator *) 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("CvLineIterator_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_ptr_get" "', argument " "1"" of type '" "CvLineIterator *""'"); + } + arg1 = (CvLineIterator *)(argp1); + result = (uchar *) ((arg1)->ptr); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvLineIterator_err_set (const octave_value_list& args, int nargout) { + CvLineIterator *arg1 = (CvLineIterator *) 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("CvLineIterator_err_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_err_set" "', argument " "1"" of type '" "CvLineIterator *""'"); + } + arg1 = (CvLineIterator *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLineIterator_err_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->err = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvLineIterator_err_get (const octave_value_list& args, int nargout) { + CvLineIterator *arg1 = (CvLineIterator *) 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("CvLineIterator_err_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_err_get" "', argument " "1"" of type '" "CvLineIterator *""'"); + } + arg1 = (CvLineIterator *)(argp1); + result = (int) ((arg1)->err); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvLineIterator_plus_delta_set (const octave_value_list& args, int nargout) { + CvLineIterator *arg1 = (CvLineIterator *) 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("CvLineIterator_plus_delta_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_plus_delta_set" "', argument " "1"" of type '" "CvLineIterator *""'"); + } + arg1 = (CvLineIterator *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLineIterator_plus_delta_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->plus_delta = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvLineIterator_plus_delta_get (const octave_value_list& args, int nargout) { + CvLineIterator *arg1 = (CvLineIterator *) 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("CvLineIterator_plus_delta_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_plus_delta_get" "', argument " "1"" of type '" "CvLineIterator *""'"); + } + arg1 = (CvLineIterator *)(argp1); + result = (int) ((arg1)->plus_delta); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvLineIterator_minus_delta_set (const octave_value_list& args, int nargout) { + CvLineIterator *arg1 = (CvLineIterator *) 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("CvLineIterator_minus_delta_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_minus_delta_set" "', argument " "1"" of type '" "CvLineIterator *""'"); + } + arg1 = (CvLineIterator *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLineIterator_minus_delta_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->minus_delta = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvLineIterator_minus_delta_get (const octave_value_list& args, int nargout) { + CvLineIterator *arg1 = (CvLineIterator *) 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("CvLineIterator_minus_delta_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_minus_delta_get" "', argument " "1"" of type '" "CvLineIterator *""'"); + } + arg1 = (CvLineIterator *)(argp1); + result = (int) ((arg1)->minus_delta); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvLineIterator_plus_step_set (const octave_value_list& args, int nargout) { + CvLineIterator *arg1 = (CvLineIterator *) 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("CvLineIterator_plus_step_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_plus_step_set" "', argument " "1"" of type '" "CvLineIterator *""'"); + } + arg1 = (CvLineIterator *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLineIterator_plus_step_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->plus_step = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvLineIterator_plus_step_get (const octave_value_list& args, int nargout) { + CvLineIterator *arg1 = (CvLineIterator *) 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("CvLineIterator_plus_step_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_plus_step_get" "', argument " "1"" of type '" "CvLineIterator *""'"); + } + arg1 = (CvLineIterator *)(argp1); + result = (int) ((arg1)->plus_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_CvLineIterator_minus_step_set (const octave_value_list& args, int nargout) { + CvLineIterator *arg1 = (CvLineIterator *) 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("CvLineIterator_minus_step_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_minus_step_set" "', argument " "1"" of type '" "CvLineIterator *""'"); + } + arg1 = (CvLineIterator *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvLineIterator_minus_step_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->minus_step = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvLineIterator_minus_step_get (const octave_value_list& args, int nargout) { + CvLineIterator *arg1 = (CvLineIterator *) 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("CvLineIterator_minus_step_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvLineIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvLineIterator_minus_step_get" "', argument " "1"" of type '" "CvLineIterator *""'"); + } + arg1 = (CvLineIterator *)(argp1); + result = (int) ((arg1)->minus_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_new_CvLineIterator (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvLineIterator *result = 0 ; + + if (!SWIG_check_num_args("new_CvLineIterator",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvLineIterator *)new CvLineIterator(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvLineIterator, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvLineIterator (const octave_value_list& args, int nargout) { + CvLineIterator *arg1 = (CvLineIterator *) 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_CvLineIterator",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvLineIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvLineIterator" "', argument " "1"" of type '" "CvLineIterator *""'"); + } + arg1 = (CvLineIterator *)(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_CvLineIterator_members[] = { +{"ptr",0,_wrap_CvLineIterator_ptr_get,_wrap_CvLineIterator_ptr_set,0,0}, +{"err",0,_wrap_CvLineIterator_err_get,_wrap_CvLineIterator_err_set,0,0}, +{"plus_delta",0,_wrap_CvLineIterator_plus_delta_get,_wrap_CvLineIterator_plus_delta_set,0,0}, +{"minus_delta",0,_wrap_CvLineIterator_minus_delta_get,_wrap_CvLineIterator_minus_delta_set,0,0}, +{"plus_step",0,_wrap_CvLineIterator_plus_step_get,_wrap_CvLineIterator_plus_step_set,0,0}, +{"minus_step",0,_wrap_CvLineIterator_minus_step_get,_wrap_CvLineIterator_minus_step_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvLineIterator_base_names[] = {0}; +static const swig_type_info *swig_CvLineIterator_base[] = {0}; +static swig_octave_class _wrap_class_CvLineIterator = {"CvLineIterator", &SWIGTYPE_p_CvLineIterator,0,_wrap_new_CvLineIterator,0,_wrap_delete_CvLineIterator,swig_CvLineIterator_members,swig_CvLineIterator_base_names,swig_CvLineIterator_base }; + +static octave_value_list _wrap_CvSlice_start_index_set (const octave_value_list& args, int nargout) { + CvSlice *arg1 = (CvSlice *) 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("CvSlice_start_index_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSlice, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSlice_start_index_set" "', argument " "1"" of type '" "CvSlice *""'"); + } + arg1 = (CvSlice *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSlice_start_index_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->start_index = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSlice_start_index_get (const octave_value_list& args, int nargout) { + CvSlice *arg1 = (CvSlice *) 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("CvSlice_start_index_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSlice, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSlice_start_index_get" "', argument " "1"" of type '" "CvSlice *""'"); + } + arg1 = (CvSlice *)(argp1); + result = (int) ((arg1)->start_index); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSlice_end_index_set (const octave_value_list& args, int nargout) { + CvSlice *arg1 = (CvSlice *) 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("CvSlice_end_index_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSlice, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSlice_end_index_set" "', argument " "1"" of type '" "CvSlice *""'"); + } + arg1 = (CvSlice *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSlice_end_index_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->end_index = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSlice_end_index_get (const octave_value_list& args, int nargout) { + CvSlice *arg1 = (CvSlice *) 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("CvSlice_end_index_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSlice, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSlice_end_index_get" "', argument " "1"" of type '" "CvSlice *""'"); + } + arg1 = (CvSlice *)(argp1); + result = (int) ((arg1)->end_index); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSlice (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSlice *result = 0 ; + + if (!SWIG_check_num_args("new_CvSlice",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSlice *)new CvSlice(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSlice, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSlice (const octave_value_list& args, int nargout) { + CvSlice *arg1 = (CvSlice *) 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_CvSlice",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSlice, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSlice" "', argument " "1"" of type '" "CvSlice *""'"); + } + arg1 = (CvSlice *)(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_CvSlice_members[] = { +{"start_index",0,_wrap_CvSlice_start_index_get,_wrap_CvSlice_start_index_set,0,0}, +{"end_index",0,_wrap_CvSlice_end_index_get,_wrap_CvSlice_end_index_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSlice_base_names[] = {0}; +static const swig_type_info *swig_CvSlice_base[] = {0}; +static swig_octave_class _wrap_class_CvSlice = {"CvSlice", &SWIGTYPE_p_CvSlice,0,_wrap_new_CvSlice,0,_wrap_delete_CvSlice,swig_CvSlice_members,swig_CvSlice_base_names,swig_CvSlice_base }; + +static octave_value_list _wrap_cvSlice (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; + CvSlice result; + + if (!SWIG_check_num_args("cvSlice",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 '" "cvSlice" "', 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 '" "cvSlice" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = cvSlice(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvSlice((const CvSlice&)(result))), SWIGTYPE_p_CvSlice, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvScalar_val_set (const octave_value_list& args, int nargout) { + CvScalar *arg1 = (CvScalar *) 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("CvScalar_val_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvScalar, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvScalar_val_set" "', argument " "1"" of type '" "CvScalar *""'"); + } + arg1 = (CvScalar *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvScalar_val_set" "', argument " "2"" of type '" "double [4]""'"); + } + arg2 = (double *)(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)4; ++ii) arg1->val[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""double [4]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvScalar_val_get (const octave_value_list& args, int nargout) { + CvScalar *arg1 = (CvScalar *) 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("CvScalar_val_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvScalar, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvScalar_val_get" "', argument " "1"" of type '" "CvScalar *""'"); + } + arg1 = (CvScalar *)(argp1); + result = (double *)(double *) ((arg1)->val); + _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_CvScalar___str__ (const octave_value_list& args, int nargout) { + CvScalar *arg1 = (CvScalar *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + char *result = 0 ; + + if (!SWIG_check_num_args("CvScalar___str__",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvScalar, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvScalar___str__" "', argument " "1"" of type '" "CvScalar *""'"); + } + arg1 = (CvScalar *)(argp1); + { + try { + result = (char *)CvScalar___str__(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_FromCharPtr((const char *)result); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvScalar___repr__ (const octave_value_list& args, int nargout) { + CvScalar *arg1 = (CvScalar *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + char *result = 0 ; + + if (!SWIG_check_num_args("CvScalar___repr__",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvScalar, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvScalar___repr__" "', argument " "1"" of type '" "CvScalar *""'"); + } + arg1 = (CvScalar *)(argp1); + { + try { + result = (char *)CvScalar___repr__(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_FromCharPtr((const char *)result); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvScalar___getitem__ (const octave_value_list& args, int nargout) { + CvScalar *arg1 = (CvScalar *) 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; + + if (!SWIG_check_num_args("CvScalar___getitem__",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvScalar, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvScalar___getitem__" "', argument " "1"" of type '" "CvScalar *""'"); + } + arg1 = (CvScalar *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvScalar___getitem__" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (double)CvScalar___getitem__(arg1,arg2); + } + 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_CvScalar___setitem__ (const octave_value_list& args, int nargout) { + CvScalar *arg1 = (CvScalar *) 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; + + if (!SWIG_check_num_args("CvScalar___setitem__",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvScalar, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvScalar___setitem__" "', argument " "1"" of type '" "CvScalar *""'"); + } + arg1 = (CvScalar *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvScalar___setitem__" "', 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 '" "CvScalar___setitem__" "', argument " "3"" of type '" "double""'"); + } + arg3 = (double)(val3); + { + try { + CvScalar___setitem__(arg1,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_CvScalar (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvScalar *result = 0 ; + + if (!SWIG_check_num_args("new_CvScalar",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvScalar *)new CvScalar(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvScalar, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvScalar (const octave_value_list& args, int nargout) { + CvScalar *arg1 = (CvScalar *) 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_CvScalar",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvScalar, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvScalar" "', argument " "1"" of type '" "CvScalar *""'"); + } + arg1 = (CvScalar *)(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_CvScalar_members[] = { +{"val",0,_wrap_CvScalar_val_get,_wrap_CvScalar_val_set,0,0}, +{"__str__",_wrap_CvScalar___str__,0,0,0,0}, +{"__repr__",_wrap_CvScalar___repr__,0,0,0,0}, +{"__getitem__",_wrap_CvScalar___getitem__,0,0,0,0}, +{"__setitem__",_wrap_CvScalar___setitem__,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvScalar_base_names[] = {0}; +static const swig_type_info *swig_CvScalar_base[] = {0}; +static swig_octave_class _wrap_class_CvScalar = {"CvScalar", &SWIGTYPE_p_CvScalar,0,_wrap_new_CvScalar,0,_wrap_delete_CvScalar,swig_CvScalar_members,swig_CvScalar_base_names,swig_CvScalar_base }; + +static octave_value_list _wrap_cvScalar__SWIG_0 (const octave_value_list& args, int nargout) { + double arg1 ; + double arg2 ; + double arg3 ; + double arg4 ; + double val1 ; + int ecode1 = 0 ; + double 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; + CvScalar result; + + if (!SWIG_check_num_args("cvScalar",args.length(),4,4,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvScalar" "', 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 '" "cvScalar" "', 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 '" "cvScalar" "', 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 '" "cvScalar" "', argument " "4"" of type '" "double""'"); + } + arg4 = (double)(val4); + { + try { + result = cvScalar(arg1,arg2,arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvScalar((const CvScalar&)(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvScalar__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; + CvScalar result; + + if (!SWIG_check_num_args("cvScalar",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 '" "cvScalar" "', 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 '" "cvScalar" "', 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 '" "cvScalar" "', argument " "3"" of type '" "double""'"); + } + arg3 = (double)(val3); + { + try { + result = cvScalar(arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvScalar((const CvScalar&)(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvScalar__SWIG_2 (const octave_value_list& args, int nargout) { + double arg1 ; + double arg2 ; + double val1 ; + int ecode1 = 0 ; + double val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvScalar result; + + if (!SWIG_check_num_args("cvScalar",args.length(),2,2,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvScalar" "', 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 '" "cvScalar" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + { + try { + result = cvScalar(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvScalar((const CvScalar&)(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvScalar__SWIG_3 (const octave_value_list& args, int nargout) { + double arg1 ; + double val1 ; + int ecode1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvScalar result; + + if (!SWIG_check_num_args("cvScalar",args.length(),1,1,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvScalar" "', argument " "1"" of type '" "double""'"); + } + arg1 = (double)(val1); + { + try { + result = cvScalar(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvScalar((const CvScalar&)(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvScalar (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 == 1) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_cvScalar__SWIG_3(args, nargout); + } + } + if (argc == 2) { + 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) { + return _wrap_cvScalar__SWIG_2(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_cvScalar__SWIG_1(args, nargout); + } + } + } + } + if (argc == 4) { + 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) { + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_cvScalar__SWIG_0(args, nargout); + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_cvRealScalar (const octave_value_list& args, int nargout) { + double arg1 ; + double val1 ; + int ecode1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvScalar result; + + if (!SWIG_check_num_args("cvRealScalar",args.length(),1,1,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvRealScalar" "', argument " "1"" of type '" "double""'"); + } + arg1 = (double)(val1); + { + try { + result = cvRealScalar(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvScalar((const CvScalar&)(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvScalarAll (const octave_value_list& args, int nargout) { + double arg1 ; + double val1 ; + int ecode1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvScalar result; + + if (!SWIG_check_num_args("cvScalarAll",args.length(),1,1,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvScalarAll" "', argument " "1"" of type '" "double""'"); + } + arg1 = (double)(val1); + { + try { + result = cvScalarAll(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvScalar((const CvScalar&)(result))), SWIGTYPE_p_CvScalar, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMemBlock_prev_set (const octave_value_list& args, int nargout) { + CvMemBlock *arg1 = (CvMemBlock *) 0 ; + CvMemBlock *arg2 = (CvMemBlock *) 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("CvMemBlock_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemBlock_prev_set" "', argument " "1"" of type '" "CvMemBlock *""'"); + } + arg1 = (CvMemBlock *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMemBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMemBlock_prev_set" "', argument " "2"" of type '" "CvMemBlock *""'"); + } + arg2 = (CvMemBlock *)(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_CvMemBlock_prev_get (const octave_value_list& args, int nargout) { + CvMemBlock *arg1 = (CvMemBlock *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMemBlock *result = 0 ; + + if (!SWIG_check_num_args("CvMemBlock_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemBlock_prev_get" "', argument " "1"" of type '" "CvMemBlock *""'"); + } + arg1 = (CvMemBlock *)(argp1); + result = (CvMemBlock *) ((arg1)->prev); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMemBlock_next_set (const octave_value_list& args, int nargout) { + CvMemBlock *arg1 = (CvMemBlock *) 0 ; + CvMemBlock *arg2 = (CvMemBlock *) 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("CvMemBlock_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemBlock_next_set" "', argument " "1"" of type '" "CvMemBlock *""'"); + } + arg1 = (CvMemBlock *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMemBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMemBlock_next_set" "', argument " "2"" of type '" "CvMemBlock *""'"); + } + arg2 = (CvMemBlock *)(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_CvMemBlock_next_get (const octave_value_list& args, int nargout) { + CvMemBlock *arg1 = (CvMemBlock *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMemBlock *result = 0 ; + + if (!SWIG_check_num_args("CvMemBlock_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemBlock_next_get" "', argument " "1"" of type '" "CvMemBlock *""'"); + } + arg1 = (CvMemBlock *)(argp1); + result = (CvMemBlock *) ((arg1)->next); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMemBlock (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMemBlock *result = 0 ; + + if (!SWIG_check_num_args("new_CvMemBlock",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvMemBlock *)new CvMemBlock(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemBlock, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvMemBlock (const octave_value_list& args, int nargout) { + CvMemBlock *arg1 = (CvMemBlock *) 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_CvMemBlock",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMemBlock" "', argument " "1"" of type '" "CvMemBlock *""'"); + } + arg1 = (CvMemBlock *)(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_CvMemBlock_members[] = { +{"prev",0,_wrap_CvMemBlock_prev_get,_wrap_CvMemBlock_prev_set,0,0}, +{"next",0,_wrap_CvMemBlock_next_get,_wrap_CvMemBlock_next_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvMemBlock_base_names[] = {0}; +static const swig_type_info *swig_CvMemBlock_base[] = {0}; +static swig_octave_class _wrap_class_CvMemBlock = {"CvMemBlock", &SWIGTYPE_p_CvMemBlock,0,_wrap_new_CvMemBlock,0,_wrap_delete_CvMemBlock,swig_CvMemBlock_members,swig_CvMemBlock_base_names,swig_CvMemBlock_base }; + +static octave_value_list _wrap_CvMemStorage_signature_set (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 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("CvMemStorage_signature_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_signature_set" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMemStorage_signature_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->signature = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMemStorage_signature_get (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 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("CvMemStorage_signature_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_signature_get" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(argp1); + result = (int) ((arg1)->signature); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMemStorage_bottom_set (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 0 ; + CvMemBlock *arg2 = (CvMemBlock *) 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("CvMemStorage_bottom_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_bottom_set" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMemBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMemStorage_bottom_set" "', argument " "2"" of type '" "CvMemBlock *""'"); + } + arg2 = (CvMemBlock *)(argp2); + if (arg1) (arg1)->bottom = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMemStorage_bottom_get (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMemBlock *result = 0 ; + + if (!SWIG_check_num_args("CvMemStorage_bottom_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_bottom_get" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(argp1); + result = (CvMemBlock *) ((arg1)->bottom); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMemStorage_top_set (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 0 ; + CvMemBlock *arg2 = (CvMemBlock *) 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("CvMemStorage_top_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_top_set" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMemBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMemStorage_top_set" "', argument " "2"" of type '" "CvMemBlock *""'"); + } + arg2 = (CvMemBlock *)(argp2); + if (arg1) (arg1)->top = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMemStorage_top_get (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMemBlock *result = 0 ; + + if (!SWIG_check_num_args("CvMemStorage_top_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_top_get" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(argp1); + result = (CvMemBlock *) ((arg1)->top); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMemStorage_parent_set (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 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("CvMemStorage_parent_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_parent_set" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(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 '" "CvMemStorage_parent_set" "', argument " "2"" of type '" "CvMemStorage *""'"); + } + arg2 = (CvMemStorage *)(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_CvMemStorage_parent_get (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 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("CvMemStorage_parent_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_parent_get" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(argp1); + result = (CvMemStorage *) ((arg1)->parent); + _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_CvMemStorage_block_size_set (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 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("CvMemStorage_block_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_block_size_set" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMemStorage_block_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->block_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMemStorage_block_size_get (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 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("CvMemStorage_block_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_block_size_get" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(argp1); + result = (int) ((arg1)->block_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_CvMemStorage_free_space_set (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 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("CvMemStorage_free_space_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_free_space_set" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMemStorage_free_space_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->free_space = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMemStorage_free_space_get (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 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("CvMemStorage_free_space_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStorage_free_space_get" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(argp1); + result = (int) ((arg1)->free_space); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvMemStorage (const octave_value_list& args, int nargout) { + CvMemStorage *arg1 = (CvMemStorage *) 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_CvMemStorage",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStorage, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMemStorage" "', argument " "1"" of type '" "CvMemStorage *""'"); + } + arg1 = (CvMemStorage *)(argp1); + { + try { + delete_CvMemStorage(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_CvMemStorage_members[] = { +{"signature",0,_wrap_CvMemStorage_signature_get,_wrap_CvMemStorage_signature_set,0,0}, +{"bottom",0,_wrap_CvMemStorage_bottom_get,_wrap_CvMemStorage_bottom_set,0,0}, +{"top",0,_wrap_CvMemStorage_top_get,_wrap_CvMemStorage_top_set,0,0}, +{"parent",0,_wrap_CvMemStorage_parent_get,_wrap_CvMemStorage_parent_set,0,0}, +{"block_size",0,_wrap_CvMemStorage_block_size_get,_wrap_CvMemStorage_block_size_set,0,0}, +{"free_space",0,_wrap_CvMemStorage_free_space_get,_wrap_CvMemStorage_free_space_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvMemStorage_base_names[] = {0}; +static const swig_type_info *swig_CvMemStorage_base[] = {0}; +static swig_octave_class _wrap_class_CvMemStorage = {"CvMemStorage", &SWIGTYPE_p_CvMemStorage,0,0,0,_wrap_delete_CvMemStorage,swig_CvMemStorage_members,swig_CvMemStorage_base_names,swig_CvMemStorage_base }; + +static octave_value_list _wrap_CvMemStoragePos_top_set (const octave_value_list& args, int nargout) { + CvMemStoragePos *arg1 = (CvMemStoragePos *) 0 ; + CvMemBlock *arg2 = (CvMemBlock *) 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("CvMemStoragePos_top_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStoragePos, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStoragePos_top_set" "', argument " "1"" of type '" "CvMemStoragePos *""'"); + } + arg1 = (CvMemStoragePos *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMemBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMemStoragePos_top_set" "', argument " "2"" of type '" "CvMemBlock *""'"); + } + arg2 = (CvMemBlock *)(argp2); + if (arg1) (arg1)->top = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMemStoragePos_top_get (const octave_value_list& args, int nargout) { + CvMemStoragePos *arg1 = (CvMemStoragePos *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMemBlock *result = 0 ; + + if (!SWIG_check_num_args("CvMemStoragePos_top_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStoragePos, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStoragePos_top_get" "', argument " "1"" of type '" "CvMemStoragePos *""'"); + } + arg1 = (CvMemStoragePos *)(argp1); + result = (CvMemBlock *) ((arg1)->top); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMemStoragePos_free_space_set (const octave_value_list& args, int nargout) { + CvMemStoragePos *arg1 = (CvMemStoragePos *) 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("CvMemStoragePos_free_space_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStoragePos, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStoragePos_free_space_set" "', argument " "1"" of type '" "CvMemStoragePos *""'"); + } + arg1 = (CvMemStoragePos *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMemStoragePos_free_space_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->free_space = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMemStoragePos_free_space_get (const octave_value_list& args, int nargout) { + CvMemStoragePos *arg1 = (CvMemStoragePos *) 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("CvMemStoragePos_free_space_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStoragePos, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMemStoragePos_free_space_get" "', argument " "1"" of type '" "CvMemStoragePos *""'"); + } + arg1 = (CvMemStoragePos *)(argp1); + result = (int) ((arg1)->free_space); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMemStoragePos (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMemStoragePos *result = 0 ; + + if (!SWIG_check_num_args("new_CvMemStoragePos",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvMemStoragePos *)new CvMemStoragePos(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMemStoragePos, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvMemStoragePos (const octave_value_list& args, int nargout) { + CvMemStoragePos *arg1 = (CvMemStoragePos *) 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_CvMemStoragePos",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMemStoragePos, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMemStoragePos" "', argument " "1"" of type '" "CvMemStoragePos *""'"); + } + arg1 = (CvMemStoragePos *)(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_CvMemStoragePos_members[] = { +{"top",0,_wrap_CvMemStoragePos_top_get,_wrap_CvMemStoragePos_top_set,0,0}, +{"free_space",0,_wrap_CvMemStoragePos_free_space_get,_wrap_CvMemStoragePos_free_space_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvMemStoragePos_base_names[] = {0}; +static const swig_type_info *swig_CvMemStoragePos_base[] = {0}; +static swig_octave_class _wrap_class_CvMemStoragePos = {"CvMemStoragePos", &SWIGTYPE_p_CvMemStoragePos,0,_wrap_new_CvMemStoragePos,0,_wrap_delete_CvMemStoragePos,swig_CvMemStoragePos_members,swig_CvMemStoragePos_base_names,swig_CvMemStoragePos_base }; + +static octave_value_list _wrap_CvSeqBlock_prev_set (const octave_value_list& args, int nargout) { + CvSeqBlock *arg1 = (CvSeqBlock *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 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("CvSeqBlock_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_prev_set" "', argument " "1"" of type '" "CvSeqBlock *""'"); + } + arg1 = (CvSeqBlock *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqBlock_prev_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(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_CvSeqBlock_prev_get (const octave_value_list& args, int nargout) { + CvSeqBlock *arg1 = (CvSeqBlock *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvSeqBlock_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_prev_get" "', argument " "1"" of type '" "CvSeqBlock *""'"); + } + arg1 = (CvSeqBlock *)(argp1); + result = (CvSeqBlock *) ((arg1)->prev); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqBlock_next_set (const octave_value_list& args, int nargout) { + CvSeqBlock *arg1 = (CvSeqBlock *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 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("CvSeqBlock_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_next_set" "', argument " "1"" of type '" "CvSeqBlock *""'"); + } + arg1 = (CvSeqBlock *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqBlock_next_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(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_CvSeqBlock_next_get (const octave_value_list& args, int nargout) { + CvSeqBlock *arg1 = (CvSeqBlock *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvSeqBlock_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_next_get" "', argument " "1"" of type '" "CvSeqBlock *""'"); + } + arg1 = (CvSeqBlock *)(argp1); + result = (CvSeqBlock *) ((arg1)->next); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqBlock_start_index_set (const octave_value_list& args, int nargout) { + CvSeqBlock *arg1 = (CvSeqBlock *) 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("CvSeqBlock_start_index_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_start_index_set" "', argument " "1"" of type '" "CvSeqBlock *""'"); + } + arg1 = (CvSeqBlock *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeqBlock_start_index_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->start_index = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqBlock_start_index_get (const octave_value_list& args, int nargout) { + CvSeqBlock *arg1 = (CvSeqBlock *) 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("CvSeqBlock_start_index_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_start_index_get" "', argument " "1"" of type '" "CvSeqBlock *""'"); + } + arg1 = (CvSeqBlock *)(argp1); + result = (int) ((arg1)->start_index); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqBlock_count_set (const octave_value_list& args, int nargout) { + CvSeqBlock *arg1 = (CvSeqBlock *) 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("CvSeqBlock_count_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_count_set" "', argument " "1"" of type '" "CvSeqBlock *""'"); + } + arg1 = (CvSeqBlock *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeqBlock_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_CvSeqBlock_count_get (const octave_value_list& args, int nargout) { + CvSeqBlock *arg1 = (CvSeqBlock *) 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("CvSeqBlock_count_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_count_get" "', argument " "1"" of type '" "CvSeqBlock *""'"); + } + arg1 = (CvSeqBlock *)(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_CvSeqBlock_data_set (const octave_value_list& args, int nargout) { + CvSeqBlock *arg1 = (CvSeqBlock *) 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("CvSeqBlock_data_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_data_set" "', argument " "1"" of type '" "CvSeqBlock *""'"); + } + arg1 = (CvSeqBlock *)(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 '" "CvSeqBlock_data_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(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_CvSeqBlock_data_get (const octave_value_list& args, int nargout) { + CvSeqBlock *arg1 = (CvSeqBlock *) 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("CvSeqBlock_data_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqBlock_data_get" "', argument " "1"" of type '" "CvSeqBlock *""'"); + } + arg1 = (CvSeqBlock *)(argp1); + result = (schar *) ((arg1)->data); + _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_new_CvSeqBlock (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("new_CvSeqBlock",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSeqBlock *)new CvSeqBlock(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSeqBlock (const octave_value_list& args, int nargout) { + CvSeqBlock *arg1 = (CvSeqBlock *) 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_CvSeqBlock",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeqBlock" "', argument " "1"" of type '" "CvSeqBlock *""'"); + } + arg1 = (CvSeqBlock *)(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_CvSeqBlock_members[] = { +{"prev",0,_wrap_CvSeqBlock_prev_get,_wrap_CvSeqBlock_prev_set,0,0}, +{"next",0,_wrap_CvSeqBlock_next_get,_wrap_CvSeqBlock_next_set,0,0}, +{"start_index",0,_wrap_CvSeqBlock_start_index_get,_wrap_CvSeqBlock_start_index_set,0,0}, +{"count",0,_wrap_CvSeqBlock_count_get,_wrap_CvSeqBlock_count_set,0,0}, +{"data",0,_wrap_CvSeqBlock_data_get,_wrap_CvSeqBlock_data_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSeqBlock_base_names[] = {0}; +static const swig_type_info *swig_CvSeqBlock_base[] = {0}; +static swig_octave_class _wrap_class_CvSeqBlock = {"CvSeqBlock", &SWIGTYPE_p_CvSeqBlock,0,_wrap_new_CvSeqBlock,0,_wrap_delete_CvSeqBlock,swig_CvSeqBlock_members,swig_CvSeqBlock_base_names,swig_CvSeqBlock_base }; + +static octave_value_list _wrap_CvSeq_flags_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_flags_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvSeq_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_header_size_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_header_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_header_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->header_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_header_size_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvSeq_header_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int) ((arg1)->header_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_CvSeq_h_prev_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + CvSeq *arg2 = (CvSeq *) 0 ; + void *ptr1 ; + void *ptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_h_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_h_prev_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_h_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (CvSeq *) ((arg1)->h_prev); + _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_CvSeq_h_next_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + CvSeq *arg2 = (CvSeq *) 0 ; + void *ptr1 ; + void *ptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_h_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_h_next_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_h_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (CvSeq *) ((arg1)->h_next); + _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_CvSeq_v_prev_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + CvSeq *arg2 = (CvSeq *) 0 ; + void *ptr1 ; + void *ptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_v_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_v_prev_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_v_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (CvSeq *) ((arg1)->v_prev); + _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_CvSeq_v_next_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + CvSeq *arg2 = (CvSeq *) 0 ; + void *ptr1 ; + void *ptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_v_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_v_next_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_v_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (CvSeq *) ((arg1)->v_next); + _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_CvSeq_total_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_total_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_total_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->total = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_total_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvSeq_total_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int) ((arg1)->total); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_elem_size_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_elem_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_elem_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->elem_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_elem_size_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvSeq_elem_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int) ((arg1)->elem_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_CvSeq_block_max_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + schar *arg2 = (schar *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_block_max_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + 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 '" "CvSeq_block_max_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->block_max = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_block_max_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + schar *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_block_max_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (schar *) ((arg1)->block_max); + _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_CvSeq_ptr_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + schar *arg2 = (schar *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + 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 '" "CvSeq_ptr_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(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_CvSeq_ptr_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + schar *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (schar *) ((arg1)->ptr); + _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_CvSeq_delta_elems_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_delta_elems_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_delta_elems_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->delta_elems = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_delta_elems_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvSeq_delta_elems_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (int) ((arg1)->delta_elems); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_storage_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + CvMemStorage *arg2 = (CvMemStorage *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_storage_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + 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 '" "CvSeq_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_CvSeq_storage_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMemStorage *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_storage_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + 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_CvSeq_free_blocks_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_free_blocks_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->free_blocks = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_free_blocks_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_free_blocks_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (CvSeqBlock *) ((arg1)->free_blocks); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_first_set (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_first_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->first = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_first_get (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_first_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + result = (CvSeqBlock *) ((arg1)->first); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSeq (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("new_CvSeq",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSeq *)new CvSeq(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeq, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSeq (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("delete_CvSeq",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + 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_CvSeq_members[] = { +{"flags",0,_wrap_CvSeq_flags_get,_wrap_CvSeq_flags_set,0,0}, +{"header_size",0,_wrap_CvSeq_header_size_get,_wrap_CvSeq_header_size_set,0,0}, +{"h_prev",0,_wrap_CvSeq_h_prev_get,_wrap_CvSeq_h_prev_set,0,0}, +{"h_next",0,_wrap_CvSeq_h_next_get,_wrap_CvSeq_h_next_set,0,0}, +{"v_prev",0,_wrap_CvSeq_v_prev_get,_wrap_CvSeq_v_prev_set,0,0}, +{"v_next",0,_wrap_CvSeq_v_next_get,_wrap_CvSeq_v_next_set,0,0}, +{"total",0,_wrap_CvSeq_total_get,_wrap_CvSeq_total_set,0,0}, +{"elem_size",0,_wrap_CvSeq_elem_size_get,_wrap_CvSeq_elem_size_set,0,0}, +{"block_max",0,_wrap_CvSeq_block_max_get,_wrap_CvSeq_block_max_set,0,0}, +{"ptr",0,_wrap_CvSeq_ptr_get,_wrap_CvSeq_ptr_set,0,0}, +{"delta_elems",0,_wrap_CvSeq_delta_elems_get,_wrap_CvSeq_delta_elems_set,0,0}, +{"storage",0,_wrap_CvSeq_storage_get,_wrap_CvSeq_storage_set,0,0}, +{"free_blocks",0,_wrap_CvSeq_free_blocks_get,_wrap_CvSeq_free_blocks_set,0,0}, +{"first",0,_wrap_CvSeq_first_get,_wrap_CvSeq_first_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSeq_base_names[] = {0}; +static const swig_type_info *swig_CvSeq_base[] = {0}; +static swig_octave_class _wrap_class_CvSeq = {"CvSeq", &SWIGTYPE_p_CvSeq,0,_wrap_new_CvSeq,0,_wrap_delete_CvSeq,swig_CvSeq_members,swig_CvSeq_base_names,swig_CvSeq_base }; + +static octave_value_list _wrap_CvSetElem_flags_set (const octave_value_list& args, int nargout) { + CvSetElem *arg1 = (CvSetElem *) 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("CvSetElem_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSetElem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSetElem_flags_set" "', argument " "1"" of type '" "CvSetElem *""'"); + } + arg1 = (CvSetElem *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSetElem_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSetElem_flags_get (const octave_value_list& args, int nargout) { + CvSetElem *arg1 = (CvSetElem *) 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("CvSetElem_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSetElem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSetElem_flags_get" "', argument " "1"" of type '" "CvSetElem *""'"); + } + arg1 = (CvSetElem *)(argp1); + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSetElem_next_free_set (const octave_value_list& args, int nargout) { + CvSetElem *arg1 = (CvSetElem *) 0 ; + CvSetElem *arg2 = (CvSetElem *) 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("CvSetElem_next_free_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSetElem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSetElem_next_free_set" "', argument " "1"" of type '" "CvSetElem *""'"); + } + arg1 = (CvSetElem *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSetElem, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSetElem_next_free_set" "', argument " "2"" of type '" "CvSetElem *""'"); + } + arg2 = (CvSetElem *)(argp2); + if (arg1) (arg1)->next_free = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSetElem_next_free_get (const octave_value_list& args, int nargout) { + CvSetElem *arg1 = (CvSetElem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSetElem *result = 0 ; + + if (!SWIG_check_num_args("CvSetElem_next_free_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSetElem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSetElem_next_free_get" "', argument " "1"" of type '" "CvSetElem *""'"); + } + arg1 = (CvSetElem *)(argp1); + result = (CvSetElem *) ((arg1)->next_free); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSetElem, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSetElem (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSetElem *result = 0 ; + + if (!SWIG_check_num_args("new_CvSetElem",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSetElem *)new CvSetElem(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSetElem, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSetElem (const octave_value_list& args, int nargout) { + CvSetElem *arg1 = (CvSetElem *) 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_CvSetElem",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSetElem, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSetElem" "', argument " "1"" of type '" "CvSetElem *""'"); + } + arg1 = (CvSetElem *)(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_CvSetElem_members[] = { +{"flags",0,_wrap_CvSetElem_flags_get,_wrap_CvSetElem_flags_set,0,0}, +{"next_free",0,_wrap_CvSetElem_next_free_get,_wrap_CvSetElem_next_free_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSetElem_base_names[] = {0}; +static const swig_type_info *swig_CvSetElem_base[] = {0}; +static swig_octave_class _wrap_class_CvSetElem = {"CvSetElem", &SWIGTYPE_p_CvSetElem,0,_wrap_new_CvSetElem,0,_wrap_delete_CvSetElem,swig_CvSetElem_members,swig_CvSetElem_base_names,swig_CvSetElem_base }; + +static octave_value_list _wrap_CvSet_flags_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSet_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_flags_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvSet_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_header_size_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_header_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSet_header_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->header_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_header_size_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvSet_header_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (int) ((arg1)->header_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_CvSet_h_prev_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + CvSeq *arg2 = (CvSeq *) 0 ; + void *ptr1 ; + void *ptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_h_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_h_prev_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("CvSet_h_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (CvSeq *) ((arg1)->h_prev); + _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_CvSet_h_next_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + CvSeq *arg2 = (CvSeq *) 0 ; + void *ptr1 ; + void *ptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_h_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_h_next_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("CvSet_h_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (CvSeq *) ((arg1)->h_next); + _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_CvSet_v_prev_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + CvSeq *arg2 = (CvSeq *) 0 ; + void *ptr1 ; + void *ptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_v_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_v_prev_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("CvSet_v_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (CvSeq *) ((arg1)->v_prev); + _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_CvSet_v_next_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + CvSeq *arg2 = (CvSeq *) 0 ; + void *ptr1 ; + void *ptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_v_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_v_next_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("CvSet_v_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (CvSeq *) ((arg1)->v_next); + _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_CvSet_total_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_total_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSet_total_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->total = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_total_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvSet_total_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (int) ((arg1)->total); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_elem_size_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_elem_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSet_elem_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->elem_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_elem_size_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvSet_elem_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (int) ((arg1)->elem_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_CvSet_block_max_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + schar *arg2 = (schar *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_block_max_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + 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 '" "CvSet_block_max_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->block_max = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_block_max_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + schar *result = 0 ; + + if (!SWIG_check_num_args("CvSet_block_max_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (schar *) ((arg1)->block_max); + _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_CvSet_ptr_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + schar *arg2 = (schar *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + 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 '" "CvSet_ptr_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(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_CvSet_ptr_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + schar *result = 0 ; + + if (!SWIG_check_num_args("CvSet_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (schar *) ((arg1)->ptr); + _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_CvSet_delta_elems_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_delta_elems_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSet_delta_elems_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->delta_elems = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_delta_elems_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvSet_delta_elems_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (int) ((arg1)->delta_elems); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_storage_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + CvMemStorage *arg2 = (CvMemStorage *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_storage_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + 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 '" "CvSet_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_CvSet_storage_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMemStorage *result = 0 ; + + if (!SWIG_check_num_args("CvSet_storage_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + 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_CvSet_free_blocks_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_free_blocks_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSet_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->free_blocks = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_free_blocks_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvSet_free_blocks_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (CvSeqBlock *) ((arg1)->free_blocks); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_first_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_first_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSet_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->first = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_first_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvSet_first_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (CvSeqBlock *) ((arg1)->first); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_free_elems_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + CvSetElem *arg2 = (CvSetElem *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_free_elems_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSetElem, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSet_free_elems_set" "', argument " "2"" of type '" "CvSetElem *""'"); + } + arg2 = (CvSetElem *)(argp2); + if (arg1) (arg1)->free_elems = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_free_elems_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSetElem *result = 0 ; + + if (!SWIG_check_num_args("CvSet_free_elems_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (CvSetElem *) ((arg1)->free_elems); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSetElem, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_active_count_set (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSet_active_count_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSet_active_count_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->active_count = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSet_active_count_get (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvSet_active_count_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + result = (int) ((arg1)->active_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_new_CvSet (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSet *result = 0 ; + + if (!SWIG_check_num_args("new_CvSet",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSet *)new CvSet(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSet, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSet (const octave_value_list& args, int nargout) { + CvSet *arg1 = (CvSet *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("delete_CvSet",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSet"); + SWIG_fail; + } + arg1 = (CvSet *)ptr1; + } + { + 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_CvSet_members[] = { +{"flags",0,_wrap_CvSet_flags_get,_wrap_CvSet_flags_set,0,0}, +{"header_size",0,_wrap_CvSet_header_size_get,_wrap_CvSet_header_size_set,0,0}, +{"h_prev",0,_wrap_CvSet_h_prev_get,_wrap_CvSet_h_prev_set,0,0}, +{"h_next",0,_wrap_CvSet_h_next_get,_wrap_CvSet_h_next_set,0,0}, +{"v_prev",0,_wrap_CvSet_v_prev_get,_wrap_CvSet_v_prev_set,0,0}, +{"v_next",0,_wrap_CvSet_v_next_get,_wrap_CvSet_v_next_set,0,0}, +{"total",0,_wrap_CvSet_total_get,_wrap_CvSet_total_set,0,0}, +{"elem_size",0,_wrap_CvSet_elem_size_get,_wrap_CvSet_elem_size_set,0,0}, +{"block_max",0,_wrap_CvSet_block_max_get,_wrap_CvSet_block_max_set,0,0}, +{"ptr",0,_wrap_CvSet_ptr_get,_wrap_CvSet_ptr_set,0,0}, +{"delta_elems",0,_wrap_CvSet_delta_elems_get,_wrap_CvSet_delta_elems_set,0,0}, +{"storage",0,_wrap_CvSet_storage_get,_wrap_CvSet_storage_set,0,0}, +{"free_blocks",0,_wrap_CvSet_free_blocks_get,_wrap_CvSet_free_blocks_set,0,0}, +{"first",0,_wrap_CvSet_first_get,_wrap_CvSet_first_set,0,0}, +{"free_elems",0,_wrap_CvSet_free_elems_get,_wrap_CvSet_free_elems_set,0,0}, +{"active_count",0,_wrap_CvSet_active_count_get,_wrap_CvSet_active_count_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSet_base_names[] = {0}; +static const swig_type_info *swig_CvSet_base[] = {0}; +static swig_octave_class _wrap_class_CvSet = {"CvSet", &SWIGTYPE_p_CvSet,0,_wrap_new_CvSet,0,_wrap_delete_CvSet,swig_CvSet_members,swig_CvSet_base_names,swig_CvSet_base }; + +static octave_value_list _wrap_CvGraphEdge_flags_set (const octave_value_list& args, int nargout) { + CvGraphEdge *arg1 = (CvGraphEdge *) 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("CvGraphEdge_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_flags_set" "', argument " "1"" of type '" "CvGraphEdge *""'"); + } + arg1 = (CvGraphEdge *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraphEdge_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphEdge_flags_get (const octave_value_list& args, int nargout) { + CvGraphEdge *arg1 = (CvGraphEdge *) 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("CvGraphEdge_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_flags_get" "', argument " "1"" of type '" "CvGraphEdge *""'"); + } + arg1 = (CvGraphEdge *)(argp1); + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphEdge_weight_set (const octave_value_list& args, int nargout) { + CvGraphEdge *arg1 = (CvGraphEdge *) 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("CvGraphEdge_weight_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_weight_set" "', argument " "1"" of type '" "CvGraphEdge *""'"); + } + arg1 = (CvGraphEdge *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraphEdge_weight_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->weight = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphEdge_weight_get (const octave_value_list& args, int nargout) { + CvGraphEdge *arg1 = (CvGraphEdge *) 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("CvGraphEdge_weight_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_weight_get" "', argument " "1"" of type '" "CvGraphEdge *""'"); + } + arg1 = (CvGraphEdge *)(argp1); + result = (float) ((arg1)->weight); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphEdge_next_set (const octave_value_list& args, int nargout) { + CvGraphEdge *arg1 = (CvGraphEdge *) 0 ; + CvGraphEdge **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("CvGraphEdge_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_next_set" "', argument " "1"" of type '" "CvGraphEdge *""'"); + } + arg1 = (CvGraphEdge *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_CvGraphEdge, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphEdge_next_set" "', argument " "2"" of type '" "CvGraphEdge *[2]""'"); + } + arg2 = (CvGraphEdge **)(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)2; ++ii) arg1->next[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""next""' of type '""CvGraphEdge *[2]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphEdge_next_get (const octave_value_list& args, int nargout) { + CvGraphEdge *arg1 = (CvGraphEdge *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvGraphEdge **result = 0 ; + + if (!SWIG_check_num_args("CvGraphEdge_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_next_get" "', argument " "1"" of type '" "CvGraphEdge *""'"); + } + arg1 = (CvGraphEdge *)(argp1); + result = (CvGraphEdge **)(CvGraphEdge **) ((arg1)->next); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvGraphEdge, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphEdge_vtx_set (const octave_value_list& args, int nargout) { + CvGraphEdge *arg1 = (CvGraphEdge *) 0 ; + CvGraphVtx **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("CvGraphEdge_vtx_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_vtx_set" "', argument " "1"" of type '" "CvGraphEdge *""'"); + } + arg1 = (CvGraphEdge *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_CvGraphVtx, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphEdge_vtx_set" "', argument " "2"" of type '" "CvGraphVtx *[2]""'"); + } + arg2 = (CvGraphVtx **)(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)2; ++ii) arg1->vtx[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""vtx""' of type '""CvGraphVtx *[2]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphEdge_vtx_get (const octave_value_list& args, int nargout) { + CvGraphEdge *arg1 = (CvGraphEdge *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvGraphVtx **result = 0 ; + + if (!SWIG_check_num_args("CvGraphEdge_vtx_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphEdge_vtx_get" "', argument " "1"" of type '" "CvGraphEdge *""'"); + } + arg1 = (CvGraphEdge *)(argp1); + result = (CvGraphVtx **)(CvGraphVtx **) ((arg1)->vtx); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvGraphVtx, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvGraphEdge (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvGraphEdge *result = 0 ; + + if (!SWIG_check_num_args("new_CvGraphEdge",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvGraphEdge *)new CvGraphEdge(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphEdge, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvGraphEdge (const octave_value_list& args, int nargout) { + CvGraphEdge *arg1 = (CvGraphEdge *) 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_CvGraphEdge",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphEdge, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvGraphEdge" "', argument " "1"" of type '" "CvGraphEdge *""'"); + } + arg1 = (CvGraphEdge *)(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_CvGraphEdge_members[] = { +{"flags",0,_wrap_CvGraphEdge_flags_get,_wrap_CvGraphEdge_flags_set,0,0}, +{"weight",0,_wrap_CvGraphEdge_weight_get,_wrap_CvGraphEdge_weight_set,0,0}, +{"next",0,_wrap_CvGraphEdge_next_get,_wrap_CvGraphEdge_next_set,0,0}, +{"vtx",0,_wrap_CvGraphEdge_vtx_get,_wrap_CvGraphEdge_vtx_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvGraphEdge_base_names[] = {0}; +static const swig_type_info *swig_CvGraphEdge_base[] = {0}; +static swig_octave_class _wrap_class_CvGraphEdge = {"CvGraphEdge", &SWIGTYPE_p_CvGraphEdge,0,_wrap_new_CvGraphEdge,0,_wrap_delete_CvGraphEdge,swig_CvGraphEdge_members,swig_CvGraphEdge_base_names,swig_CvGraphEdge_base }; + +static octave_value_list _wrap_CvGraphVtx_flags_set (const octave_value_list& args, int nargout) { + CvGraphVtx *arg1 = (CvGraphVtx *) 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("CvGraphVtx_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphVtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx_flags_set" "', argument " "1"" of type '" "CvGraphVtx *""'"); + } + arg1 = (CvGraphVtx *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraphVtx_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphVtx_flags_get (const octave_value_list& args, int nargout) { + CvGraphVtx *arg1 = (CvGraphVtx *) 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("CvGraphVtx_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphVtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx_flags_get" "', argument " "1"" of type '" "CvGraphVtx *""'"); + } + arg1 = (CvGraphVtx *)(argp1); + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphVtx_first_set (const octave_value_list& args, int nargout) { + CvGraphVtx *arg1 = (CvGraphVtx *) 0 ; + CvGraphEdge *arg2 = (CvGraphEdge *) 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("CvGraphVtx_first_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphVtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx_first_set" "', argument " "1"" of type '" "CvGraphVtx *""'"); + } + arg1 = (CvGraphVtx *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvGraphEdge, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphVtx_first_set" "', argument " "2"" of type '" "CvGraphEdge *""'"); + } + arg2 = (CvGraphEdge *)(argp2); + if (arg1) (arg1)->first = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphVtx_first_get (const octave_value_list& args, int nargout) { + CvGraphVtx *arg1 = (CvGraphVtx *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvGraphEdge *result = 0 ; + + if (!SWIG_check_num_args("CvGraphVtx_first_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphVtx, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx_first_get" "', argument " "1"" of type '" "CvGraphVtx *""'"); + } + arg1 = (CvGraphVtx *)(argp1); + result = (CvGraphEdge *) ((arg1)->first); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvGraphVtx (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvGraphVtx *result = 0 ; + + if (!SWIG_check_num_args("new_CvGraphVtx",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvGraphVtx *)new CvGraphVtx(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphVtx, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvGraphVtx (const octave_value_list& args, int nargout) { + CvGraphVtx *arg1 = (CvGraphVtx *) 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_CvGraphVtx",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphVtx, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvGraphVtx" "', argument " "1"" of type '" "CvGraphVtx *""'"); + } + arg1 = (CvGraphVtx *)(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_CvGraphVtx_members[] = { +{"flags",0,_wrap_CvGraphVtx_flags_get,_wrap_CvGraphVtx_flags_set,0,0}, +{"first",0,_wrap_CvGraphVtx_first_get,_wrap_CvGraphVtx_first_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvGraphVtx_base_names[] = {0}; +static const swig_type_info *swig_CvGraphVtx_base[] = {0}; +static swig_octave_class _wrap_class_CvGraphVtx = {"CvGraphVtx", &SWIGTYPE_p_CvGraphVtx,0,_wrap_new_CvGraphVtx,0,_wrap_delete_CvGraphVtx,swig_CvGraphVtx_members,swig_CvGraphVtx_base_names,swig_CvGraphVtx_base }; + +static octave_value_list _wrap_CvGraphVtx2D_flags_set (const octave_value_list& args, int nargout) { + CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 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("CvGraphVtx2D_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphVtx2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx2D_flags_set" "', argument " "1"" of type '" "CvGraphVtx2D *""'"); + } + arg1 = (CvGraphVtx2D *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraphVtx2D_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphVtx2D_flags_get (const octave_value_list& args, int nargout) { + CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 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("CvGraphVtx2D_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphVtx2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx2D_flags_get" "', argument " "1"" of type '" "CvGraphVtx2D *""'"); + } + arg1 = (CvGraphVtx2D *)(argp1); + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphVtx2D_first_set (const octave_value_list& args, int nargout) { + CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 0 ; + CvGraphEdge *arg2 = (CvGraphEdge *) 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("CvGraphVtx2D_first_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphVtx2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx2D_first_set" "', argument " "1"" of type '" "CvGraphVtx2D *""'"); + } + arg1 = (CvGraphVtx2D *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvGraphEdge, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphVtx2D_first_set" "', argument " "2"" of type '" "CvGraphEdge *""'"); + } + arg2 = (CvGraphEdge *)(argp2); + if (arg1) (arg1)->first = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphVtx2D_first_get (const octave_value_list& args, int nargout) { + CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvGraphEdge *result = 0 ; + + if (!SWIG_check_num_args("CvGraphVtx2D_first_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphVtx2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx2D_first_get" "', argument " "1"" of type '" "CvGraphVtx2D *""'"); + } + arg1 = (CvGraphVtx2D *)(argp1); + result = (CvGraphEdge *) ((arg1)->first); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphVtx2D_ptr_set (const octave_value_list& args, int nargout) { + CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 0 ; + CvPoint2D32f *arg2 = (CvPoint2D32f *) 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("CvGraphVtx2D_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphVtx2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx2D_ptr_set" "', argument " "1"" of type '" "CvGraphVtx2D *""'"); + } + arg1 = (CvGraphVtx2D *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint2D32f, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphVtx2D_ptr_set" "', argument " "2"" of type '" "CvPoint2D32f *""'"); + } + arg2 = (CvPoint2D32f *)(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_CvGraphVtx2D_ptr_get (const octave_value_list& args, int nargout) { + CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint2D32f *result = 0 ; + + if (!SWIG_check_num_args("CvGraphVtx2D_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphVtx2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphVtx2D_ptr_get" "', argument " "1"" of type '" "CvGraphVtx2D *""'"); + } + arg1 = (CvGraphVtx2D *)(argp1); + result = (CvPoint2D32f *) ((arg1)->ptr); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvGraphVtx2D (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvGraphVtx2D *result = 0 ; + + if (!SWIG_check_num_args("new_CvGraphVtx2D",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvGraphVtx2D *)new CvGraphVtx2D(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphVtx2D, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvGraphVtx2D (const octave_value_list& args, int nargout) { + CvGraphVtx2D *arg1 = (CvGraphVtx2D *) 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_CvGraphVtx2D",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphVtx2D, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvGraphVtx2D" "', argument " "1"" of type '" "CvGraphVtx2D *""'"); + } + arg1 = (CvGraphVtx2D *)(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_CvGraphVtx2D_members[] = { +{"flags",0,_wrap_CvGraphVtx2D_flags_get,_wrap_CvGraphVtx2D_flags_set,0,0}, +{"first",0,_wrap_CvGraphVtx2D_first_get,_wrap_CvGraphVtx2D_first_set,0,0}, +{"ptr",0,_wrap_CvGraphVtx2D_ptr_get,_wrap_CvGraphVtx2D_ptr_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvGraphVtx2D_base_names[] = {0}; +static const swig_type_info *swig_CvGraphVtx2D_base[] = {0}; +static swig_octave_class _wrap_class_CvGraphVtx2D = {"CvGraphVtx2D", &SWIGTYPE_p_CvGraphVtx2D,0,_wrap_new_CvGraphVtx2D,0,_wrap_delete_CvGraphVtx2D,swig_CvGraphVtx2D_members,swig_CvGraphVtx2D_base_names,swig_CvGraphVtx2D_base }; + +static octave_value_list _wrap_CvGraph_flags_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraph_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_flags_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvGraph_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_header_size_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_header_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraph_header_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->header_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_header_size_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvGraph_header_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (int) ((arg1)->header_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_CvGraph_h_prev_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + CvSeq *arg2 = (CvSeq *) 0 ; + void *ptr1 ; + void *ptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_h_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_h_prev_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("CvGraph_h_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (CvSeq *) ((arg1)->h_prev); + _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_CvGraph_h_next_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + CvSeq *arg2 = (CvSeq *) 0 ; + void *ptr1 ; + void *ptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_h_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_h_next_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("CvGraph_h_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (CvSeq *) ((arg1)->h_next); + _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_CvGraph_v_prev_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + CvSeq *arg2 = (CvSeq *) 0 ; + void *ptr1 ; + void *ptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_v_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_v_prev_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("CvGraph_v_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (CvSeq *) ((arg1)->v_prev); + _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_CvGraph_v_next_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + CvSeq *arg2 = (CvSeq *) 0 ; + void *ptr1 ; + void *ptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_v_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_v_next_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("CvGraph_v_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (CvSeq *) ((arg1)->v_next); + _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_CvGraph_total_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_total_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraph_total_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->total = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_total_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvGraph_total_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (int) ((arg1)->total); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_elem_size_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_elem_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraph_elem_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->elem_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_elem_size_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvGraph_elem_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (int) ((arg1)->elem_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_CvGraph_block_max_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + schar *arg2 = (schar *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_block_max_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + 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 '" "CvGraph_block_max_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->block_max = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_block_max_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + schar *result = 0 ; + + if (!SWIG_check_num_args("CvGraph_block_max_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (schar *) ((arg1)->block_max); + _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_CvGraph_ptr_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + schar *arg2 = (schar *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + 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 '" "CvGraph_ptr_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(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_CvGraph_ptr_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + schar *result = 0 ; + + if (!SWIG_check_num_args("CvGraph_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (schar *) ((arg1)->ptr); + _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_CvGraph_delta_elems_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_delta_elems_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraph_delta_elems_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->delta_elems = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_delta_elems_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvGraph_delta_elems_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (int) ((arg1)->delta_elems); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_storage_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + CvMemStorage *arg2 = (CvMemStorage *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_storage_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + 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 '" "CvGraph_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_CvGraph_storage_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMemStorage *result = 0 ; + + if (!SWIG_check_num_args("CvGraph_storage_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + 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_CvGraph_free_blocks_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_free_blocks_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraph_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->free_blocks = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_free_blocks_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvGraph_free_blocks_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (CvSeqBlock *) ((arg1)->free_blocks); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_first_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_first_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraph_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->first = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_first_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvGraph_first_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (CvSeqBlock *) ((arg1)->first); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_free_elems_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + CvSetElem *arg2 = (CvSetElem *) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_free_elems_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSetElem, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraph_free_elems_set" "', argument " "2"" of type '" "CvSetElem *""'"); + } + arg2 = (CvSetElem *)(argp2); + if (arg1) (arg1)->free_elems = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_free_elems_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSetElem *result = 0 ; + + if (!SWIG_check_num_args("CvGraph_free_elems_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (CvSetElem *) ((arg1)->free_elems); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSetElem, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_active_count_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + int arg2 ; + void *ptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_active_count_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraph_active_count_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->active_count = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_active_count_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("CvGraph_active_count_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (int) ((arg1)->active_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_CvGraph_edges_set (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + CvSet *arg2 = (CvSet *) 0 ; + void *ptr1 ; + void *ptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvGraph_edges_set",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + { + 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)->edges = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraph_edges_get (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSet *result = 0 ; + + if (!SWIG_check_num_args("CvGraph_edges_get",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + result = (CvSet *) ((arg1)->edges); + _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_new_CvGraph (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvGraph *result = 0 ; + + if (!SWIG_check_num_args("new_CvGraph",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvGraph *)new CvGraph(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraph, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvGraph (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("delete_CvGraph",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + { + 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_CvGraph_members[] = { +{"flags",0,_wrap_CvGraph_flags_get,_wrap_CvGraph_flags_set,0,0}, +{"header_size",0,_wrap_CvGraph_header_size_get,_wrap_CvGraph_header_size_set,0,0}, +{"h_prev",0,_wrap_CvGraph_h_prev_get,_wrap_CvGraph_h_prev_set,0,0}, +{"h_next",0,_wrap_CvGraph_h_next_get,_wrap_CvGraph_h_next_set,0,0}, +{"v_prev",0,_wrap_CvGraph_v_prev_get,_wrap_CvGraph_v_prev_set,0,0}, +{"v_next",0,_wrap_CvGraph_v_next_get,_wrap_CvGraph_v_next_set,0,0}, +{"total",0,_wrap_CvGraph_total_get,_wrap_CvGraph_total_set,0,0}, +{"elem_size",0,_wrap_CvGraph_elem_size_get,_wrap_CvGraph_elem_size_set,0,0}, +{"block_max",0,_wrap_CvGraph_block_max_get,_wrap_CvGraph_block_max_set,0,0}, +{"ptr",0,_wrap_CvGraph_ptr_get,_wrap_CvGraph_ptr_set,0,0}, +{"delta_elems",0,_wrap_CvGraph_delta_elems_get,_wrap_CvGraph_delta_elems_set,0,0}, +{"storage",0,_wrap_CvGraph_storage_get,_wrap_CvGraph_storage_set,0,0}, +{"free_blocks",0,_wrap_CvGraph_free_blocks_get,_wrap_CvGraph_free_blocks_set,0,0}, +{"first",0,_wrap_CvGraph_first_get,_wrap_CvGraph_first_set,0,0}, +{"free_elems",0,_wrap_CvGraph_free_elems_get,_wrap_CvGraph_free_elems_set,0,0}, +{"active_count",0,_wrap_CvGraph_active_count_get,_wrap_CvGraph_active_count_set,0,0}, +{"edges",0,_wrap_CvGraph_edges_get,_wrap_CvGraph_edges_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvGraph_base_names[] = {0}; +static const swig_type_info *swig_CvGraph_base[] = {0}; +static swig_octave_class _wrap_class_CvGraph = {"CvGraph", &SWIGTYPE_p_CvGraph,0,_wrap_new_CvGraph,0,_wrap_delete_CvGraph,swig_CvGraph_members,swig_CvGraph_base_names,swig_CvGraph_base }; + +static octave_value_list _wrap_CvChain_flags_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_flags_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChain_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_flags_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_flags_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_header_size_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_header_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_header_size_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChain_header_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->header_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_header_size_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_header_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_header_size_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (int) ((arg1)->header_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_CvChain_h_prev_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvChain_h_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_h_prev_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_h_prev_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_h_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_h_prev_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (CvSeq *) ((arg1)->h_prev); + _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_CvChain_h_next_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvChain_h_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_h_next_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_h_next_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_h_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_h_next_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (CvSeq *) ((arg1)->h_next); + _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_CvChain_v_prev_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvChain_v_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_v_prev_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_v_prev_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_v_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_v_prev_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (CvSeq *) ((arg1)->v_prev); + _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_CvChain_v_next_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvChain_v_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_v_next_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_v_next_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_v_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_v_next_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (CvSeq *) ((arg1)->v_next); + _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_CvChain_total_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_total_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_total_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChain_total_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->total = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_total_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_total_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_total_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (int) ((arg1)->total); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_elem_size_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_elem_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_elem_size_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChain_elem_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->elem_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_elem_size_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_elem_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_elem_size_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (int) ((arg1)->elem_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_CvChain_block_max_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_block_max_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_block_max_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(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 '" "CvChain_block_max_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->block_max = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_block_max_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_block_max_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_block_max_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (schar *) ((arg1)->block_max); + _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_CvChain_ptr_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_ptr_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(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 '" "CvChain_ptr_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(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_CvChain_ptr_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_ptr_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (schar *) ((arg1)->ptr); + _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_CvChain_delta_elems_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_delta_elems_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_delta_elems_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChain_delta_elems_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->delta_elems = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_delta_elems_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_delta_elems_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_delta_elems_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (int) ((arg1)->delta_elems); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_storage_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_storage_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_storage_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(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 '" "CvChain_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_CvChain_storage_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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("CvChain_storage_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_storage_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(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_CvChain_free_blocks_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 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("CvChain_free_blocks_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_free_blocks_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChain_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->free_blocks = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_free_blocks_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvChain_free_blocks_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_free_blocks_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (CvSeqBlock *) ((arg1)->free_blocks); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_first_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 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("CvChain_first_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_first_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChain_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->first = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_first_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvChain_first_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_first_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (CvSeqBlock *) ((arg1)->first); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_origin_set (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 0 ; + CvPoint *arg2 = (CvPoint *) 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("CvChain_origin_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_origin_set" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChain_origin_set" "', argument " "2"" of type '" "CvPoint *""'"); + } + arg2 = (CvPoint *)(argp2); + if (arg1) (arg1)->origin = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChain_origin_get (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvChain_origin_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChain_origin_get" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(argp1); + result = (CvPoint *)& ((arg1)->origin); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvChain (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvChain *result = 0 ; + + if (!SWIG_check_num_args("new_CvChain",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvChain *)new CvChain(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvChain, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvChain (const octave_value_list& args, int nargout) { + CvChain *arg1 = (CvChain *) 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_CvChain",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChain, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvChain" "', argument " "1"" of type '" "CvChain *""'"); + } + arg1 = (CvChain *)(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_CvChain_members[] = { +{"flags",0,_wrap_CvChain_flags_get,_wrap_CvChain_flags_set,0,0}, +{"header_size",0,_wrap_CvChain_header_size_get,_wrap_CvChain_header_size_set,0,0}, +{"h_prev",0,_wrap_CvChain_h_prev_get,_wrap_CvChain_h_prev_set,0,0}, +{"h_next",0,_wrap_CvChain_h_next_get,_wrap_CvChain_h_next_set,0,0}, +{"v_prev",0,_wrap_CvChain_v_prev_get,_wrap_CvChain_v_prev_set,0,0}, +{"v_next",0,_wrap_CvChain_v_next_get,_wrap_CvChain_v_next_set,0,0}, +{"total",0,_wrap_CvChain_total_get,_wrap_CvChain_total_set,0,0}, +{"elem_size",0,_wrap_CvChain_elem_size_get,_wrap_CvChain_elem_size_set,0,0}, +{"block_max",0,_wrap_CvChain_block_max_get,_wrap_CvChain_block_max_set,0,0}, +{"ptr",0,_wrap_CvChain_ptr_get,_wrap_CvChain_ptr_set,0,0}, +{"delta_elems",0,_wrap_CvChain_delta_elems_get,_wrap_CvChain_delta_elems_set,0,0}, +{"storage",0,_wrap_CvChain_storage_get,_wrap_CvChain_storage_set,0,0}, +{"free_blocks",0,_wrap_CvChain_free_blocks_get,_wrap_CvChain_free_blocks_set,0,0}, +{"first",0,_wrap_CvChain_first_get,_wrap_CvChain_first_set,0,0}, +{"origin",0,_wrap_CvChain_origin_get,_wrap_CvChain_origin_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvChain_base_names[] = {0}; +static const swig_type_info *swig_CvChain_base[] = {0}; +static swig_octave_class _wrap_class_CvChain = {"CvChain", &SWIGTYPE_p_CvChain,0,_wrap_new_CvChain,0,_wrap_delete_CvChain,swig_CvChain_members,swig_CvChain_base_names,swig_CvChain_base }; + +static octave_value_list _wrap_CvContour_flags_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_flags_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContour_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_flags_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_flags_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_header_size_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_header_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_header_size_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContour_header_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->header_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_header_size_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_header_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_header_size_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (int) ((arg1)->header_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_CvContour_h_prev_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvContour_h_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_h_prev_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_h_prev_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_h_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_h_prev_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (CvSeq *) ((arg1)->h_prev); + _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_CvContour_h_next_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvContour_h_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_h_next_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_h_next_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_h_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_h_next_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (CvSeq *) ((arg1)->h_next); + _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_CvContour_v_prev_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvContour_v_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_v_prev_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_v_prev_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_v_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_v_prev_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (CvSeq *) ((arg1)->v_prev); + _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_CvContour_v_next_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvContour_v_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_v_next_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_v_next_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_v_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_v_next_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (CvSeq *) ((arg1)->v_next); + _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_CvContour_total_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_total_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_total_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContour_total_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->total = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_total_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_total_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_total_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (int) ((arg1)->total); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_elem_size_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_elem_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_elem_size_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContour_elem_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->elem_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_elem_size_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_elem_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_elem_size_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (int) ((arg1)->elem_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_CvContour_block_max_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_block_max_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_block_max_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(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 '" "CvContour_block_max_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->block_max = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_block_max_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_block_max_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_block_max_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (schar *) ((arg1)->block_max); + _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_CvContour_ptr_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_ptr_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(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 '" "CvContour_ptr_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(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_CvContour_ptr_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_ptr_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (schar *) ((arg1)->ptr); + _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_CvContour_delta_elems_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_delta_elems_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_delta_elems_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContour_delta_elems_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->delta_elems = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_delta_elems_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_delta_elems_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_delta_elems_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (int) ((arg1)->delta_elems); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_storage_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_storage_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_storage_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(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 '" "CvContour_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_CvContour_storage_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_storage_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_storage_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(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_CvContour_free_blocks_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 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("CvContour_free_blocks_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_free_blocks_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContour_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->free_blocks = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_free_blocks_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvContour_free_blocks_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_free_blocks_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (CvSeqBlock *) ((arg1)->free_blocks); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_first_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 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("CvContour_first_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_first_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContour_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->first = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_first_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvContour_first_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_first_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (CvSeqBlock *) ((arg1)->first); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_rect_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 0 ; + CvRect *arg2 = (CvRect *) 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("CvContour_rect_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_rect_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContour_rect_set" "', argument " "2"" of type '" "CvRect *""'"); + } + arg2 = (CvRect *)(argp2); + if (arg1) (arg1)->rect = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_rect_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvRect *result = 0 ; + + if (!SWIG_check_num_args("CvContour_rect_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_rect_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (CvRect *)& ((arg1)->rect); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_color_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_color_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_color_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContour_color_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->color = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_color_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_color_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_color_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (int) ((arg1)->color); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_reserved_set (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 0 ; + int *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("CvContour_reserved_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_reserved_set" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContour_reserved_set" "', argument " "2"" of type '" "int [3]""'"); + } + arg2 = (int *)(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)3; ++ii) arg1->reserved[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""reserved""' of type '""int [3]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContour_reserved_get (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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("CvContour_reserved_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContour_reserved_get" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(argp1); + result = (int *)(int *) ((arg1)->reserved); + _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_CvContour (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvContour *result = 0 ; + + if (!SWIG_check_num_args("new_CvContour",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvContour *)new CvContour(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvContour, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvContour (const octave_value_list& args, int nargout) { + CvContour *arg1 = (CvContour *) 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_CvContour",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContour, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvContour" "', argument " "1"" of type '" "CvContour *""'"); + } + arg1 = (CvContour *)(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_CvContour_members[] = { +{"flags",0,_wrap_CvContour_flags_get,_wrap_CvContour_flags_set,0,0}, +{"header_size",0,_wrap_CvContour_header_size_get,_wrap_CvContour_header_size_set,0,0}, +{"h_prev",0,_wrap_CvContour_h_prev_get,_wrap_CvContour_h_prev_set,0,0}, +{"h_next",0,_wrap_CvContour_h_next_get,_wrap_CvContour_h_next_set,0,0}, +{"v_prev",0,_wrap_CvContour_v_prev_get,_wrap_CvContour_v_prev_set,0,0}, +{"v_next",0,_wrap_CvContour_v_next_get,_wrap_CvContour_v_next_set,0,0}, +{"total",0,_wrap_CvContour_total_get,_wrap_CvContour_total_set,0,0}, +{"elem_size",0,_wrap_CvContour_elem_size_get,_wrap_CvContour_elem_size_set,0,0}, +{"block_max",0,_wrap_CvContour_block_max_get,_wrap_CvContour_block_max_set,0,0}, +{"ptr",0,_wrap_CvContour_ptr_get,_wrap_CvContour_ptr_set,0,0}, +{"delta_elems",0,_wrap_CvContour_delta_elems_get,_wrap_CvContour_delta_elems_set,0,0}, +{"storage",0,_wrap_CvContour_storage_get,_wrap_CvContour_storage_set,0,0}, +{"free_blocks",0,_wrap_CvContour_free_blocks_get,_wrap_CvContour_free_blocks_set,0,0}, +{"first",0,_wrap_CvContour_first_get,_wrap_CvContour_first_set,0,0}, +{"rect",0,_wrap_CvContour_rect_get,_wrap_CvContour_rect_set,0,0}, +{"color",0,_wrap_CvContour_color_get,_wrap_CvContour_color_set,0,0}, +{"reserved",0,_wrap_CvContour_reserved_get,_wrap_CvContour_reserved_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvContour_base_names[] = {0}; +static const swig_type_info *swig_CvContour_base[] = {0}; +static swig_octave_class _wrap_class_CvContour = {"CvContour", &SWIGTYPE_p_CvContour,0,_wrap_new_CvContour,0,_wrap_delete_CvContour,swig_CvContour_members,swig_CvContour_base_names,swig_CvContour_base }; + +static octave_value_list _wrap_CvSeqWriter_header_size_set (const octave_value_list& args, int nargout) { + CvSeqWriter *arg1 = (CvSeqWriter *) 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("CvSeqWriter_header_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_header_size_set" "', argument " "1"" of type '" "CvSeqWriter *""'"); + } + arg1 = (CvSeqWriter *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeqWriter_header_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->header_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqWriter_header_size_get (const octave_value_list& args, int nargout) { + CvSeqWriter *arg1 = (CvSeqWriter *) 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("CvSeqWriter_header_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_header_size_get" "', argument " "1"" of type '" "CvSeqWriter *""'"); + } + arg1 = (CvSeqWriter *)(argp1); + result = (int) ((arg1)->header_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_CvSeqWriter_seq_set (const octave_value_list& args, int nargout) { + CvSeqWriter *arg1 = (CvSeqWriter *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvSeqWriter_seq_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_seq_set" "', argument " "1"" of type '" "CvSeqWriter *""'"); + } + arg1 = (CvSeqWriter *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->seq = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqWriter_seq_get (const octave_value_list& args, int nargout) { + CvSeqWriter *arg1 = (CvSeqWriter *) 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("CvSeqWriter_seq_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_seq_get" "', argument " "1"" of type '" "CvSeqWriter *""'"); + } + arg1 = (CvSeqWriter *)(argp1); + result = (CvSeq *) ((arg1)->seq); + _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_CvSeqWriter_block_set (const octave_value_list& args, int nargout) { + CvSeqWriter *arg1 = (CvSeqWriter *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 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("CvSeqWriter_block_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_block_set" "', argument " "1"" of type '" "CvSeqWriter *""'"); + } + arg1 = (CvSeqWriter *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqWriter_block_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->block = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqWriter_block_get (const octave_value_list& args, int nargout) { + CvSeqWriter *arg1 = (CvSeqWriter *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvSeqWriter_block_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_block_get" "', argument " "1"" of type '" "CvSeqWriter *""'"); + } + arg1 = (CvSeqWriter *)(argp1); + result = (CvSeqBlock *) ((arg1)->block); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqWriter_ptr_set (const octave_value_list& args, int nargout) { + CvSeqWriter *arg1 = (CvSeqWriter *) 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("CvSeqWriter_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_ptr_set" "', argument " "1"" of type '" "CvSeqWriter *""'"); + } + arg1 = (CvSeqWriter *)(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 '" "CvSeqWriter_ptr_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(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_CvSeqWriter_ptr_get (const octave_value_list& args, int nargout) { + CvSeqWriter *arg1 = (CvSeqWriter *) 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("CvSeqWriter_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_ptr_get" "', argument " "1"" of type '" "CvSeqWriter *""'"); + } + arg1 = (CvSeqWriter *)(argp1); + result = (schar *) ((arg1)->ptr); + _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_CvSeqWriter_block_min_set (const octave_value_list& args, int nargout) { + CvSeqWriter *arg1 = (CvSeqWriter *) 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("CvSeqWriter_block_min_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_block_min_set" "', argument " "1"" of type '" "CvSeqWriter *""'"); + } + arg1 = (CvSeqWriter *)(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 '" "CvSeqWriter_block_min_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->block_min = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqWriter_block_min_get (const octave_value_list& args, int nargout) { + CvSeqWriter *arg1 = (CvSeqWriter *) 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("CvSeqWriter_block_min_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_block_min_get" "', argument " "1"" of type '" "CvSeqWriter *""'"); + } + arg1 = (CvSeqWriter *)(argp1); + result = (schar *) ((arg1)->block_min); + _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_CvSeqWriter_block_max_set (const octave_value_list& args, int nargout) { + CvSeqWriter *arg1 = (CvSeqWriter *) 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("CvSeqWriter_block_max_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_block_max_set" "', argument " "1"" of type '" "CvSeqWriter *""'"); + } + arg1 = (CvSeqWriter *)(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 '" "CvSeqWriter_block_max_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->block_max = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqWriter_block_max_get (const octave_value_list& args, int nargout) { + CvSeqWriter *arg1 = (CvSeqWriter *) 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("CvSeqWriter_block_max_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqWriter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqWriter_block_max_get" "', argument " "1"" of type '" "CvSeqWriter *""'"); + } + arg1 = (CvSeqWriter *)(argp1); + result = (schar *) ((arg1)->block_max); + _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_new_CvSeqWriter (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqWriter *result = 0 ; + + if (!SWIG_check_num_args("new_CvSeqWriter",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSeqWriter *)new CvSeqWriter(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqWriter, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSeqWriter (const octave_value_list& args, int nargout) { + CvSeqWriter *arg1 = (CvSeqWriter *) 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_CvSeqWriter",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqWriter, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeqWriter" "', argument " "1"" of type '" "CvSeqWriter *""'"); + } + arg1 = (CvSeqWriter *)(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_CvSeqWriter_members[] = { +{"header_size",0,_wrap_CvSeqWriter_header_size_get,_wrap_CvSeqWriter_header_size_set,0,0}, +{"seq",0,_wrap_CvSeqWriter_seq_get,_wrap_CvSeqWriter_seq_set,0,0}, +{"block",0,_wrap_CvSeqWriter_block_get,_wrap_CvSeqWriter_block_set,0,0}, +{"ptr",0,_wrap_CvSeqWriter_ptr_get,_wrap_CvSeqWriter_ptr_set,0,0}, +{"block_min",0,_wrap_CvSeqWriter_block_min_get,_wrap_CvSeqWriter_block_min_set,0,0}, +{"block_max",0,_wrap_CvSeqWriter_block_max_get,_wrap_CvSeqWriter_block_max_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSeqWriter_base_names[] = {0}; +static const swig_type_info *swig_CvSeqWriter_base[] = {0}; +static swig_octave_class _wrap_class_CvSeqWriter = {"CvSeqWriter", &SWIGTYPE_p_CvSeqWriter,0,_wrap_new_CvSeqWriter,0,_wrap_delete_CvSeqWriter,swig_CvSeqWriter_members,swig_CvSeqWriter_base_names,swig_CvSeqWriter_base }; + +static octave_value_list _wrap_CvSeqReader_header_size_set (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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("CvSeqReader_header_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_header_size_set" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeqReader_header_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->header_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqReader_header_size_get (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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("CvSeqReader_header_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_header_size_get" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(argp1); + result = (int) ((arg1)->header_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_CvSeqReader_seq_set (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvSeqReader_seq_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_seq_set" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->seq = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqReader_seq_get (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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("CvSeqReader_seq_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_seq_get" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(argp1); + result = (CvSeq *) ((arg1)->seq); + _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_CvSeqReader_block_set (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 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("CvSeqReader_block_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_block_set" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeqReader_block_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->block = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqReader_block_get (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvSeqReader_block_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_block_get" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(argp1); + result = (CvSeqBlock *) ((arg1)->block); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqReader_ptr_set (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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("CvSeqReader_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_ptr_set" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(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 '" "CvSeqReader_ptr_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(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_CvSeqReader_ptr_get (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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("CvSeqReader_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_ptr_get" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(argp1); + result = (schar *) ((arg1)->ptr); + _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_CvSeqReader_block_min_set (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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("CvSeqReader_block_min_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_block_min_set" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(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 '" "CvSeqReader_block_min_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->block_min = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqReader_block_min_get (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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("CvSeqReader_block_min_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_block_min_get" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(argp1); + result = (schar *) ((arg1)->block_min); + _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_CvSeqReader_block_max_set (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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("CvSeqReader_block_max_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_block_max_set" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(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 '" "CvSeqReader_block_max_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->block_max = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqReader_block_max_get (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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("CvSeqReader_block_max_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_block_max_get" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(argp1); + result = (schar *) ((arg1)->block_max); + _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_CvSeqReader_delta_index_set (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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("CvSeqReader_delta_index_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_delta_index_set" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeqReader_delta_index_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->delta_index = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqReader_delta_index_get (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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("CvSeqReader_delta_index_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_delta_index_get" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(argp1); + result = (int) ((arg1)->delta_index); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqReader_prev_elem_set (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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("CvSeqReader_prev_elem_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_prev_elem_set" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(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 '" "CvSeqReader_prev_elem_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->prev_elem = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeqReader_prev_elem_get (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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("CvSeqReader_prev_elem_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeqReader_prev_elem_get" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(argp1); + result = (schar *) ((arg1)->prev_elem); + _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_new_CvSeqReader (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqReader *result = 0 ; + + if (!SWIG_check_num_args("new_CvSeqReader",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSeqReader *)new CvSeqReader(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqReader, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSeqReader (const octave_value_list& args, int nargout) { + CvSeqReader *arg1 = (CvSeqReader *) 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_CvSeqReader",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSeqReader, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeqReader" "', argument " "1"" of type '" "CvSeqReader *""'"); + } + arg1 = (CvSeqReader *)(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_CvSeqReader_members[] = { +{"header_size",0,_wrap_CvSeqReader_header_size_get,_wrap_CvSeqReader_header_size_set,0,0}, +{"seq",0,_wrap_CvSeqReader_seq_get,_wrap_CvSeqReader_seq_set,0,0}, +{"block",0,_wrap_CvSeqReader_block_get,_wrap_CvSeqReader_block_set,0,0}, +{"ptr",0,_wrap_CvSeqReader_ptr_get,_wrap_CvSeqReader_ptr_set,0,0}, +{"block_min",0,_wrap_CvSeqReader_block_min_get,_wrap_CvSeqReader_block_min_set,0,0}, +{"block_max",0,_wrap_CvSeqReader_block_max_get,_wrap_CvSeqReader_block_max_set,0,0}, +{"delta_index",0,_wrap_CvSeqReader_delta_index_get,_wrap_CvSeqReader_delta_index_set,0,0}, +{"prev_elem",0,_wrap_CvSeqReader_prev_elem_get,_wrap_CvSeqReader_prev_elem_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSeqReader_base_names[] = {0}; +static const swig_type_info *swig_CvSeqReader_base[] = {0}; +static swig_octave_class _wrap_class_CvSeqReader = {"CvSeqReader", &SWIGTYPE_p_CvSeqReader,0,_wrap_new_CvSeqReader,0,_wrap_delete_CvSeqReader,swig_CvSeqReader_members,swig_CvSeqReader_base_names,swig_CvSeqReader_base }; + +static octave_value_list _wrap_CvAttrList_attr_set (const octave_value_list& args, int nargout) { + CvAttrList *arg1 = (CvAttrList *) 0 ; + char **arg2 = (char **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *vptr2 ; + char *buffer2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvAttrList_attr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvAttrList, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAttrList_attr_set" "', argument " "1"" of type '" "CvAttrList *""'"); + } + arg1 = (CvAttrList *)(argp1); + { + if ((SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_char, 1)) == -1){ + SWIG_fail; + } + buffer2 = (char *) vptr2; + arg2=&buffer2; + } + if (arg1) (arg1)->attr = (char const **)arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvAttrList_attr_get (const octave_value_list& args, int nargout) { + CvAttrList *arg1 = (CvAttrList *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + char **result = 0 ; + + if (!SWIG_check_num_args("CvAttrList_attr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvAttrList, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAttrList_attr_get" "', argument " "1"" of type '" "CvAttrList *""'"); + } + arg1 = (CvAttrList *)(argp1); + result = (char **) ((arg1)->attr); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvAttrList_next_set (const octave_value_list& args, int nargout) { + CvAttrList *arg1 = (CvAttrList *) 0 ; + CvAttrList *arg2 = (CvAttrList *) 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("CvAttrList_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvAttrList, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAttrList_next_set" "', argument " "1"" of type '" "CvAttrList *""'"); + } + arg1 = (CvAttrList *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvAttrList, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvAttrList_next_set" "', argument " "2"" of type '" "CvAttrList *""'"); + } + arg2 = (CvAttrList *)(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_CvAttrList_next_get (const octave_value_list& args, int nargout) { + CvAttrList *arg1 = (CvAttrList *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvAttrList *result = 0 ; + + if (!SWIG_check_num_args("CvAttrList_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvAttrList, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAttrList_next_get" "', argument " "1"" of type '" "CvAttrList *""'"); + } + arg1 = (CvAttrList *)(argp1); + result = (CvAttrList *) ((arg1)->next); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvAttrList, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvAttrList (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvAttrList *result = 0 ; + + if (!SWIG_check_num_args("new_CvAttrList",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvAttrList *)new CvAttrList(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvAttrList, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvAttrList (const octave_value_list& args, int nargout) { + CvAttrList *arg1 = (CvAttrList *) 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_CvAttrList",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvAttrList, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvAttrList" "', argument " "1"" of type '" "CvAttrList *""'"); + } + arg1 = (CvAttrList *)(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_CvAttrList_members[] = { +{"attr",0,_wrap_CvAttrList_attr_get,_wrap_CvAttrList_attr_set,0,0}, +{"next",0,_wrap_CvAttrList_next_get,_wrap_CvAttrList_next_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvAttrList_base_names[] = {0}; +static const swig_type_info *swig_CvAttrList_base[] = {0}; +static swig_octave_class _wrap_class_CvAttrList = {"CvAttrList", &SWIGTYPE_p_CvAttrList,0,_wrap_new_CvAttrList,0,_wrap_delete_CvAttrList,swig_CvAttrList_members,swig_CvAttrList_base_names,swig_CvAttrList_base }; + +static octave_value_list _wrap_cvAttrList__SWIG_0 (const octave_value_list& args, int nargout) { + char **arg1 = (char **) 0 ; + CvAttrList *arg2 = (CvAttrList *) 0 ; + void *vptr1 ; + char *buffer1 ; + void *argp2 = 0 ; + int res2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvAttrList result; + + if (!SWIG_check_num_args("cvAttrList",args.length(),2,2,0)) { + SWIG_fail; + } + { + if ((SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_char, 1)) == -1){ + SWIG_fail; + } + buffer1 = (char *) vptr1; + arg1=&buffer1; + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvAttrList, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvAttrList" "', argument " "2"" of type '" "CvAttrList *""'"); + } + arg2 = (CvAttrList *)(argp2); + { + try { + result = cvAttrList((char const **)arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvAttrList((const CvAttrList&)(result))), SWIGTYPE_p_CvAttrList, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvAttrList__SWIG_1 (const octave_value_list& args, int nargout) { + char **arg1 = (char **) 0 ; + void *vptr1 ; + char *buffer1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvAttrList result; + + if (!SWIG_check_num_args("cvAttrList",args.length(),1,1,0)) { + SWIG_fail; + } + { + if ((SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_char, 1)) == -1){ + SWIG_fail; + } + buffer1 = (char *) vptr1; + arg1=&buffer1; + } + { + try { + result = cvAttrList((char const **)arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvAttrList((const CvAttrList&)(result))), SWIGTYPE_p_CvAttrList, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvAttrList__SWIG_2 (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvAttrList result; + + if (!SWIG_check_num_args("cvAttrList",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = cvAttrList(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvAttrList((const CvAttrList&)(result))), SWIGTYPE_p_CvAttrList, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvAttrList (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_cvAttrList__SWIG_2(args, nargout); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_char, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_cvAttrList__SWIG_1(args, nargout); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_char, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CvAttrList, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_cvAttrList__SWIG_0(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvString_len_set (const octave_value_list& args, int nargout) { + CvString *arg1 = (CvString *) 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("CvString_len_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvString, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvString_len_set" "', argument " "1"" of type '" "CvString *""'"); + } + arg1 = (CvString *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvString_len_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->len = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvString_len_get (const octave_value_list& args, int nargout) { + CvString *arg1 = (CvString *) 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("CvString_len_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvString, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvString_len_get" "', argument " "1"" of type '" "CvString *""'"); + } + arg1 = (CvString *)(argp1); + result = (int) ((arg1)->len); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvString_ptr_set (const octave_value_list& args, int nargout) { + CvString *arg1 = (CvString *) 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("CvString_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvString, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvString_ptr_set" "', argument " "1"" of type '" "CvString *""'"); + } + arg1 = (CvString *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvString_ptr_set" "', argument " "2"" of type '" "char *""'"); + } + arg2 = (char *)(buf2); + if (arg1->ptr) delete[] arg1->ptr; + if (arg2) { + size_t size = strlen((const char *)(arg2)) + 1; + arg1->ptr = (char *)(char*)(memcpy((new char[size]), (const char *)(arg2), sizeof(char)*(size))); + } else { + arg1->ptr = 0; + } + _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_CvString_ptr_get (const octave_value_list& args, int nargout) { + CvString *arg1 = (CvString *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + char *result = 0 ; + + if (!SWIG_check_num_args("CvString_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvString, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvString_ptr_get" "', argument " "1"" of type '" "CvString *""'"); + } + arg1 = (CvString *)(argp1); + result = (char *) ((arg1)->ptr); + _outv = SWIG_FromCharPtr((const char *)result); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvString (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvString *result = 0 ; + + if (!SWIG_check_num_args("new_CvString",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvString *)new CvString(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvString, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvString (const octave_value_list& args, int nargout) { + CvString *arg1 = (CvString *) 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_CvString",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvString, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvString" "', argument " "1"" of type '" "CvString *""'"); + } + arg1 = (CvString *)(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_CvString_members[] = { +{"len",0,_wrap_CvString_len_get,_wrap_CvString_len_set,0,0}, +{"ptr",0,_wrap_CvString_ptr_get,_wrap_CvString_ptr_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvString_base_names[] = {0}; +static const swig_type_info *swig_CvString_base[] = {0}; +static swig_octave_class _wrap_class_CvString = {"CvString", &SWIGTYPE_p_CvString,0,_wrap_new_CvString,0,_wrap_delete_CvString,swig_CvString_members,swig_CvString_base_names,swig_CvString_base }; + +static octave_value_list _wrap_CvStringHashNode_hashval_set (const octave_value_list& args, int nargout) { + CvStringHashNode *arg1 = (CvStringHashNode *) 0 ; + unsigned int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvStringHashNode_hashval_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStringHashNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStringHashNode_hashval_set" "', argument " "1"" of type '" "CvStringHashNode *""'"); + } + arg1 = (CvStringHashNode *)(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStringHashNode_hashval_set" "', argument " "2"" of type '" "unsigned int""'"); + } + arg2 = (unsigned int)(val2); + if (arg1) (arg1)->hashval = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStringHashNode_hashval_get (const octave_value_list& args, int nargout) { + CvStringHashNode *arg1 = (CvStringHashNode *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + unsigned int result; + + if (!SWIG_check_num_args("CvStringHashNode_hashval_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStringHashNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStringHashNode_hashval_get" "', argument " "1"" of type '" "CvStringHashNode *""'"); + } + arg1 = (CvStringHashNode *)(argp1); + result = (unsigned int) ((arg1)->hashval); + _outv = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStringHashNode_str_set (const octave_value_list& args, int nargout) { + CvStringHashNode *arg1 = (CvStringHashNode *) 0 ; + CvString *arg2 = (CvString *) 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("CvStringHashNode_str_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStringHashNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStringHashNode_str_set" "', argument " "1"" of type '" "CvStringHashNode *""'"); + } + arg1 = (CvStringHashNode *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvString, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStringHashNode_str_set" "', argument " "2"" of type '" "CvString *""'"); + } + arg2 = (CvString *)(argp2); + if (arg1) (arg1)->str = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStringHashNode_str_get (const octave_value_list& args, int nargout) { + CvStringHashNode *arg1 = (CvStringHashNode *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvString *result = 0 ; + + if (!SWIG_check_num_args("CvStringHashNode_str_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStringHashNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStringHashNode_str_get" "', argument " "1"" of type '" "CvStringHashNode *""'"); + } + arg1 = (CvStringHashNode *)(argp1); + result = (CvString *)& ((arg1)->str); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvString, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStringHashNode_next_set (const octave_value_list& args, int nargout) { + CvStringHashNode *arg1 = (CvStringHashNode *) 0 ; + CvStringHashNode *arg2 = (CvStringHashNode *) 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("CvStringHashNode_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStringHashNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStringHashNode_next_set" "', argument " "1"" of type '" "CvStringHashNode *""'"); + } + arg1 = (CvStringHashNode *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvStringHashNode, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvStringHashNode_next_set" "', argument " "2"" of type '" "CvStringHashNode *""'"); + } + arg2 = (CvStringHashNode *)(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_CvStringHashNode_next_get (const octave_value_list& args, int nargout) { + CvStringHashNode *arg1 = (CvStringHashNode *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvStringHashNode *result = 0 ; + + if (!SWIG_check_num_args("CvStringHashNode_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStringHashNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStringHashNode_next_get" "', argument " "1"" of type '" "CvStringHashNode *""'"); + } + arg1 = (CvStringHashNode *)(argp1); + result = (CvStringHashNode *) ((arg1)->next); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStringHashNode, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvStringHashNode (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvStringHashNode *result = 0 ; + + if (!SWIG_check_num_args("new_CvStringHashNode",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvStringHashNode *)new CvStringHashNode(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStringHashNode, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvStringHashNode (const octave_value_list& args, int nargout) { + CvStringHashNode *arg1 = (CvStringHashNode *) 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_CvStringHashNode",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStringHashNode, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvStringHashNode" "', argument " "1"" of type '" "CvStringHashNode *""'"); + } + arg1 = (CvStringHashNode *)(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_CvStringHashNode_members[] = { +{"hashval",0,_wrap_CvStringHashNode_hashval_get,_wrap_CvStringHashNode_hashval_set,0,0}, +{"str",0,_wrap_CvStringHashNode_str_get,_wrap_CvStringHashNode_str_set,0,0}, +{"next",0,_wrap_CvStringHashNode_next_get,_wrap_CvStringHashNode_next_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvStringHashNode_base_names[] = {0}; +static const swig_type_info *swig_CvStringHashNode_base[] = {0}; +static swig_octave_class _wrap_class_CvStringHashNode = {"CvStringHashNode", &SWIGTYPE_p_CvStringHashNode,0,_wrap_new_CvStringHashNode,0,_wrap_delete_CvStringHashNode,swig_CvStringHashNode_members,swig_CvStringHashNode_base_names,swig_CvStringHashNode_base }; + +static octave_value_list _wrap_CvFileNode_tag_set (const octave_value_list& args, int nargout) { + CvFileNode *arg1 = (CvFileNode *) 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("CvFileNode_tag_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_tag_set" "', argument " "1"" of type '" "CvFileNode *""'"); + } + arg1 = (CvFileNode *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFileNode_tag_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->tag = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFileNode_tag_get (const octave_value_list& args, int nargout) { + CvFileNode *arg1 = (CvFileNode *) 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("CvFileNode_tag_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_tag_get" "', argument " "1"" of type '" "CvFileNode *""'"); + } + arg1 = (CvFileNode *)(argp1); + result = (int) ((arg1)->tag); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFileNode_info_set (const octave_value_list& args, int nargout) { + CvFileNode *arg1 = (CvFileNode *) 0 ; + CvTypeInfo *arg2 = (CvTypeInfo *) 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("CvFileNode_info_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_info_set" "', argument " "1"" of type '" "CvFileNode *""'"); + } + arg1 = (CvFileNode *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTypeInfo, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvFileNode_info_set" "', argument " "2"" of type '" "CvTypeInfo *""'"); + } + arg2 = (CvTypeInfo *)(argp2); + if (arg1) (arg1)->info = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFileNode_info_get (const octave_value_list& args, int nargout) { + CvFileNode *arg1 = (CvFileNode *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypeInfo *result = 0 ; + + if (!SWIG_check_num_args("CvFileNode_info_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_info_get" "', argument " "1"" of type '" "CvFileNode *""'"); + } + arg1 = (CvFileNode *)(argp1); + result = (CvTypeInfo *) ((arg1)->info); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFileNode_data_get (const octave_value_list& args, int nargout) { + CvFileNode *arg1 = (CvFileNode *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvFileNode_data *result = 0 ; + + if (!SWIG_check_num_args("CvFileNode_data_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_get" "', argument " "1"" of type '" "CvFileNode *""'"); + } + arg1 = (CvFileNode *)(argp1); + result = (CvFileNode_data *)& ((arg1)->data); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvFileNode_data, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvFileNode (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvFileNode *result = 0 ; + + if (!SWIG_check_num_args("new_CvFileNode",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvFileNode *)new CvFileNode(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvFileNode, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvFileNode (const octave_value_list& args, int nargout) { + CvFileNode *arg1 = (CvFileNode *) 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_CvFileNode",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvFileNode" "', argument " "1"" of type '" "CvFileNode *""'"); + } + arg1 = (CvFileNode *)(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_CvFileNode_members[] = { +{"tag",0,_wrap_CvFileNode_tag_get,_wrap_CvFileNode_tag_set,0,0}, +{"info",0,_wrap_CvFileNode_info_get,_wrap_CvFileNode_info_set,0,0}, +{"data",0,_wrap_CvFileNode_data_get,octave_set_immutable,0,0}, +{0,0,0,0} +}; +static const char *swig_CvFileNode_base_names[] = {0}; +static const swig_type_info *swig_CvFileNode_base[] = {0}; +static swig_octave_class _wrap_class_CvFileNode = {"CvFileNode", &SWIGTYPE_p_CvFileNode,0,_wrap_new_CvFileNode,0,_wrap_delete_CvFileNode,swig_CvFileNode_members,swig_CvFileNode_base_names,swig_CvFileNode_base }; + +static octave_value_list _wrap_CvFileNode_data_f_set (const octave_value_list& args, int nargout) { + CvFileNode_data *arg1 = (CvFileNode_data *) 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("CvFileNode_data_f_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_f_set" "', argument " "1"" of type '" "CvFileNode_data *""'"); + } + arg1 = (CvFileNode_data *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFileNode_data_f_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->f = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFileNode_data_f_get (const octave_value_list& args, int nargout) { + CvFileNode_data *arg1 = (CvFileNode_data *) 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("CvFileNode_data_f_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_f_get" "', argument " "1"" of type '" "CvFileNode_data *""'"); + } + arg1 = (CvFileNode_data *)(argp1); + result = (double) ((arg1)->f); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFileNode_data_i_set (const octave_value_list& args, int nargout) { + CvFileNode_data *arg1 = (CvFileNode_data *) 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("CvFileNode_data_i_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_i_set" "', argument " "1"" of type '" "CvFileNode_data *""'"); + } + arg1 = (CvFileNode_data *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFileNode_data_i_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + 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_CvFileNode_data_i_get (const octave_value_list& args, int nargout) { + CvFileNode_data *arg1 = (CvFileNode_data *) 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("CvFileNode_data_i_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_i_get" "', argument " "1"" of type '" "CvFileNode_data *""'"); + } + arg1 = (CvFileNode_data *)(argp1); + result = (int) ((arg1)->i); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFileNode_data_str_set (const octave_value_list& args, int nargout) { + CvFileNode_data *arg1 = (CvFileNode_data *) 0 ; + CvString *arg2 = (CvString *) 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("CvFileNode_data_str_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_str_set" "', argument " "1"" of type '" "CvFileNode_data *""'"); + } + arg1 = (CvFileNode_data *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvString, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvFileNode_data_str_set" "', argument " "2"" of type '" "CvString *""'"); + } + arg2 = (CvString *)(argp2); + if (arg1) (arg1)->str = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFileNode_data_str_get (const octave_value_list& args, int nargout) { + CvFileNode_data *arg1 = (CvFileNode_data *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvString *result = 0 ; + + if (!SWIG_check_num_args("CvFileNode_data_str_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_str_get" "', argument " "1"" of type '" "CvFileNode_data *""'"); + } + arg1 = (CvFileNode_data *)(argp1); + result = (CvString *)& ((arg1)->str); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvString, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFileNode_data_seq_set (const octave_value_list& args, int nargout) { + CvFileNode_data *arg1 = (CvFileNode_data *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvFileNode_data_seq_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_seq_set" "', argument " "1"" of type '" "CvFileNode_data *""'"); + } + arg1 = (CvFileNode_data *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->seq = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFileNode_data_seq_get (const octave_value_list& args, int nargout) { + CvFileNode_data *arg1 = (CvFileNode_data *) 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("CvFileNode_data_seq_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_seq_get" "', argument " "1"" of type '" "CvFileNode_data *""'"); + } + arg1 = (CvFileNode_data *)(argp1); + result = (CvSeq *) ((arg1)->seq); + _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_CvFileNode_data_map_set (const octave_value_list& args, int nargout) { + CvFileNode_data *arg1 = (CvFileNode_data *) 0 ; + CvFileNodeHash *arg2 = (CvFileNodeHash *) 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("CvFileNode_data_map_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_map_set" "', argument " "1"" of type '" "CvFileNode_data *""'"); + } + arg1 = (CvFileNode_data *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvGenericHash, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvFileNode_data_map_set" "', argument " "2"" of type '" "CvFileNodeHash *""'"); + } + arg2 = (CvFileNodeHash *)(argp2); + if (arg1) (arg1)->map = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFileNode_data_map_get (const octave_value_list& args, int nargout) { + CvFileNode_data *arg1 = (CvFileNode_data *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvFileNodeHash *result = 0 ; + + if (!SWIG_check_num_args("CvFileNode_data_map_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode_data, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFileNode_data_map_get" "', argument " "1"" of type '" "CvFileNode_data *""'"); + } + arg1 = (CvFileNode_data *)(argp1); + result = (CvFileNodeHash *) ((arg1)->map); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGenericHash, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvFileNode_data (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvFileNode_data *result = 0 ; + + if (!SWIG_check_num_args("new_CvFileNode_data",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvFileNode_data *)new CvFileNode_data(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvFileNode_data, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvFileNode_data (const octave_value_list& args, int nargout) { + CvFileNode_data *arg1 = (CvFileNode_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_CvFileNode_data",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileNode_data, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvFileNode_data" "', argument " "1"" of type '" "CvFileNode_data *""'"); + } + arg1 = (CvFileNode_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_CvFileNode_data_members[] = { +{"f",0,_wrap_CvFileNode_data_f_get,_wrap_CvFileNode_data_f_set,0,0}, +{"i",0,_wrap_CvFileNode_data_i_get,_wrap_CvFileNode_data_i_set,0,0}, +{"str",0,_wrap_CvFileNode_data_str_get,_wrap_CvFileNode_data_str_set,0,0}, +{"seq",0,_wrap_CvFileNode_data_seq_get,_wrap_CvFileNode_data_seq_set,0,0}, +{"map",0,_wrap_CvFileNode_data_map_get,_wrap_CvFileNode_data_map_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvFileNode_data_base_names[] = {0}; +static const swig_type_info *swig_CvFileNode_data_base[] = {0}; +static swig_octave_class _wrap_class_CvFileNode_data = {"CvFileNode_data", &SWIGTYPE_p_CvFileNode_data,0,_wrap_new_CvFileNode_data,0,_wrap_delete_CvFileNode_data,swig_CvFileNode_data_members,swig_CvFileNode_data_base_names,swig_CvFileNode_data_base }; + +static octave_value_list _wrap_CvTypeInfo_flags_set (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 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("CvTypeInfo_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_flags_set" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTypeInfo_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_flags_get (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 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("CvTypeInfo_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_flags_get" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_header_size_set (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 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("CvTypeInfo_header_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_header_size_set" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTypeInfo_header_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->header_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_header_size_get (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 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("CvTypeInfo_header_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_header_size_get" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + result = (int) ((arg1)->header_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_CvTypeInfo_prev_set (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + CvTypeInfo *arg2 = (CvTypeInfo *) 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("CvTypeInfo_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_prev_set" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTypeInfo, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTypeInfo_prev_set" "', argument " "2"" of type '" "CvTypeInfo *""'"); + } + arg2 = (CvTypeInfo *)(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_CvTypeInfo_prev_get (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypeInfo *result = 0 ; + + if (!SWIG_check_num_args("CvTypeInfo_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_prev_get" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + result = (CvTypeInfo *) ((arg1)->prev); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_next_set (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + CvTypeInfo *arg2 = (CvTypeInfo *) 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("CvTypeInfo_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_next_set" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTypeInfo, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTypeInfo_next_set" "', argument " "2"" of type '" "CvTypeInfo *""'"); + } + arg2 = (CvTypeInfo *)(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_CvTypeInfo_next_get (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypeInfo *result = 0 ; + + if (!SWIG_check_num_args("CvTypeInfo_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_next_get" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + result = (CvTypeInfo *) ((arg1)->next); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_type_name_set (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 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("CvTypeInfo_type_name_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_type_name_set" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTypeInfo_type_name_set" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = (char *)(buf2); + if (arg2) { + size_t size = strlen((const char *)((const char *)(arg2))) + 1; + arg1->type_name = (char const *)(char*)(memcpy((new char[size]), arg2, sizeof(char)*(size))); + } else { + arg1->type_name = 0; + } + _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_CvTypeInfo_type_name_get (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + char *result = 0 ; + + if (!SWIG_check_num_args("CvTypeInfo_type_name_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_type_name_get" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + result = (char *) ((arg1)->type_name); + _outv = SWIG_FromCharPtr((const char *)result); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_is_instance_set (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + CvIsInstanceFunc arg2 = (CvIsInstanceFunc) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvTypeInfo_is_instance_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_is_instance_set" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + { + int res = SWIG_ConvertFunctionPtr(args(1), (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__int); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvTypeInfo_is_instance_set" "', argument " "2"" of type '" "CvIsInstanceFunc""'"); + } + } + if (arg1) (arg1)->is_instance = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_is_instance_get (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvIsInstanceFunc result; + + if (!SWIG_check_num_args("CvTypeInfo_is_instance_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_is_instance_get" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + result = (CvIsInstanceFunc) ((arg1)->is_instance); + _outv = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__void__int); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_release_set (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + CvReleaseFunc arg2 = (CvReleaseFunc) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvTypeInfo_release_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_release_set" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + { + int res = SWIG_ConvertFunctionPtr(args(1), (void**)(&arg2), SWIGTYPE_p_f_p_p_void__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvTypeInfo_release_set" "', argument " "2"" of type '" "CvReleaseFunc""'"); + } + } + if (arg1) (arg1)->release = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_release_get (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvReleaseFunc result; + + if (!SWIG_check_num_args("CvTypeInfo_release_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_release_get" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + result = (CvReleaseFunc) ((arg1)->release); + _outv = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_p_void__void); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_read_set (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + CvReadFunc arg2 = (CvReadFunc) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvTypeInfo_read_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_read_set" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + { + int res = SWIG_ConvertFunctionPtr(args(1), (void**)(&arg2), SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvTypeInfo_read_set" "', argument " "2"" of type '" "CvReadFunc""'"); + } + } + if (arg1) (arg1)->read = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_read_get (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvReadFunc result; + + if (!SWIG_check_num_args("CvTypeInfo_read_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_read_get" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + result = (CvReadFunc) ((arg1)->read); + _outv = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_write_set (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + CvWriteFunc arg2 = (CvWriteFunc) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvTypeInfo_write_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_write_set" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + { + int res = SWIG_ConvertFunctionPtr(args(1), (void**)(&arg2), SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvTypeInfo_write_set" "', argument " "2"" of type '" "CvWriteFunc""'"); + } + } + if (arg1) (arg1)->write = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_write_get (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvWriteFunc result; + + if (!SWIG_check_num_args("CvTypeInfo_write_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_write_get" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + result = (CvWriteFunc) ((arg1)->write); + _outv = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_clone_set (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + CvCloneFunc arg2 = (CvCloneFunc) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvTypeInfo_clone_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_clone_set" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + { + int res = SWIG_ConvertFunctionPtr(args(1), (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__p_void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "CvTypeInfo_clone_set" "', argument " "2"" of type '" "CvCloneFunc""'"); + } + } + if (arg1) (arg1)->clone = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTypeInfo_clone_get (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvCloneFunc result; + + if (!SWIG_check_num_args("CvTypeInfo_clone_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTypeInfo_clone_get" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(argp1); + result = (CvCloneFunc) ((arg1)->clone); + _outv = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__void__p_void); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvTypeInfo (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypeInfo *result = 0 ; + + if (!SWIG_check_num_args("new_CvTypeInfo",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTypeInfo *)new CvTypeInfo(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypeInfo, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvTypeInfo (const octave_value_list& args, int nargout) { + CvTypeInfo *arg1 = (CvTypeInfo *) 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_CvTypeInfo",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypeInfo, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTypeInfo" "', argument " "1"" of type '" "CvTypeInfo *""'"); + } + arg1 = (CvTypeInfo *)(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_CvTypeInfo_members[] = { +{"flags",0,_wrap_CvTypeInfo_flags_get,_wrap_CvTypeInfo_flags_set,0,0}, +{"header_size",0,_wrap_CvTypeInfo_header_size_get,_wrap_CvTypeInfo_header_size_set,0,0}, +{"prev",0,_wrap_CvTypeInfo_prev_get,_wrap_CvTypeInfo_prev_set,0,0}, +{"next",0,_wrap_CvTypeInfo_next_get,_wrap_CvTypeInfo_next_set,0,0}, +{"type_name",0,_wrap_CvTypeInfo_type_name_get,_wrap_CvTypeInfo_type_name_set,0,0}, +{"is_instance",0,_wrap_CvTypeInfo_is_instance_get,_wrap_CvTypeInfo_is_instance_set,0,0}, +{"release",0,_wrap_CvTypeInfo_release_get,_wrap_CvTypeInfo_release_set,0,0}, +{"read",0,_wrap_CvTypeInfo_read_get,_wrap_CvTypeInfo_read_set,0,0}, +{"write",0,_wrap_CvTypeInfo_write_get,_wrap_CvTypeInfo_write_set,0,0}, +{"clone",0,_wrap_CvTypeInfo_clone_get,_wrap_CvTypeInfo_clone_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvTypeInfo_base_names[] = {0}; +static const swig_type_info *swig_CvTypeInfo_base[] = {0}; +static swig_octave_class _wrap_class_CvTypeInfo = {"CvTypeInfo", &SWIGTYPE_p_CvTypeInfo,0,_wrap_new_CvTypeInfo,0,_wrap_delete_CvTypeInfo,swig_CvTypeInfo_members,swig_CvTypeInfo_base_names,swig_CvTypeInfo_base }; + +static octave_value_list _wrap_CvPluginFuncInfo_func_addr_set (const octave_value_list& args, int nargout) { + CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ; + void **arg2 = (void **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *vptr2 ; + void *buffer2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvPluginFuncInfo_func_addr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_func_addr_set" "', argument " "1"" of type '" "CvPluginFuncInfo *""'"); + } + arg1 = (CvPluginFuncInfo *)(argp1); + { + if ((SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_void, 1)) == -1){ + SWIG_fail; + } + buffer2 = (void *) vptr2; + arg2=&buffer2; + } + if (arg1) (arg1)->func_addr = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPluginFuncInfo_func_addr_get (const octave_value_list& args, int nargout) { + CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + void **result = 0 ; + + if (!SWIG_check_num_args("CvPluginFuncInfo_func_addr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_func_addr_get" "', argument " "1"" of type '" "CvPluginFuncInfo *""'"); + } + arg1 = (CvPluginFuncInfo *)(argp1); + result = (void **) ((arg1)->func_addr); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPluginFuncInfo_default_func_addr_set (const octave_value_list& args, int nargout) { + CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ; + void *arg2 = (void *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvPluginFuncInfo_default_func_addr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_default_func_addr_set" "', argument " "1"" of type '" "CvPluginFuncInfo *""'"); + } + arg1 = (CvPluginFuncInfo *)(argp1); + res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvPluginFuncInfo_default_func_addr_set" "', argument " "2"" of type '" "void *""'"); + } + if (arg1) (arg1)->default_func_addr = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPluginFuncInfo_default_func_addr_get (const octave_value_list& args, int nargout) { + CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + void *result = 0 ; + + if (!SWIG_check_num_args("CvPluginFuncInfo_default_func_addr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_default_func_addr_get" "', argument " "1"" of type '" "CvPluginFuncInfo *""'"); + } + arg1 = (CvPluginFuncInfo *)(argp1); + result = (void *) ((arg1)->default_func_addr); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPluginFuncInfo_func_names_set (const octave_value_list& args, int nargout) { + CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 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("CvPluginFuncInfo_func_names_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_func_names_set" "', argument " "1"" of type '" "CvPluginFuncInfo *""'"); + } + arg1 = (CvPluginFuncInfo *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvPluginFuncInfo_func_names_set" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = (char *)(buf2); + if (arg2) { + size_t size = strlen((const char *)((const char *)(arg2))) + 1; + arg1->func_names = (char const *)(char*)(memcpy((new char[size]), arg2, sizeof(char)*(size))); + } else { + arg1->func_names = 0; + } + _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_CvPluginFuncInfo_func_names_get (const octave_value_list& args, int nargout) { + CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + char *result = 0 ; + + if (!SWIG_check_num_args("CvPluginFuncInfo_func_names_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_func_names_get" "', argument " "1"" of type '" "CvPluginFuncInfo *""'"); + } + arg1 = (CvPluginFuncInfo *)(argp1); + result = (char *) ((arg1)->func_names); + _outv = SWIG_FromCharPtr((const char *)result); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPluginFuncInfo_search_modules_set (const octave_value_list& args, int nargout) { + CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 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("CvPluginFuncInfo_search_modules_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_search_modules_set" "', argument " "1"" of type '" "CvPluginFuncInfo *""'"); + } + arg1 = (CvPluginFuncInfo *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPluginFuncInfo_search_modules_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->search_modules = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPluginFuncInfo_search_modules_get (const octave_value_list& args, int nargout) { + CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 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("CvPluginFuncInfo_search_modules_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_search_modules_get" "', argument " "1"" of type '" "CvPluginFuncInfo *""'"); + } + arg1 = (CvPluginFuncInfo *)(argp1); + result = (int) ((arg1)->search_modules); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPluginFuncInfo_loaded_from_set (const octave_value_list& args, int nargout) { + CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 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("CvPluginFuncInfo_loaded_from_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_loaded_from_set" "', argument " "1"" of type '" "CvPluginFuncInfo *""'"); + } + arg1 = (CvPluginFuncInfo *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvPluginFuncInfo_loaded_from_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->loaded_from = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvPluginFuncInfo_loaded_from_get (const octave_value_list& args, int nargout) { + CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 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("CvPluginFuncInfo_loaded_from_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvPluginFuncInfo_loaded_from_get" "', argument " "1"" of type '" "CvPluginFuncInfo *""'"); + } + arg1 = (CvPluginFuncInfo *)(argp1); + result = (int) ((arg1)->loaded_from); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvPluginFuncInfo (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPluginFuncInfo *result = 0 ; + + if (!SWIG_check_num_args("new_CvPluginFuncInfo",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvPluginFuncInfo *)new CvPluginFuncInfo(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPluginFuncInfo, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvPluginFuncInfo (const octave_value_list& args, int nargout) { + CvPluginFuncInfo *arg1 = (CvPluginFuncInfo *) 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_CvPluginFuncInfo",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvPluginFuncInfo, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvPluginFuncInfo" "', argument " "1"" of type '" "CvPluginFuncInfo *""'"); + } + arg1 = (CvPluginFuncInfo *)(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_CvPluginFuncInfo_members[] = { +{"func_addr",0,_wrap_CvPluginFuncInfo_func_addr_get,_wrap_CvPluginFuncInfo_func_addr_set,0,0}, +{"default_func_addr",0,_wrap_CvPluginFuncInfo_default_func_addr_get,_wrap_CvPluginFuncInfo_default_func_addr_set,0,0}, +{"func_names",0,_wrap_CvPluginFuncInfo_func_names_get,_wrap_CvPluginFuncInfo_func_names_set,0,0}, +{"search_modules",0,_wrap_CvPluginFuncInfo_search_modules_get,_wrap_CvPluginFuncInfo_search_modules_set,0,0}, +{"loaded_from",0,_wrap_CvPluginFuncInfo_loaded_from_get,_wrap_CvPluginFuncInfo_loaded_from_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvPluginFuncInfo_base_names[] = {0}; +static const swig_type_info *swig_CvPluginFuncInfo_base[] = {0}; +static swig_octave_class _wrap_class_CvPluginFuncInfo = {"CvPluginFuncInfo", &SWIGTYPE_p_CvPluginFuncInfo,0,_wrap_new_CvPluginFuncInfo,0,_wrap_delete_CvPluginFuncInfo,swig_CvPluginFuncInfo_members,swig_CvPluginFuncInfo_base_names,swig_CvPluginFuncInfo_base }; + +static octave_value_list _wrap_CvModuleInfo_next_set (const octave_value_list& args, int nargout) { + CvModuleInfo *arg1 = (CvModuleInfo *) 0 ; + CvModuleInfo *arg2 = (CvModuleInfo *) 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("CvModuleInfo_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_next_set" "', argument " "1"" of type '" "CvModuleInfo *""'"); + } + arg1 = (CvModuleInfo *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvModuleInfo, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvModuleInfo_next_set" "', argument " "2"" of type '" "CvModuleInfo *""'"); + } + arg2 = (CvModuleInfo *)(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_CvModuleInfo_next_get (const octave_value_list& args, int nargout) { + CvModuleInfo *arg1 = (CvModuleInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvModuleInfo *result = 0 ; + + if (!SWIG_check_num_args("CvModuleInfo_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_next_get" "', argument " "1"" of type '" "CvModuleInfo *""'"); + } + arg1 = (CvModuleInfo *)(argp1); + result = (CvModuleInfo *) ((arg1)->next); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvModuleInfo, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvModuleInfo_name_set (const octave_value_list& args, int nargout) { + CvModuleInfo *arg1 = (CvModuleInfo *) 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("CvModuleInfo_name_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_name_set" "', argument " "1"" of type '" "CvModuleInfo *""'"); + } + arg1 = (CvModuleInfo *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvModuleInfo_name_set" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = (char *)(buf2); + if (arg2) { + size_t size = strlen((const char *)((const char *)(arg2))) + 1; + arg1->name = (char const *)(char*)(memcpy((new char[size]), arg2, sizeof(char)*(size))); + } else { + arg1->name = 0; + } + _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_CvModuleInfo_name_get (const octave_value_list& args, int nargout) { + CvModuleInfo *arg1 = (CvModuleInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + char *result = 0 ; + + if (!SWIG_check_num_args("CvModuleInfo_name_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_name_get" "', argument " "1"" of type '" "CvModuleInfo *""'"); + } + arg1 = (CvModuleInfo *)(argp1); + result = (char *) ((arg1)->name); + _outv = SWIG_FromCharPtr((const char *)result); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvModuleInfo_version_set (const octave_value_list& args, int nargout) { + CvModuleInfo *arg1 = (CvModuleInfo *) 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("CvModuleInfo_version_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_version_set" "', argument " "1"" of type '" "CvModuleInfo *""'"); + } + arg1 = (CvModuleInfo *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvModuleInfo_version_set" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = (char *)(buf2); + if (arg2) { + size_t size = strlen((const char *)((const char *)(arg2))) + 1; + arg1->version = (char const *)(char*)(memcpy((new char[size]), arg2, sizeof(char)*(size))); + } else { + arg1->version = 0; + } + _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_CvModuleInfo_version_get (const octave_value_list& args, int nargout) { + CvModuleInfo *arg1 = (CvModuleInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + char *result = 0 ; + + if (!SWIG_check_num_args("CvModuleInfo_version_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_version_get" "', argument " "1"" of type '" "CvModuleInfo *""'"); + } + arg1 = (CvModuleInfo *)(argp1); + result = (char *) ((arg1)->version); + _outv = SWIG_FromCharPtr((const char *)result); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvModuleInfo_func_tab_set (const octave_value_list& args, int nargout) { + CvModuleInfo *arg1 = (CvModuleInfo *) 0 ; + CvPluginFuncInfo *arg2 = (CvPluginFuncInfo *) 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("CvModuleInfo_func_tab_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_func_tab_set" "', argument " "1"" of type '" "CvModuleInfo *""'"); + } + arg1 = (CvModuleInfo *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPluginFuncInfo, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvModuleInfo_func_tab_set" "', argument " "2"" of type '" "CvPluginFuncInfo *""'"); + } + arg2 = (CvPluginFuncInfo *)(argp2); + if (arg1) (arg1)->func_tab = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvModuleInfo_func_tab_get (const octave_value_list& args, int nargout) { + CvModuleInfo *arg1 = (CvModuleInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPluginFuncInfo *result = 0 ; + + if (!SWIG_check_num_args("CvModuleInfo_func_tab_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModuleInfo_func_tab_get" "', argument " "1"" of type '" "CvModuleInfo *""'"); + } + arg1 = (CvModuleInfo *)(argp1); + result = (CvPluginFuncInfo *) ((arg1)->func_tab); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPluginFuncInfo, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvModuleInfo (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvModuleInfo *result = 0 ; + + if (!SWIG_check_num_args("new_CvModuleInfo",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvModuleInfo *)new CvModuleInfo(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvModuleInfo, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvModuleInfo (const octave_value_list& args, int nargout) { + CvModuleInfo *arg1 = (CvModuleInfo *) 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_CvModuleInfo",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvModuleInfo, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvModuleInfo" "', argument " "1"" of type '" "CvModuleInfo *""'"); + } + arg1 = (CvModuleInfo *)(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_CvModuleInfo_members[] = { +{"next",0,_wrap_CvModuleInfo_next_get,_wrap_CvModuleInfo_next_set,0,0}, +{"name",0,_wrap_CvModuleInfo_name_get,_wrap_CvModuleInfo_name_set,0,0}, +{"version",0,_wrap_CvModuleInfo_version_get,_wrap_CvModuleInfo_version_set,0,0}, +{"func_tab",0,_wrap_CvModuleInfo_func_tab_get,_wrap_CvModuleInfo_func_tab_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvModuleInfo_base_names[] = {0}; +static const swig_type_info *swig_CvModuleInfo_base[] = {0}; +static swig_octave_class _wrap_class_CvModuleInfo = {"CvModuleInfo", &SWIGTYPE_p_CvModuleInfo,0,_wrap_new_CvModuleInfo,0,_wrap_delete_CvModuleInfo,swig_CvModuleInfo_members,swig_CvModuleInfo_base_names,swig_CvModuleInfo_base }; + +static octave_value_list _wrap_cvAlloc (const octave_value_list& args, int nargout) { + size_t arg1 ; + size_t val1 ; + int ecode1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + void *result = 0 ; + + if (!SWIG_check_num_args("cvAlloc",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 '" "cvAlloc" "', argument " "1"" of type '" "size_t""'"); + } + arg1 = (size_t)(val1); + { + try { + result = (void *)cvAlloc(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvFree_ (const octave_value_list& args, int nargout) { + void *arg1 = (void *) 0 ; + int res1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvFree_",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0),SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvFree_" "', argument " "1"" of type '" "void *""'"); + } + { + try { + cvFree_(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_cvReleaseImageHeader (const octave_value_list& args, int nargout) { + IplImage **arg1 = (IplImage **) 0 ; + void *vptr1 ; + IplImage *buffer1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvReleaseImageHeader",args.length(),1,1,0)) { + SWIG_fail; + } + { + if ((SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p__IplImage, 1)) == -1){ + SWIG_fail; + } + buffer1 = (IplImage *) vptr1; + arg1=&buffer1; + } + { + try { + cvReleaseImageHeader(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_cvReleaseImage (const octave_value_list& args, int nargout) { + IplImage **arg1 = (IplImage **) 0 ; + void *vptr1 ; + IplImage *buffer1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvReleaseImage",args.length(),1,1,0)) { + SWIG_fail; + } + { + if ((SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p__IplImage, 1)) == -1){ + SWIG_fail; + } + buffer1 = (IplImage *) vptr1; + arg1=&buffer1; + } + { + try { + cvReleaseImage(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_cvResetImageROI (const octave_value_list& args, int nargout) { + IplImage *arg1 = (IplImage *) 0 ; + IplImage header1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvResetImageROI",args.length(),1,1,0)) { + SWIG_fail; + } + { + void * vptr; + int res = SWIG_ConvertPtr(args(0), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg1 = cvGetImage((CvMat *)vptr, &header1); + } + { + try { + cvResetImageROI(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_cvCreateMatHeader (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; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("cvCreateMatHeader",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 '" "cvCreateMatHeader" "', 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 '" "cvCreateMatHeader" "', 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 '" "cvCreateMatHeader" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + { + try { + result = (CvMat *)cvCreateMatHeader(arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvInitMatHeader (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + int arg2 ; + int arg3 ; + int arg4 ; + void *arg5 = (void *) NULL ; + int arg6 = (int) 0x7fffffff ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int res5 ; + int val6 ; + int ecode6 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + if (!SWIG_check_num_args("cvInitMatHeader",args.length(),6,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 '" "cvInitMatHeader" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvInitMatHeader" "', 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 '" "cvInitMatHeader" "', 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 '" "cvInitMatHeader" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + if (4hdr_refcount = ((CvMat *)arg1)->hdr_refcount; + arg2->refcount = ((CvMat *)arg1)->refcount; + cvIncRefData(arg2); + } + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvGetRows (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvMat *arg2 = (CvMat *) 0 ; + int arg3 ; + int arg4 ; + int arg5 = (int) 1 ; + bool freearg1 = false ; + CvMat *header2 ; + 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; + CvMat *result = 0 ; + + { + header2 = (CvMat *)cvAlloc(sizeof(CvMat)); + arg2 = header2; + } + if (!SWIG_check_num_args("cvGetRows",args.length(),4,3,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + ecode3 = SWIG_AsVal_int(args(1), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetRows" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + ecode4 = SWIG_AsVal_int(args(2), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvGetRows" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + if (3hdr_refcount = ((CvMat *)arg1)->hdr_refcount; + arg2->refcount = ((CvMat *)arg1)->refcount; + cvIncRefData(arg2); + } + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvGetRow (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvMat *arg2 = (CvMat *) 0 ; + int arg3 ; + bool freearg1 = false ; + CvMat *header2 ; + int val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + { + header2 = (CvMat *)cvAlloc(sizeof(CvMat)); + arg2 = header2; + } + if (!SWIG_check_num_args("cvGetRow",args.length(),2,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + ecode3 = SWIG_AsVal_int(args(1), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetRow" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + { + try { + result = (CvMat *)cvGetRow((void const *)arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + arg2->hdr_refcount = ((CvMat *)arg1)->hdr_refcount; + arg2->refcount = ((CvMat *)arg1)->refcount; + cvIncRefData(arg2); + } + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvGetCols (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvMat *arg2 = (CvMat *) 0 ; + int arg3 ; + int arg4 ; + bool freearg1 = false ; + CvMat *header2 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + { + header2 = (CvMat *)cvAlloc(sizeof(CvMat)); + arg2 = header2; + } + if (!SWIG_check_num_args("cvGetCols",args.length(),3,3,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + ecode3 = SWIG_AsVal_int(args(1), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetCols" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + ecode4 = SWIG_AsVal_int(args(2), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvGetCols" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + { + try { + result = (CvMat *)cvGetCols((void const *)arg1,arg2,arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + arg2->hdr_refcount = ((CvMat *)arg1)->hdr_refcount; + arg2->refcount = ((CvMat *)arg1)->refcount; + cvIncRefData(arg2); + } + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvGetCol (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvMat *arg2 = (CvMat *) 0 ; + int arg3 ; + bool freearg1 = false ; + CvMat *header2 ; + int val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + { + header2 = (CvMat *)cvAlloc(sizeof(CvMat)); + arg2 = header2; + } + if (!SWIG_check_num_args("cvGetCol",args.length(),2,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + ecode3 = SWIG_AsVal_int(args(1), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvGetCol" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + { + try { + result = (CvMat *)cvGetCol((void const *)arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMat, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + arg2->hdr_refcount = ((CvMat *)arg1)->hdr_refcount; + arg2->refcount = ((CvMat *)arg1)->refcount; + cvIncRefData(arg2); + } + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvGetDiag (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvMat *arg2 = (CvMat *) 0 ; + int arg3 = (int) 0 ; + bool freearg1 = false ; + CvMat *header2 ; + int val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + { + header2 = (CvMat *)cvAlloc(sizeof(CvMat)); + arg2 = header2; + } + if (!SWIG_check_num_args("cvGetDiag",args.length(),2,1,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + if (1hdr_refcount = ((CvMat *)arg1)->hdr_refcount; + arg2->refcount = ((CvMat *)arg1)->refcount; + cvIncRefData(arg2); + } + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvScalarToRawData (const octave_value_list& args, int nargout) { + CvScalar *arg1 = (CvScalar *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + int arg4 = (int) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvScalarToRawData",args.length(),4,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvScalar, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvScalarToRawData" "', argument " "1"" of type '" "CvScalar const *""'"); + } + arg1 = (CvScalar *)(argp1); + res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvScalarToRawData" "', argument " "2"" of type '" "void *""'"); + } + ecode3 = SWIG_AsVal_int(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvScalarToRawData" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + if (3count = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvNArrayIterator_count_get (const octave_value_list& args, int nargout) { + CvNArrayIterator *arg1 = (CvNArrayIterator *) 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("CvNArrayIterator_count_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_count_get" "', argument " "1"" of type '" "CvNArrayIterator *""'"); + } + arg1 = (CvNArrayIterator *)(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_CvNArrayIterator_dims_set (const octave_value_list& args, int nargout) { + CvNArrayIterator *arg1 = (CvNArrayIterator *) 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("CvNArrayIterator_dims_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_dims_set" "', argument " "1"" of type '" "CvNArrayIterator *""'"); + } + arg1 = (CvNArrayIterator *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvNArrayIterator_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_CvNArrayIterator_dims_get (const octave_value_list& args, int nargout) { + CvNArrayIterator *arg1 = (CvNArrayIterator *) 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("CvNArrayIterator_dims_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_dims_get" "', argument " "1"" of type '" "CvNArrayIterator *""'"); + } + arg1 = (CvNArrayIterator *)(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_CvNArrayIterator_size_set (const octave_value_list& args, int nargout) { + CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ; + CvSize *arg2 = (CvSize *) 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("CvNArrayIterator_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_size_set" "', argument " "1"" of type '" "CvNArrayIterator *""'"); + } + arg1 = (CvNArrayIterator *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSize, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNArrayIterator_size_set" "', argument " "2"" of type '" "CvSize *""'"); + } + arg2 = (CvSize *)(argp2); + if (arg1) (arg1)->size = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvNArrayIterator_size_get (const octave_value_list& args, int nargout) { + CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSize *result = 0 ; + + if (!SWIG_check_num_args("CvNArrayIterator_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_size_get" "', argument " "1"" of type '" "CvNArrayIterator *""'"); + } + arg1 = (CvNArrayIterator *)(argp1); + result = (CvSize *)& ((arg1)->size); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSize, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvNArrayIterator_ptr_set (const octave_value_list& args, int nargout) { + CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ; + uchar **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("CvNArrayIterator_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_ptr_set" "', argument " "1"" of type '" "CvNArrayIterator *""'"); + } + arg1 = (CvNArrayIterator *)(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 '" "CvNArrayIterator_ptr_set" "', argument " "2"" of type '" "uchar *[10]""'"); + } + arg2 = (uchar **)(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)10; ++ii) arg1->ptr[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""ptr""' of type '""uchar *[10]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvNArrayIterator_ptr_get (const octave_value_list& args, int nargout) { + CvNArrayIterator *arg1 = (CvNArrayIterator *) 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("CvNArrayIterator_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_ptr_get" "', argument " "1"" of type '" "CvNArrayIterator *""'"); + } + arg1 = (CvNArrayIterator *)(argp1); + result = (uchar **)(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_CvNArrayIterator_stack_set (const octave_value_list& args, int nargout) { + CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ; + int *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("CvNArrayIterator_stack_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_stack_set" "', argument " "1"" of type '" "CvNArrayIterator *""'"); + } + arg1 = (CvNArrayIterator *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNArrayIterator_stack_set" "', argument " "2"" of type '" "int [32]""'"); + } + arg2 = (int *)(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)32; ++ii) arg1->stack[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""stack""' of type '""int [32]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvNArrayIterator_stack_get (const octave_value_list& args, int nargout) { + CvNArrayIterator *arg1 = (CvNArrayIterator *) 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("CvNArrayIterator_stack_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_stack_get" "', argument " "1"" of type '" "CvNArrayIterator *""'"); + } + arg1 = (CvNArrayIterator *)(argp1); + result = (int *)(int *) ((arg1)->stack); + _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_CvNArrayIterator_hdr_set (const octave_value_list& args, int nargout) { + CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ; + CvMatND **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("CvNArrayIterator_hdr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_hdr_set" "', argument " "1"" of type '" "CvNArrayIterator *""'"); + } + arg1 = (CvNArrayIterator *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_CvMatND, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvNArrayIterator_hdr_set" "', argument " "2"" of type '" "CvMatND *[10]""'"); + } + arg2 = (CvMatND **)(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)10; ++ii) arg1->hdr[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""hdr""' of type '""CvMatND *[10]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvNArrayIterator_hdr_get (const octave_value_list& args, int nargout) { + CvNArrayIterator *arg1 = (CvNArrayIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatND **result = 0 ; + + if (!SWIG_check_num_args("CvNArrayIterator_hdr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNArrayIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvNArrayIterator_hdr_get" "', argument " "1"" of type '" "CvNArrayIterator *""'"); + } + arg1 = (CvNArrayIterator *)(argp1); + result = (CvMatND **)(CvMatND **) ((arg1)->hdr); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvMatND, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvNArrayIterator (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvNArrayIterator *result = 0 ; + + if (!SWIG_check_num_args("new_CvNArrayIterator",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvNArrayIterator *)new CvNArrayIterator(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvNArrayIterator, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvNArrayIterator (const octave_value_list& args, int nargout) { + CvNArrayIterator *arg1 = (CvNArrayIterator *) 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_CvNArrayIterator",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvNArrayIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvNArrayIterator" "', argument " "1"" of type '" "CvNArrayIterator *""'"); + } + arg1 = (CvNArrayIterator *)(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_CvNArrayIterator_members[] = { +{"count",0,_wrap_CvNArrayIterator_count_get,_wrap_CvNArrayIterator_count_set,0,0}, +{"dims",0,_wrap_CvNArrayIterator_dims_get,_wrap_CvNArrayIterator_dims_set,0,0}, +{"size",0,_wrap_CvNArrayIterator_size_get,_wrap_CvNArrayIterator_size_set,0,0}, +{"ptr",0,_wrap_CvNArrayIterator_ptr_get,_wrap_CvNArrayIterator_ptr_set,0,0}, +{"stack",0,_wrap_CvNArrayIterator_stack_get,_wrap_CvNArrayIterator_stack_set,0,0}, +{"hdr",0,_wrap_CvNArrayIterator_hdr_get,_wrap_CvNArrayIterator_hdr_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvNArrayIterator_base_names[] = {0}; +static const swig_type_info *swig_CvNArrayIterator_base[] = {0}; +static swig_octave_class _wrap_class_CvNArrayIterator = {"CvNArrayIterator", &SWIGTYPE_p_CvNArrayIterator,0,_wrap_new_CvNArrayIterator,0,_wrap_delete_CvNArrayIterator,swig_CvNArrayIterator_members,swig_CvNArrayIterator_base_names,swig_CvNArrayIterator_base }; + +static octave_value_list _wrap_cvInitNArrayIterator (const octave_value_list& args, int nargout) { + int arg1 ; + CvArr **arg2 = (CvArr **) 0 ; + CvArr *arg3 = (CvArr *) 0 ; + CvMatND *arg4 = (CvMatND *) 0 ; + CvNArrayIterator *arg5 = (CvNArrayIterator *) 0 ; + int arg6 = (int) 0 ; + int val1 ; + int ecode1 = 0 ; + void *vptr2 ; + CvArr *buffer2 ; + bool freearg3 = false ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + int val6 ; + int ecode6 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("cvInitNArrayIterator",args.length(),6,5,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_int(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvInitNArrayIterator" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + { + if ((SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_void, 1)) == -1){ + SWIG_fail; + } + buffer2 = (CvArr *) vptr2; + arg2=&buffer2; + } + { + arg3 = OctObject_to_CvArr(args(2), &freearg3); + } + res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMatND, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvInitNArrayIterator" "', argument " "4"" of type '" "CvMatND *""'"); + } + arg4 = (CvMatND *)(argp4); + res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvNArrayIterator, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvInitNArrayIterator" "', argument " "5"" of type '" "CvNArrayIterator *""'"); + } + arg5 = (CvNArrayIterator *)(argp5); + if (5hdr_refcount = ((CvMat *)arg1)->hdr_refcount; + arg2->refcount = ((CvMat *)arg1)->refcount; + cvIncRefData(arg2); + } + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvReshapeMatND (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + int arg2 ; + CvArr *arg3 = (CvArr *) 0 ; + int arg4 ; + int arg5 ; + int *arg6 = (int *) 0 ; + bool freearg1 = false ; + int val2 ; + int ecode2 = 0 ; + bool freearg3 = false ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvArr *result = 0 ; + + if (!SWIG_check_num_args("cvReshapeMatND",args.length(),6,6,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvReshapeMatND" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + arg3 = OctObject_to_CvArr(args(2), &freearg3); + } + ecode4 = SWIG_AsVal_int(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvReshapeMatND" "', 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 '" "cvReshapeMatND" "', argument " "5"" of type '" "int""'"); + } + arg5 = (int)(val5); + res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvReshapeMatND" "', argument " "6"" of type '" "int *""'"); + } + arg6 = (int *)(argp6); + { + try { + result = (CvArr *)cvReshapeMatND((void const *)arg1,arg2,arg3,arg4,arg5,arg6); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } + { + if(arg3!=NULL && freearg3){ + cvReleaseData( arg3 ); + cvFree(&(arg3)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvReshape (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvMat *arg2 = (CvMat *) 0 ; + int arg3 ; + int arg4 = (int) 0 ; + bool freearg1 = false ; + CvMat *header2 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMat *result = 0 ; + + { + header2 = (CvMat *)cvAlloc(sizeof(CvMat)); + arg2 = header2; + } + if (!SWIG_check_num_args("cvReshape",args.length(),3,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + ecode3 = SWIG_AsVal_int(args(1), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvReshape" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + if (2hdr_refcount = ((CvMat *)arg1)->hdr_refcount; + arg2->refcount = ((CvMat *)arg1)->refcount; + cvIncRefData(arg2); + } + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvRepeat (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + bool freearg1 = false ; + bool freearg2 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvRepeat",args.length(),2,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + try { + cvRepeat((void const *)arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvCreateData (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + bool freearg1 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvCreateData",args.length(),1,1,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + try { + cvCreateData(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvReleaseData (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + bool freearg1 = false ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvReleaseData",args.length(),1,1,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + try { + cvReleaseData(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvSetData (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + bool freearg1 = false ; + int res2 ; + int val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvSetData",args.length(),3,3,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvSetData" "', argument " "2"" of type '" "void *""'"); + } + ecode3 = SWIG_AsVal_int(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvSetData" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + { + try { + cvSetData(arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvGetRawData (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + uchar **arg2 = (uchar **) 0 ; + int *arg3 = (int *) NULL ; + CvSize *arg4 = (CvSize *) NULL ; + bool freearg1 = false ; + 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("cvGetRawData",args.length(),4,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + 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 '" "cvGetRawData" "', argument " "2"" of type '" "uchar **""'"); + } + arg2 = (uchar **)(argp2); + if (2ptr(); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + ecode3 = SWIG_AsVal_int(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvRandArr" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + { + arg4 = OctObject_to_CvScalar( args(3) ); + } + { + arg5 = OctObject_to_CvScalar( args(4) ); + } + { + try { + cvRandArr(arg1,arg2,arg3,arg4,arg5); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvRandShuffle (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvRNG *arg2 = (CvRNG *) 0 ; + double arg3 = (double) 1. ; + bool freearg1 = false ; + void *vptr2 ; + CvRNG_Wrapper *wrapper2 ; + double val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvRandShuffle",args.length(),3,2,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + 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->ptr(); + } + if (2vtx = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphScanner_vtx_get (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvGraphVtx *result = 0 ; + + if (!SWIG_check_num_args("CvGraphScanner_vtx_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_vtx_get" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + result = (CvGraphVtx *) ((arg1)->vtx); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphVtx, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphScanner_dst_set (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 0 ; + CvGraphVtx *arg2 = (CvGraphVtx *) 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("CvGraphScanner_dst_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_dst_set" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvGraphVtx, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphScanner_dst_set" "', argument " "2"" of type '" "CvGraphVtx *""'"); + } + arg2 = (CvGraphVtx *)(argp2); + if (arg1) (arg1)->dst = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphScanner_dst_get (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvGraphVtx *result = 0 ; + + if (!SWIG_check_num_args("CvGraphScanner_dst_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_dst_get" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + result = (CvGraphVtx *) ((arg1)->dst); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphVtx, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphScanner_edge_set (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 0 ; + CvGraphEdge *arg2 = (CvGraphEdge *) 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("CvGraphScanner_edge_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_edge_set" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvGraphEdge, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvGraphScanner_edge_set" "', argument " "2"" of type '" "CvGraphEdge *""'"); + } + arg2 = (CvGraphEdge *)(argp2); + if (arg1) (arg1)->edge = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphScanner_edge_get (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvGraphEdge *result = 0 ; + + if (!SWIG_check_num_args("CvGraphScanner_edge_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_edge_get" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + result = (CvGraphEdge *) ((arg1)->edge); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraphEdge, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphScanner_graph_set (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 0 ; + CvGraph *arg2 = (CvGraph *) 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("CvGraphScanner_graph_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_graph_set" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + { + if( 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 CvGraph"); + SWIG_fail; + } + arg2 = (CvGraph *)ptr2; + } + if (arg1) (arg1)->graph = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphScanner_graph_get (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvGraph *result = 0 ; + + if (!SWIG_check_num_args("CvGraphScanner_graph_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_graph_get" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + result = (CvGraph *) ((arg1)->graph); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvGraph, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphScanner_stack_set (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvGraphScanner_stack_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_stack_set" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->stack = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphScanner_stack_get (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 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("CvGraphScanner_stack_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_stack_get" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + result = (CvSeq *) ((arg1)->stack); + _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_CvGraphScanner_index_set (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 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("CvGraphScanner_index_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_index_set" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraphScanner_index_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->index = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphScanner_index_get (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 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("CvGraphScanner_index_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_index_get" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + result = (int) ((arg1)->index); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphScanner_mask_set (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 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("CvGraphScanner_mask_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_mask_set" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvGraphScanner_mask_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->mask = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvGraphScanner_mask_get (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 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("CvGraphScanner_mask_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvGraphScanner_mask_get" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + result = (int) ((arg1)->mask); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvGraphScanner (const octave_value_list& args, int nargout) { + CvGraphScanner *arg1 = (CvGraphScanner *) 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_CvGraphScanner",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvGraphScanner, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvGraphScanner" "', argument " "1"" of type '" "CvGraphScanner *""'"); + } + arg1 = (CvGraphScanner *)(argp1); + { + try { + delete_CvGraphScanner(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_CvGraphScanner_members[] = { +{"vtx",0,_wrap_CvGraphScanner_vtx_get,_wrap_CvGraphScanner_vtx_set,0,0}, +{"dst",0,_wrap_CvGraphScanner_dst_get,_wrap_CvGraphScanner_dst_set,0,0}, +{"edge",0,_wrap_CvGraphScanner_edge_get,_wrap_CvGraphScanner_edge_set,0,0}, +{"graph",0,_wrap_CvGraphScanner_graph_get,_wrap_CvGraphScanner_graph_set,0,0}, +{"stack",0,_wrap_CvGraphScanner_stack_get,_wrap_CvGraphScanner_stack_set,0,0}, +{"index",0,_wrap_CvGraphScanner_index_get,_wrap_CvGraphScanner_index_set,0,0}, +{"mask",0,_wrap_CvGraphScanner_mask_get,_wrap_CvGraphScanner_mask_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvGraphScanner_base_names[] = {0}; +static const swig_type_info *swig_CvGraphScanner_base[] = {0}; +static swig_octave_class _wrap_class_CvGraphScanner = {"CvGraphScanner", &SWIGTYPE_p_CvGraphScanner,0,0,0,_wrap_delete_CvGraphScanner,swig_CvGraphScanner_members,swig_CvGraphScanner_base_names,swig_CvGraphScanner_base }; + +static octave_value_list _wrap_cvCreateGraphScanner (const octave_value_list& args, int nargout) { + CvGraph *arg1 = (CvGraph *) 0 ; + CvGraphVtx *arg2 = (CvGraphVtx *) NULL ; + int arg3 = (int) -1 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvGraphScanner *result = 0 ; + + if (!SWIG_check_num_args("cvCreateGraphScanner",args.length(),3,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvGraph"); + SWIG_fail; + } + arg1 = (CvGraph *)ptr1; + } + if (1font_face = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_font_face_get (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_font_face_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_font_face_get" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + result = (int) ((arg1)->font_face); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_ascii_set (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_ascii_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_ascii_set" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(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 '" "CvFont_ascii_set" "', argument " "2"" of type '" "int const *""'"); + } + arg2 = (int *)(argp2); + if (arg1) (arg1)->ascii = (int const *)arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_ascii_get (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_ascii_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_ascii_get" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + result = (int *) ((arg1)->ascii); + _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_CvFont_greek_set (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_greek_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_greek_set" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(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 '" "CvFont_greek_set" "', argument " "2"" of type '" "int const *""'"); + } + arg2 = (int *)(argp2); + if (arg1) (arg1)->greek = (int const *)arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_greek_get (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_greek_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_greek_get" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + result = (int *) ((arg1)->greek); + _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_CvFont_cyrillic_set (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_cyrillic_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_cyrillic_set" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(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 '" "CvFont_cyrillic_set" "', argument " "2"" of type '" "int const *""'"); + } + arg2 = (int *)(argp2); + if (arg1) (arg1)->cyrillic = (int const *)arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_cyrillic_get (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_cyrillic_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_cyrillic_get" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + result = (int *) ((arg1)->cyrillic); + _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_CvFont_hscale_set (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_hscale_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_hscale_set" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFont_hscale_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->hscale = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_hscale_get (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_hscale_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_hscale_get" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + result = (float) ((arg1)->hscale); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_vscale_set (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_vscale_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_vscale_set" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFont_vscale_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->vscale = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_vscale_get (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_vscale_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_vscale_get" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + result = (float) ((arg1)->vscale); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_shear_set (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_shear_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_shear_set" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFont_shear_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->shear = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_shear_get (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_shear_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_shear_get" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + result = (float) ((arg1)->shear); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_thickness_set (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_thickness_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_thickness_set" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFont_thickness_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->thickness = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_thickness_get (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_thickness_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_thickness_get" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + result = (int) ((arg1)->thickness); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_dx_set (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_dx_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_dx_set" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFont_dx_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->dx = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_dx_get (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_dx_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_dx_get" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + result = (float) ((arg1)->dx); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_line_type_set (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_line_type_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_line_type_set" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvFont_line_type_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->line_type = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvFont_line_type_get (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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("CvFont_line_type_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvFont_line_type_get" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(argp1); + result = (int) ((arg1)->line_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_new_CvFont (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvFont *result = 0 ; + + if (!SWIG_check_num_args("new_CvFont",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvFont *)new CvFont(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvFont, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvFont (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 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_CvFont",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFont, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvFont" "', argument " "1"" of type '" "CvFont *""'"); + } + arg1 = (CvFont *)(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_CvFont_members[] = { +{"font_face",0,_wrap_CvFont_font_face_get,_wrap_CvFont_font_face_set,0,0}, +{"ascii",0,_wrap_CvFont_ascii_get,_wrap_CvFont_ascii_set,0,0}, +{"greek",0,_wrap_CvFont_greek_get,_wrap_CvFont_greek_set,0,0}, +{"cyrillic",0,_wrap_CvFont_cyrillic_get,_wrap_CvFont_cyrillic_set,0,0}, +{"hscale",0,_wrap_CvFont_hscale_get,_wrap_CvFont_hscale_set,0,0}, +{"vscale",0,_wrap_CvFont_vscale_get,_wrap_CvFont_vscale_set,0,0}, +{"shear",0,_wrap_CvFont_shear_get,_wrap_CvFont_shear_set,0,0}, +{"thickness",0,_wrap_CvFont_thickness_get,_wrap_CvFont_thickness_set,0,0}, +{"dx",0,_wrap_CvFont_dx_get,_wrap_CvFont_dx_set,0,0}, +{"line_type",0,_wrap_CvFont_line_type_get,_wrap_CvFont_line_type_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvFont_base_names[] = {0}; +static const swig_type_info *swig_CvFont_base[] = {0}; +static swig_octave_class _wrap_class_CvFont = {"CvFont", &SWIGTYPE_p_CvFont,0,_wrap_new_CvFont,0,_wrap_delete_CvFont,swig_CvFont_members,swig_CvFont_base_names,swig_CvFont_base }; + +static octave_value_list _wrap_cvInitFont (const octave_value_list& args, int nargout) { + CvFont *arg1 = (CvFont *) 0 ; + int arg2 ; + double arg3 ; + double arg4 ; + double arg5 = (double) 0 ; + int arg6 = (int) 1 ; + int arg7 = (int) 8 ; + double val3 ; + int ecode3 = 0 ; + double val4 ; + int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + int val7 ; + int ecode7 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvInitFont",args.length(),6,3,0)) { + SWIG_fail; + } + { + arg1 = (CvFont *)malloc (sizeof (CvFont)); + arg2 = (int)OctInt_AsLong (args(0)); + if (SWIG_arg_fail(1)) SWIG_fail; + } + ecode3 = SWIG_AsVal_double(args(1), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvInitFont" "', argument " "3"" of type '" "double""'"); + } + arg3 = (double)(val3); + ecode4 = SWIG_AsVal_double(args(2), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvInitFont" "', argument " "4"" of type '" "double""'"); + } + arg4 = (double)(val4); + if (3node = (void const *)arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTreeNodeIterator_node_get (const octave_value_list& args, int nargout) { + CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + void *result = 0 ; + + if (!SWIG_check_num_args("CvTreeNodeIterator_node_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTreeNodeIterator_node_get" "', argument " "1"" of type '" "CvTreeNodeIterator *""'"); + } + arg1 = (CvTreeNodeIterator *)(argp1); + result = (void *) ((arg1)->node); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTreeNodeIterator_level_set (const octave_value_list& args, int nargout) { + CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 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("CvTreeNodeIterator_level_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTreeNodeIterator_level_set" "', argument " "1"" of type '" "CvTreeNodeIterator *""'"); + } + arg1 = (CvTreeNodeIterator *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTreeNodeIterator_level_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->level = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTreeNodeIterator_level_get (const octave_value_list& args, int nargout) { + CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 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("CvTreeNodeIterator_level_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTreeNodeIterator_level_get" "', argument " "1"" of type '" "CvTreeNodeIterator *""'"); + } + arg1 = (CvTreeNodeIterator *)(argp1); + result = (int) ((arg1)->level); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTreeNodeIterator_max_level_set (const octave_value_list& args, int nargout) { + CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 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("CvTreeNodeIterator_max_level_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTreeNodeIterator_max_level_set" "', argument " "1"" of type '" "CvTreeNodeIterator *""'"); + } + arg1 = (CvTreeNodeIterator *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTreeNodeIterator_max_level_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->max_level = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTreeNodeIterator_max_level_get (const octave_value_list& args, int nargout) { + CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 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("CvTreeNodeIterator_max_level_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTreeNodeIterator_max_level_get" "', argument " "1"" of type '" "CvTreeNodeIterator *""'"); + } + arg1 = (CvTreeNodeIterator *)(argp1); + result = (int) ((arg1)->max_level); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvTreeNodeIterator (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTreeNodeIterator *result = 0 ; + + if (!SWIG_check_num_args("new_CvTreeNodeIterator",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTreeNodeIterator *)new CvTreeNodeIterator(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTreeNodeIterator, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvTreeNodeIterator (const octave_value_list& args, int nargout) { + CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 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_CvTreeNodeIterator",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTreeNodeIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTreeNodeIterator" "', argument " "1"" of type '" "CvTreeNodeIterator *""'"); + } + arg1 = (CvTreeNodeIterator *)(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_CvTreeNodeIterator_members[] = { +{"node",0,_wrap_CvTreeNodeIterator_node_get,_wrap_CvTreeNodeIterator_node_set,0,0}, +{"level",0,_wrap_CvTreeNodeIterator_level_get,_wrap_CvTreeNodeIterator_level_set,0,0}, +{"max_level",0,_wrap_CvTreeNodeIterator_max_level_get,_wrap_CvTreeNodeIterator_max_level_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvTreeNodeIterator_base_names[] = {0}; +static const swig_type_info *swig_CvTreeNodeIterator_base[] = {0}; +static swig_octave_class _wrap_class_CvTreeNodeIterator = {"CvTreeNodeIterator", &SWIGTYPE_p_CvTreeNodeIterator,0,_wrap_new_CvTreeNodeIterator,0,_wrap_delete_CvTreeNodeIterator,swig_CvTreeNodeIterator_members,swig_CvTreeNodeIterator_base_names,swig_CvTreeNodeIterator_base }; + +static octave_value_list _wrap_cvInitTreeNodeIterator (const octave_value_list& args, int nargout) { + CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + int val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvInitTreeNodeIterator",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvInitTreeNodeIterator" "', argument " "1"" of type '" "CvTreeNodeIterator *""'"); + } + arg1 = (CvTreeNodeIterator *)(argp1); + res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvInitTreeNodeIterator" "', argument " "2"" of type '" "void const *""'"); + } + ecode3 = SWIG_AsVal_int(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvInitTreeNodeIterator" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + { + try { + cvInitTreeNodeIterator(arg1,(void 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_cvNextTreeNode (const octave_value_list& args, int nargout) { + CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + void *result = 0 ; + + if (!SWIG_check_num_args("cvNextTreeNode",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvNextTreeNode" "', argument " "1"" of type '" "CvTreeNodeIterator *""'"); + } + arg1 = (CvTreeNodeIterator *)(argp1); + { + try { + result = (void *)cvNextTreeNode(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvPrevTreeNode (const octave_value_list& args, int nargout) { + CvTreeNodeIterator *arg1 = (CvTreeNodeIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + void *result = 0 ; + + if (!SWIG_check_num_args("cvPrevTreeNode",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTreeNodeIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvPrevTreeNode" "', argument " "1"" of type '" "CvTreeNodeIterator *""'"); + } + arg1 = (CvTreeNodeIterator *)(argp1); + { + try { + result = (void *)cvPrevTreeNode(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvInsertNodeIntoTree (const octave_value_list& args, int nargout) { + void *arg1 = (void *) 0 ; + void *arg2 = (void *) 0 ; + void *arg3 = (void *) 0 ; + int res1 ; + int res2 ; + int res3 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvInsertNodeIntoTree",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0),SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvInsertNodeIntoTree" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvInsertNodeIntoTree" "', argument " "2"" of type '" "void *""'"); + } + res3 = SWIG_ConvertPtr(args(2),SWIG_as_voidptrptr(&arg3), 0, 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvInsertNodeIntoTree" "', argument " "3"" of type '" "void *""'"); + } + { + try { + cvInsertNodeIntoTree(arg1,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_cvRemoveNodeFromTree (const octave_value_list& args, int nargout) { + void *arg1 = (void *) 0 ; + void *arg2 = (void *) 0 ; + int res1 ; + int res2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvRemoveNodeFromTree",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0),SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvRemoveNodeFromTree" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvRemoveNodeFromTree" "', argument " "2"" of type '" "void *""'"); + } + { + try { + cvRemoveNodeFromTree(arg1,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_cvTreeToNodeSeq (const octave_value_list& args, int nargout) { + void *arg1 = (void *) 0 ; + int arg2 ; + CvMemStorage *arg3 = (CvMemStorage *) 0 ; + int res1 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("cvTreeToNodeSeq",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0),SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvTreeToNodeSeq" "', argument " "1"" of type '" "void const *""'"); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvTreeToNodeSeq" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvTreeToNodeSeq" "', argument " "3"" of type '" "CvMemStorage *""'"); + } + arg3 = (CvMemStorage *)(argp3); + { + try { + result = (CvSeq *)cvTreeToNodeSeq((void const *)arg1,arg2,arg3); + } + 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_cvKMeans2 (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + int arg2 ; + CvArr *arg3 = (CvArr *) 0 ; + CvTermCriteria arg4 ; + int arg5 = (int) 1 ; + CvRNG *arg6 = (CvRNG *) 0 ; + int arg7 = (int) 0 ; + CvArr *arg8 = (CvArr *) 0 ; + double *arg9 = (double *) 0 ; + bool freearg1 = false ; + int val2 ; + int ecode2 = 0 ; + bool freearg3 = false ; + void *argp4 ; + int res4 = 0 ; + int val5 ; + int ecode5 = 0 ; + void *vptr6 ; + CvRNG_Wrapper *wrapper6 ; + int val7 ; + int ecode7 = 0 ; + bool freearg8 = false ; + void *argp9 = 0 ; + int res9 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("cvKMeans2",args.length(),9,4,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvKMeans2" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + arg3 = OctObject_to_CvArr(args(2), &freearg3); + } + { + res4 = SWIG_ConvertPtr(args(3), &argp4, SWIGTYPE_p_CvTermCriteria, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvKMeans2" "', argument " "4"" of type '" "CvTermCriteria""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvKMeans2" "', argument " "4"" of type '" "CvTermCriteria""'"); + } else { + arg4 = *((CvTermCriteria *)(argp4)); + } + } + if (4ptr(); + } + } + if (6clone(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvImage((const CvImage&)(result))), SWIGTYPE_p_CvImage, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvImage_create (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + CvSize arg2 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvImage_create",args.length(),4,4,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_create" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSize, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_create" "', argument " "2"" of type '" "CvSize""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvImage_create" "', argument " "2"" of type '" "CvSize""'"); + } else { + arg2 = *((CvSize *)(argp2)); + } + } + ecode3 = SWIG_AsVal_int(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvImage_create" "', 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 '" "CvImage_create" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + { + try { + (arg1)->create(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_CvImage_release (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvImage_release",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_release" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + (arg1)->release(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvImage_clear (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvImage_clear",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_clear" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(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_CvImage_attach__SWIG_0 (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + IplImage *arg2 = (IplImage *) 0 ; + bool arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + IplImage header2 ; + bool val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvImage_attach",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_attach" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + { + void * vptr; + int res = SWIG_ConvertPtr(args(1), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg2 = cvGetImage((CvMat *)vptr, &header2); + } + ecode3 = SWIG_AsVal_bool(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvImage_attach" "', argument " "3"" of type '" "bool""'"); + } + arg3 = (bool)(val3); + { + try { + (arg1)->attach(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_CvImage_attach__SWIG_1 (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + IplImage *arg2 = (IplImage *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + IplImage header2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvImage_attach",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_attach" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + { + void * vptr; + int res = SWIG_ConvertPtr(args(1), (&vptr), SWIGTYPE_p_CvMat, 0); + if ( res == -1 ){ + SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat"); + SWIG_fail; + } + arg2 = cvGetImage((CvMat *)vptr, &header2); + } + { + try { + (arg1)->attach(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_CvImage_attach (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_CvImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvImage_attach__SWIG_1(args, nargout); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p__IplImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvImage_attach__SWIG_0(args, nargout); + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvImage_detach (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvImage_detach",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_detach" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + (arg1)->detach(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvImage_load__SWIG_0 (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + bool result; + + if (!SWIG_check_num_args("CvImage_load",args.length(),4,4,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_load" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_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 '" "CvImage_load" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + ecode4 = SWIG_AsVal_int(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvImage_load" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + { + try { + result = (bool)(arg1)->load((char const *)arg2,(char const *)arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_From_bool((bool)(result)); + 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_CvImage_load__SWIG_1 (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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; + bool result; + + if (!SWIG_check_num_args("CvImage_load",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_load" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_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 '" "CvImage_load" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + { + try { + result = (bool)(arg1)->load((char const *)arg2,(char const *)arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_From_bool((bool)(result)); + 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_CvImage_load__SWIG_2 (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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; + bool result; + + if (!SWIG_check_num_args("CvImage_load",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_load" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_load" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = (char *)(buf2); + { + try { + result = (bool)(arg1)->load((char const *)arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_From_bool((bool)(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_CvImage_load (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_CvImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvImage_load__SWIG_2(args, nargout); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 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_CvImage_load__SWIG_1(args, nargout); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 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) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvImage_load__SWIG_0(args, nargout); + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvImage_read__SWIG_0 (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + CvFileStorage *arg2 = (CvFileStorage *) 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + bool result; + + if (!SWIG_check_num_args("CvImage_read",args.length(),4,4,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_read" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_read" "', 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 '" "CvImage_read" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvImage_read" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = (char *)(buf4); + { + try { + result = (bool)(arg1)->read(arg2,(char const *)arg3,(char const *)arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_From_bool((bool)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; +fail: + return _out; +} + + +static octave_value_list _wrap_CvImage_read__SWIG_1 (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + CvFileStorage *arg2 = (CvFileStorage *) 0 ; + char *arg3 = (char *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + bool result; + + if (!SWIG_check_num_args("CvImage_read",args.length(),4,4,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_read" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_read" "', 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 '" "CvImage_read" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + ecode4 = SWIG_AsVal_int(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvImage_read" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + { + try { + result = (bool)(arg1)->read(arg2,(char const *)arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_From_bool((bool)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; +fail: + return _out; +} + + +static octave_value_list _wrap_CvImage_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 == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 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) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvImage_read__SWIG_1(args, nargout); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 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) { + int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvImage_read__SWIG_0(args, nargout); + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvImage_save__SWIG_0 (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + int *arg4 = (int *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvImage_save",args.length(),4,4,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_save" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_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 '" "CvImage_save" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvImage_save" "', argument " "4"" of type '" "int const *""'"); + } + arg4 = (int *)(argp4); + { + try { + (arg1)->save((char const *)arg2,(char const *)arg3,(int const *)arg4); + } + 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_CvImage_save__SWIG_1 (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_save",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_save" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_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 '" "CvImage_save" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + { + try { + (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_CvImage_save (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_CvImage, 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_CvImage_save__SWIG_1(args, nargout); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 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) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvImage_save__SWIG_0(args, nargout); + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvImage_write (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_write",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_write" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_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 '" "CvImage_write" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + { + try { + (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_CvImage_show (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_show",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_show" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_show" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = (char *)(buf2); + { + try { + (arg1)->show((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_CvImage_is_valid (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_is_valid",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_is_valid" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = (bool)(arg1)->is_valid(); + } + 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_CvImage_width (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_width",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_width" "', argument " "1"" of type '" "CvImage const *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = (int)((CvImage const *)arg1)->width(); + } + 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_CvImage_height (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_height",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_height" "', argument " "1"" of type '" "CvImage const *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = (int)((CvImage const *)arg1)->height(); + } + 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_CvImage_size (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSize result; + + if (!SWIG_check_num_args("CvImage_size",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_size" "', argument " "1"" of type '" "CvImage const *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = ((CvImage const *)arg1)->size(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvSize((const CvSize&)(result))), SWIGTYPE_p_CvSize, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvImage_roi_size (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSize result; + + if (!SWIG_check_num_args("CvImage_roi_size",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_roi_size" "', argument " "1"" of type '" "CvImage const *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = ((CvImage const *)arg1)->roi_size(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvSize((const CvSize&)(result))), SWIGTYPE_p_CvSize, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvImage_roi (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvRect result; + + if (!SWIG_check_num_args("CvImage_roi",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_roi" "', argument " "1"" of type '" "CvImage const *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = ((CvImage const *)arg1)->roi(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvRect((const CvRect&)(result))), SWIGTYPE_p_CvRect, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvImage_coi (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_coi",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_coi" "', argument " "1"" of type '" "CvImage const *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = (int)((CvImage const *)arg1)->coi(); + } + 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_CvImage_set_roi (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + CvRect 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("CvImage_set_roi",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_set_roi" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvRect, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvImage_set_roi" "', argument " "2"" of type '" "CvRect""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CvImage_set_roi" "', argument " "2"" of type '" "CvRect""'"); + } else { + arg2 = *((CvRect *)(argp2)); + } + } + { + try { + (arg1)->set_roi(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_CvImage_reset_roi (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvImage_reset_roi",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_reset_roi" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + (arg1)->reset_roi(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvImage_set_coi (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_set_coi",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_set_coi" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvImage_set_coi" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + (arg1)->set_coi(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_CvImage_depth (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_depth",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_depth" "', argument " "1"" of type '" "CvImage const *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = (int)((CvImage const *)arg1)->depth(); + } + 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_CvImage_channels (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_channels",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_channels" "', argument " "1"" of type '" "CvImage const *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = (int)((CvImage const *)arg1)->channels(); + } + 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_CvImage_pix_size (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_pix_size",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_pix_size" "', argument " "1"" of type '" "CvImage const *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = (int)((CvImage const *)arg1)->pix_size(); + } + 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_CvImage_data__SWIG_0 (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_data",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_data" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = (uchar *)(arg1)->data(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvImage_data__SWIG_1 (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_data",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_data" "', argument " "1"" of type '" "CvImage const *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = (uchar *)((CvImage const *)arg1)->data(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvImage_data (const octave_value_list& args, int nargout) { + int argc = args.length(); + octave_value_ref argv[1]={ + octave_value_ref(args,0) + }; + + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvImage_data__SWIG_0(args, nargout); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvImage_data__SWIG_1(args, nargout); + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvImage_step (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_step",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_step" "', argument " "1"" of type '" "CvImage const *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = (int)((CvImage const *)arg1)->step(); + } + 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_CvImage_origin (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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("CvImage_origin",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_origin" "', argument " "1"" of type '" "CvImage const *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = (int)((CvImage const *)arg1)->origin(); + } + 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_CvImage_roi_row__SWIG_0 (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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; + uchar *result = 0 ; + + if (!SWIG_check_num_args("CvImage_roi_row",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_roi_row" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvImage_roi_row" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (uchar *)(arg1)->roi_row(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvImage_roi_row__SWIG_1 (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 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; + uchar *result = 0 ; + + if (!SWIG_check_num_args("CvImage_roi_row",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_roi_row" "', argument " "1"" of type '" "CvImage const *""'"); + } + arg1 = (CvImage *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvImage_roi_row" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (uchar *)((CvImage const *)arg1)->roi_row(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvImage_roi_row (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvImage_roi_row__SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvImage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvImage_roi_row__SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvImage_asIplImage (const octave_value_list& args, int nargout) { + CvImage *arg1 = (CvImage *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + IplImage *result = 0 ; + + if (!SWIG_check_num_args("CvImage_asIplImage",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvImage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvImage_asIplImage" "', argument " "1"" of type '" "CvImage *""'"); + } + arg1 = (CvImage *)(argp1); + { + try { + result = (IplImage *)(arg1)->operator IplImage*(); + } + catch (...) + { + SWIG_fail; + } + } + { + SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message."); + SWIG_fail; + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static swig_octave_member swig_CvImage_members[] = { +{"clone",_wrap_CvImage_clone,0,0,0,0}, +{"create",_wrap_CvImage_create,0,0,0,0}, +{"release",_wrap_CvImage_release,0,0,0,0}, +{"clear",_wrap_CvImage_clear,0,0,0,0}, +{"attach",_wrap_CvImage_attach,0,0,0,0}, +{"detach",_wrap_CvImage_detach,0,0,0,0}, +{"load",_wrap_CvImage_load,0,0,0,0}, +{"read",_wrap_CvImage_read,0,0,0,0}, +{"save",_wrap_CvImage_save,0,0,0,0}, +{"write",_wrap_CvImage_write,0,0,0,0}, +{"show",_wrap_CvImage_show,0,0,0,0}, +{"is_valid",_wrap_CvImage_is_valid,0,0,0,0}, +{"width",_wrap_CvImage_width,0,0,0,0}, +{"height",_wrap_CvImage_height,0,0,0,0}, +{"size",_wrap_CvImage_size,0,0,0,0}, +{"roi_size",_wrap_CvImage_roi_size,0,0,0,0}, +{"roi",_wrap_CvImage_roi,0,0,0,0}, +{"coi",_wrap_CvImage_coi,0,0,0,0}, +{"set_roi",_wrap_CvImage_set_roi,0,0,0,0}, +{"reset_roi",_wrap_CvImage_reset_roi,0,0,0,0}, +{"set_coi",_wrap_CvImage_set_coi,0,0,0,0}, +{"depth",_wrap_CvImage_depth,0,0,0,0}, +{"channels",_wrap_CvImage_channels,0,0,0,0}, +{"pix_size",_wrap_CvImage_pix_size,0,0,0,0}, +{"data",_wrap_CvImage_data,0,0,0,0}, +{"step",_wrap_CvImage_step,0,0,0,0}, +{"origin",_wrap_CvImage_origin,0,0,0,0}, +{"roi_row",_wrap_CvImage_roi_row,0,0,0,0}, +{"asIplImage",_wrap_CvImage_asIplImage,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvImage_base_names[] = {0}; +static const swig_type_info *swig_CvImage_base[] = {0}; +static swig_octave_class _wrap_class_CvImage = {"CvImage", &SWIGTYPE_p_CvImage,0,_wrap_new_CvImage,0,_wrap_delete_CvImage,swig_CvImage_members,swig_CvImage_base_names,swig_CvImage_base }; + +static octave_value_list _wrap_new_CvMatrix__SWIG_0 (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvMatrix *)new CvMatrix(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_1 (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; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",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_CvMatrix" "', 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_CvMatrix" "', 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_CvMatrix" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + { + try { + result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_2 (const octave_value_list& args, int nargout) { + int arg1 ; + int arg2 ; + int arg3 ; + CvMat *arg4 = (CvMat *) 0 ; + void *arg5 = (void *) 0 ; + int arg6 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int res5 ; + int val6 ; + int ecode6 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",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_CvMatrix" "', 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_CvMatrix" "', 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_CvMatrix" "', 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 '" "new_CvMatrix" "', argument " "4"" of type '" "CvMat *""'"); + } + arg4 = (CvMat *)(argp4); + res5 = SWIG_ConvertPtr(args(4),SWIG_as_voidptrptr(&arg5), 0, 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvMatrix" "', argument " "5"" of type '" "void *""'"); + } + ecode6 = SWIG_AsVal_int(args(5), &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CvMatrix" "', argument " "6"" of type '" "int""'"); + } + arg6 = (int)(val6); + { + try { + result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4,arg5,arg6); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_3 (const octave_value_list& args, int nargout) { + int arg1 ; + int arg2 ; + int arg3 ; + CvMat *arg4 = (CvMat *) 0 ; + void *arg5 = (void *) 0 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int res5 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",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_CvMatrix" "', 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_CvMatrix" "', 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_CvMatrix" "', 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 '" "new_CvMatrix" "', argument " "4"" of type '" "CvMat *""'"); + } + arg4 = (CvMat *)(argp4); + res5 = SWIG_ConvertPtr(args(4),SWIG_as_voidptrptr(&arg5), 0, 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CvMatrix" "', argument " "5"" of type '" "void *""'"); + } + { + try { + result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4,arg5); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_4 (const octave_value_list& args, int nargout) { + int arg1 ; + int arg2 ; + int arg3 ; + CvMat *arg4 = (CvMat *) 0 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",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_CvMatrix" "', 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_CvMatrix" "', 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_CvMatrix" "', 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 '" "new_CvMatrix" "', argument " "4"" of type '" "CvMat *""'"); + } + arg4 = (CvMat *)(argp4); + { + try { + result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_5 (const octave_value_list& args, int nargout) { + int arg1 ; + int arg2 ; + int arg3 ; + CvMemStorage *arg4 = (CvMemStorage *) 0 ; + bool arg5 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",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_CvMatrix" "', 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_CvMatrix" "', 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_CvMatrix" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvMatrix" "', argument " "4"" of type '" "CvMemStorage *""'"); + } + arg4 = (CvMemStorage *)(argp4); + ecode5 = SWIG_AsVal_bool(args(4), &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CvMatrix" "', argument " "5"" of type '" "bool""'"); + } + arg5 = (bool)(val5); + { + try { + result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4,arg5); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_6 (const octave_value_list& args, int nargout) { + int arg1 ; + int arg2 ; + int arg3 ; + CvMemStorage *arg4 = (CvMemStorage *) 0 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",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_CvMatrix" "', 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_CvMatrix" "', 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_CvMatrix" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvMatrix" "', argument " "4"" of type '" "CvMemStorage *""'"); + } + arg4 = (CvMemStorage *)(argp4); + { + try { + result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_7 (const octave_value_list& args, int nargout) { + int arg1 ; + int arg2 ; + int arg3 ; + void *arg4 = (void *) 0 ; + int arg5 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int res4 ; + int val5 ; + int ecode5 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",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_CvMatrix" "', 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_CvMatrix" "', 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_CvMatrix" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + res4 = SWIG_ConvertPtr(args(3),SWIG_as_voidptrptr(&arg4), 0, 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvMatrix" "', argument " "4"" of type '" "void *""'"); + } + ecode5 = SWIG_AsVal_int(args(4), &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CvMatrix" "', argument " "5"" of type '" "int""'"); + } + arg5 = (int)(val5); + { + try { + result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4,arg5); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_8 (const octave_value_list& args, int nargout) { + int arg1 ; + int arg2 ; + int arg3 ; + void *arg4 = (void *) 0 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int res4 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",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_CvMatrix" "', 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_CvMatrix" "', 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_CvMatrix" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + res4 = SWIG_ConvertPtr(args(3),SWIG_as_voidptrptr(&arg4), 0, 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CvMatrix" "', argument " "4"" of type '" "void *""'"); + } + { + try { + result = (CvMatrix *)new CvMatrix(arg1,arg2,arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_9 (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; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",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_CvMatrix" "', argument " "1"" of type '" "CvMat *""'"); + } + arg1 = (CvMat *)(argp1); + { + try { + result = (CvMatrix *)new CvMatrix(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_10 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = 0 ; + void *argp1 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1, SWIGTYPE_p_CvMatrix, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "CvMatrix const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CvMatrix" "', argument " "1"" of type '" "CvMatrix const &""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = (CvMatrix *)new CvMatrix((CvMatrix const &)*arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_11 (const octave_value_list& args, int nargout) { + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = (char *)(buf1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = (char *)(buf2); + ecode3 = SWIG_AsVal_int(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMatrix" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + { + try { + result = (CvMatrix *)new CvMatrix((char const *)arg1,(char const *)arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_12 (const octave_value_list& args, int nargout) { + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = (char *)(buf1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = (char *)(buf2); + { + try { + result = (CvMatrix *)new CvMatrix((char const *)arg1,(char const *)arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_13 (const octave_value_list& args, int nargout) { + char *arg1 = (char *) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = (char *)(buf1); + { + try { + result = (CvMatrix *)new CvMatrix((char const *)arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix__SWIG_14 (const octave_value_list& args, int nargout) { + CvFileStorage *arg1 = (CvFileStorage *) 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; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "CvFileStorage *""'"); + } + arg1 = (CvFileStorage *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvMatrix" "', 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 '" "new_CvMatrix" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + { + try { + result = (CvMatrix *)new CvMatrix(arg1,(char const *)arg2,(char const *)arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + 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_new_CvMatrix__SWIG_15 (const octave_value_list& args, int nargout) { + CvFileStorage *arg1 = (CvFileStorage *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvFileStorage, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvMatrix" "', argument " "1"" of type '" "CvFileStorage *""'"); + } + arg1 = (CvFileStorage *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CvMatrix" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = (char *)(buf2); + ecode3 = SWIG_AsVal_int(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CvMatrix" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + { + try { + result = (CvMatrix *)new CvMatrix(arg1,(char const *)arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix (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_CvMatrix__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_CvMatrix__SWIG_9(args, nargout); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvMatrix__SWIG_10(args, nargout); + } + } + if (argc == 1) { + int _v; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvMatrix__SWIG_13(args, nargout); + } + } + if (argc == 2) { + int _v; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvMatrix__SWIG_12(args, nargout); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvFileStorage, 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_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_CvMatrix__SWIG_15(args, nargout); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvFileStorage, 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_new_CvMatrix__SWIG_14(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_CvMatrix__SWIG_1(args, nargout); + } + } + } + } + if (argc == 3) { + int _v; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 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_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_CvMatrix__SWIG_11(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_CvMemStorage, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvMatrix__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_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvMatrix__SWIG_4(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 *ptr = 0; + int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvMatrix__SWIG_8(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_CvMemStorage, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_CvMatrix__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_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvMatrix__SWIG_3(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 *ptr = 0; + int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_CvMatrix__SWIG_7(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_CvMat, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_CvMatrix__SWIG_2(args, nargout); + } + } + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_delete_CvMatrix (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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_CvMatrix",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMatrix" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(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_CvMatrix_clone (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix result; + + if (!SWIG_check_num_args("CvMatrix_clone",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_clone" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = (arg1)->clone(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvMatrix((const CvMatrix&)(result))), SWIGTYPE_p_CvMatrix, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatrix_set (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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; + + if (!SWIG_check_num_args("CvMatrix_set",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_set" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMat, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + ecode3 = SWIG_AsVal_bool(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMatrix_set" "', argument " "3"" of type '" "bool""'"); + } + arg3 = (bool)(val3); + { + try { + (arg1)->set(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_CvMatrix_create (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 0 ; + int arg2 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvMatrix_create",args.length(),4,4,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_create" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatrix_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 '" "CvMatrix_create" "', 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 '" "CvMatrix_create" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + { + try { + (arg1)->create(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_CvMatrix_addref (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvMatrix_addref",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_addref" "', argument " "1"" of type '" "CvMatrix const *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + ((CvMatrix const *)arg1)->addref(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatrix_release (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvMatrix_release",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_release" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + (arg1)->release(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatrix_clear (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvMatrix_clear",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_clear" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(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_CvMatrix_load__SWIG_0 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + bool result; + + if (!SWIG_check_num_args("CvMatrix_load",args.length(),4,4,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_load" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_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 '" "CvMatrix_load" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + ecode4 = SWIG_AsVal_int(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMatrix_load" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + { + try { + result = (bool)(arg1)->load((char const *)arg2,(char const *)arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_From_bool((bool)(result)); + 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_CvMatrix_load__SWIG_1 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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; + bool result; + + if (!SWIG_check_num_args("CvMatrix_load",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_load" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_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 '" "CvMatrix_load" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + { + try { + result = (bool)(arg1)->load((char const *)arg2,(char const *)arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_From_bool((bool)(result)); + 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_CvMatrix_load__SWIG_2 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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; + bool result; + + if (!SWIG_check_num_args("CvMatrix_load",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_load" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_load" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = (char *)(buf2); + { + try { + result = (bool)(arg1)->load((char const *)arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_From_bool((bool)(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_CvMatrix_load (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_CvMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMatrix_load__SWIG_2(args, nargout); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 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_CvMatrix_load__SWIG_1(args, nargout); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 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) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMatrix_load__SWIG_0(args, nargout); + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMatrix_read__SWIG_0 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 0 ; + CvFileStorage *arg2 = (CvFileStorage *) 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + bool result; + + if (!SWIG_check_num_args("CvMatrix_read",args.length(),4,4,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_read" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_read" "', 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 '" "CvMatrix_read" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvMatrix_read" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = (char *)(buf4); + { + try { + result = (bool)(arg1)->read(arg2,(char const *)arg3,(char const *)arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_From_bool((bool)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatrix_read__SWIG_1 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 0 ; + CvFileStorage *arg2 = (CvFileStorage *) 0 ; + char *arg3 = (char *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + bool result; + + if (!SWIG_check_num_args("CvMatrix_read",args.length(),4,4,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_read" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_read" "', 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 '" "CvMatrix_read" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + ecode4 = SWIG_AsVal_int(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CvMatrix_read" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + { + try { + result = (bool)(arg1)->read(arg2,(char const *)arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_From_bool((bool)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatrix_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 == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 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) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMatrix_read__SWIG_1(args, nargout); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 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) { + int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMatrix_read__SWIG_0(args, nargout); + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMatrix_save__SWIG_0 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + int *arg4 = (int *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvMatrix_save",args.length(),4,4,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_save" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_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 '" "CvMatrix_save" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + res4 = SWIG_ConvertPtr(args(3), &argp4,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CvMatrix_save" "', argument " "4"" of type '" "int const *""'"); + } + arg4 = (int *)(argp4); + { + try { + (arg1)->save((char const *)arg2,(char const *)arg3,(int const *)arg4); + } + 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_CvMatrix_save__SWIG_1 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_save",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_save" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_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 '" "CvMatrix_save" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + { + try { + (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_CvMatrix_save (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_CvMatrix, 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_CvMatrix_save__SWIG_1(args, nargout); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 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) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMatrix_save__SWIG_0(args, nargout); + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMatrix_write (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_write",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_write" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvFileStorage, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_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 '" "CvMatrix_write" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = (char *)(buf3); + { + try { + (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_CvMatrix_show (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_show",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_show" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_show" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = (char *)(buf2); + { + try { + (arg1)->show((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_CvMatrix_is_valid (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_is_valid",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_is_valid" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = (bool)(arg1)->is_valid(); + } + 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_CvMatrix_rows (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_rows",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_rows" "', argument " "1"" of type '" "CvMatrix const *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = (int)((CvMatrix const *)arg1)->rows(); + } + 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_CvMatrix_cols (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_cols",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_cols" "', argument " "1"" of type '" "CvMatrix const *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = (int)((CvMatrix const *)arg1)->cols(); + } + 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_CvMatrix_size (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSize result; + + if (!SWIG_check_num_args("CvMatrix_size",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_size" "', argument " "1"" of type '" "CvMatrix const *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = ((CvMatrix const *)arg1)->size(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvSize((const CvSize&)(result))), SWIGTYPE_p_CvSize, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatrix_type (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_type",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_type" "', argument " "1"" of type '" "CvMatrix const *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = (int)((CvMatrix const *)arg1)->type(); + } + 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_CvMatrix_depth (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_depth",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_depth" "', argument " "1"" of type '" "CvMatrix const *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = (int)((CvMatrix const *)arg1)->depth(); + } + 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_CvMatrix_channels (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_channels",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_channels" "', argument " "1"" of type '" "CvMatrix const *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = (int)((CvMatrix const *)arg1)->channels(); + } + 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_CvMatrix_pix_size (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_pix_size",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_pix_size" "', argument " "1"" of type '" "CvMatrix const *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = (int)((CvMatrix const *)arg1)->pix_size(); + } + 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_CvMatrix_data__SWIG_0 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_data",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_data" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = (uchar *)(arg1)->data(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatrix_data__SWIG_1 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_data",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_data" "', argument " "1"" of type '" "CvMatrix const *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = (uchar *)((CvMatrix const *)arg1)->data(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatrix_data (const octave_value_list& args, int nargout) { + int argc = args.length(); + octave_value_ref argv[1]={ + octave_value_ref(args,0) + }; + + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMatrix_data__SWIG_0(args, nargout); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMatrix_data__SWIG_1(args, nargout); + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMatrix_step (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_step",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_step" "', argument " "1"" of type '" "CvMatrix const *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = (int)((CvMatrix const *)arg1)->step(); + } + 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_CvMatrix_set_data__SWIG_0 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + int val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvMatrix_set_data",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_set_data" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_set_data" "', argument " "2"" of type '" "void *""'"); + } + ecode3 = SWIG_AsVal_int(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CvMatrix_set_data" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + { + try { + (arg1)->set_data(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_CvMatrix_set_data__SWIG_1 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 0 ; + void *arg2 = (void *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvMatrix_set_data",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_set_data" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix_set_data" "', argument " "2"" of type '" "void *""'"); + } + { + try { + (arg1)->set_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_CvMatrix_set_data (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_CvMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CvMatrix_set_data__SWIG_1(args, nargout); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMatrix_set_data__SWIG_0(args, nargout); + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMatrix_row__SWIG_0 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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; + uchar *result = 0 ; + + if (!SWIG_check_num_args("CvMatrix_row",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_row" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatrix_row" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (uchar *)(arg1)->row(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatrix_row__SWIG_1 (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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; + uchar *result = 0 ; + + if (!SWIG_check_num_args("CvMatrix_row",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_row" "', argument " "1"" of type '" "CvMatrix const *""'"); + } + arg1 = (CvMatrix *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMatrix_row" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (uchar *)((CvMatrix const *)arg1)->row(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatrix_row (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 == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMatrix_row__SWIG_0(args, nargout); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CvMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CvMatrix_row__SWIG_1(args, nargout); + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_CvMatrix_asCvMat (const octave_value_list& args, int nargout) { + CvMatrix *arg1 = (CvMatrix *) 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("CvMatrix_asCvMat",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix_asCvMat" "', argument " "1"" of type '" "CvMatrix *""'"); + } + arg1 = (CvMatrix *)(argp1); + { + try { + result = (CvMat *)(arg1)->operator CvMat*(); + } + 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 swig_octave_member swig_CvMatrix_members[] = { +{"clone",_wrap_CvMatrix_clone,0,0,0,0}, +{"set",_wrap_CvMatrix_set,0,0,0,0}, +{"create",_wrap_CvMatrix_create,0,0,0,0}, +{"addref",_wrap_CvMatrix_addref,0,0,0,0}, +{"release",_wrap_CvMatrix_release,0,0,0,0}, +{"clear",_wrap_CvMatrix_clear,0,0,0,0}, +{"load",_wrap_CvMatrix_load,0,0,0,0}, +{"read",_wrap_CvMatrix_read,0,0,0,0}, +{"save",_wrap_CvMatrix_save,0,0,0,0}, +{"write",_wrap_CvMatrix_write,0,0,0,0}, +{"show",_wrap_CvMatrix_show,0,0,0,0}, +{"is_valid",_wrap_CvMatrix_is_valid,0,0,0,0}, +{"rows",_wrap_CvMatrix_rows,0,0,0,0}, +{"cols",_wrap_CvMatrix_cols,0,0,0,0}, +{"size",_wrap_CvMatrix_size,0,0,0,0}, +{"type",_wrap_CvMatrix_type,0,0,0,0}, +{"depth",_wrap_CvMatrix_depth,0,0,0,0}, +{"channels",_wrap_CvMatrix_channels,0,0,0,0}, +{"pix_size",_wrap_CvMatrix_pix_size,0,0,0,0}, +{"data",_wrap_CvMatrix_data,0,0,0,0}, +{"step",_wrap_CvMatrix_step,0,0,0,0}, +{"set_data",_wrap_CvMatrix_set_data,0,0,0,0}, +{"row",_wrap_CvMatrix_row,0,0,0,0}, +{"asCvMat",_wrap_CvMatrix_asCvMat,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvMatrix_base_names[] = {0}; +static const swig_type_info *swig_CvMatrix_base[] = {0}; +static swig_octave_class _wrap_class_CvMatrix = {"CvMatrix", &SWIGTYPE_p_CvMatrix,0,_wrap_new_CvMatrix,0,_wrap_delete_CvMatrix,swig_CvMatrix_members,swig_CvMatrix_base_names,swig_CvMatrix_base }; + +static octave_value_list _wrap_new_CvModule (const octave_value_list& args, int nargout) { + CvModuleInfo *arg1 = (CvModuleInfo *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvModule *result = 0 ; + + if (!SWIG_check_num_args("new_CvModule",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvModuleInfo, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvModule" "', argument " "1"" of type '" "CvModuleInfo *""'"); + } + arg1 = (CvModuleInfo *)(argp1); + { + try { + result = (CvModule *)new CvModule(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvModule, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvModule (const octave_value_list& args, int nargout) { + CvModule *arg1 = (CvModule *) 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_CvModule",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvModule, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvModule" "', argument " "1"" of type '" "CvModule *""'"); + } + arg1 = (CvModule *)(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_CvModule_info_set (const octave_value_list& args, int nargout) { + CvModule *arg1 = (CvModule *) 0 ; + CvModuleInfo *arg2 = (CvModuleInfo *) 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("CvModule_info_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvModule, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModule_info_set" "', argument " "1"" of type '" "CvModule *""'"); + } + arg1 = (CvModule *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvModuleInfo, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvModule_info_set" "', argument " "2"" of type '" "CvModuleInfo *""'"); + } + arg2 = (CvModuleInfo *)(argp2); + if (arg1) (arg1)->info = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvModule_info_get (const octave_value_list& args, int nargout) { + CvModule *arg1 = (CvModule *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvModuleInfo *result = 0 ; + + if (!SWIG_check_num_args("CvModule_info_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvModule, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvModule_info_get" "', argument " "1"" of type '" "CvModule *""'"); + } + arg1 = (CvModule *)(argp1); + result = (CvModuleInfo *) ((arg1)->info); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvModuleInfo, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvModule_first_set(const octave_value_list& args,int nargout) { + if (!SWIG_check_num_args("CvModule_first_set",args.length(),1,1,0)) return octave_value_list(); + + { + void *argp = 0; + int res = SWIG_ConvertPtr(args(0), &argp, SWIGTYPE_p_CvModuleInfo, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in variable '""CvModule::first""' of type '""CvModuleInfo *""'"); + } + CvModule::first = (CvModuleInfo *)(argp); + } +fail: + return octave_value_list(); +} + + +static octave_value_list _wrap_CvModule_first_get(const octave_value_list& args,int nargout) { + octave_value obj; + + obj = SWIG_NewPointerObj(SWIG_as_voidptr(CvModule::first), SWIGTYPE_p_CvModuleInfo, 0 ); + return obj; +} + + +static octave_value_list _wrap_CvModule_last_set(const octave_value_list& args,int nargout) { + if (!SWIG_check_num_args("CvModule_last_set",args.length(),1,1,0)) return octave_value_list(); + + { + void *argp = 0; + int res = SWIG_ConvertPtr(args(0), &argp, SWIGTYPE_p_CvModuleInfo, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in variable '""CvModule::last""' of type '""CvModuleInfo *""'"); + } + CvModule::last = (CvModuleInfo *)(argp); + } +fail: + return octave_value_list(); +} + + +static octave_value_list _wrap_CvModule_last_get(const octave_value_list& args,int nargout) { + octave_value obj; + + obj = SWIG_NewPointerObj(SWIG_as_voidptr(CvModule::last), SWIGTYPE_p_CvModuleInfo, 0 ); + return obj; +} + + +static swig_octave_member swig_CvModule_members[] = { +{"info",0,_wrap_CvModule_info_get,_wrap_CvModule_info_set,0,0}, +{"first",0,_wrap_CvModule_first_get,_wrap_CvModule_first_set,1,0}, +{"last",0,_wrap_CvModule_last_get,_wrap_CvModule_last_set,1,0}, +{0,0,0,0} +}; +static const char *swig_CvModule_base_names[] = {0}; +static const swig_type_info *swig_CvModule_base[] = {0}; +static swig_octave_class _wrap_class_CvModule = {"CvModule", &SWIGTYPE_p_CvModule,0,_wrap_new_CvModule,0,_wrap_delete_CvModule,swig_CvModule_members,swig_CvModule_base_names,swig_CvModule_base }; + +static octave_value_list _wrap_new_CvType__SWIG_0 (const octave_value_list& args, int nargout) { + char *arg1 = (char *) 0 ; + CvIsInstanceFunc arg2 = (CvIsInstanceFunc) 0 ; + CvReleaseFunc arg3 = (CvReleaseFunc) 0 ; + CvReadFunc arg4 = (CvReadFunc) 0 ; + CvWriteFunc arg5 = (CvWriteFunc) 0 ; + CvCloneFunc arg6 = (CvCloneFunc) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvType *result = 0 ; + + if (!SWIG_check_num_args("new_CvType",args.length(),6,6,0)) { + SWIG_fail; + } + res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvType" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = (char *)(buf1); + { + int res = SWIG_ConvertFunctionPtr(args(1), (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__int); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "2"" of type '" "CvIsInstanceFunc""'"); + } + } + { + int res = SWIG_ConvertFunctionPtr(args(2), (void**)(&arg3), SWIGTYPE_p_f_p_p_void__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "3"" of type '" "CvReleaseFunc""'"); + } + } + { + int res = SWIG_ConvertFunctionPtr(args(3), (void**)(&arg4), SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "4"" of type '" "CvReadFunc""'"); + } + } + { + int res = SWIG_ConvertFunctionPtr(args(4), (void**)(&arg5), SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "5"" of type '" "CvWriteFunc""'"); + } + } + { + int res = SWIG_ConvertFunctionPtr(args(5), (void**)(&arg6), SWIGTYPE_p_f_p_q_const__void__p_void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "6"" of type '" "CvCloneFunc""'"); + } + } + { + try { + result = (CvType *)new CvType((char const *)arg1,arg2,arg3,arg4,arg5,arg6); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvType, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvType__SWIG_1 (const octave_value_list& args, int nargout) { + char *arg1 = (char *) 0 ; + CvIsInstanceFunc arg2 = (CvIsInstanceFunc) 0 ; + CvReleaseFunc arg3 = (CvReleaseFunc) 0 ; + CvReadFunc arg4 = (CvReadFunc) 0 ; + CvWriteFunc arg5 = (CvWriteFunc) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvType *result = 0 ; + + if (!SWIG_check_num_args("new_CvType",args.length(),5,5,0)) { + SWIG_fail; + } + res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvType" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = (char *)(buf1); + { + int res = SWIG_ConvertFunctionPtr(args(1), (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__int); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "2"" of type '" "CvIsInstanceFunc""'"); + } + } + { + int res = SWIG_ConvertFunctionPtr(args(2), (void**)(&arg3), SWIGTYPE_p_f_p_p_void__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "3"" of type '" "CvReleaseFunc""'"); + } + } + { + int res = SWIG_ConvertFunctionPtr(args(3), (void**)(&arg4), SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "4"" of type '" "CvReadFunc""'"); + } + } + { + int res = SWIG_ConvertFunctionPtr(args(4), (void**)(&arg5), SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "5"" of type '" "CvWriteFunc""'"); + } + } + { + try { + result = (CvType *)new CvType((char const *)arg1,arg2,arg3,arg4,arg5); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvType, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvType__SWIG_2 (const octave_value_list& args, int nargout) { + char *arg1 = (char *) 0 ; + CvIsInstanceFunc arg2 = (CvIsInstanceFunc) 0 ; + CvReleaseFunc arg3 = (CvReleaseFunc) 0 ; + CvReadFunc arg4 = (CvReadFunc) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvType *result = 0 ; + + if (!SWIG_check_num_args("new_CvType",args.length(),4,4,0)) { + SWIG_fail; + } + res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvType" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = (char *)(buf1); + { + int res = SWIG_ConvertFunctionPtr(args(1), (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__int); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "2"" of type '" "CvIsInstanceFunc""'"); + } + } + { + int res = SWIG_ConvertFunctionPtr(args(2), (void**)(&arg3), SWIGTYPE_p_f_p_p_void__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "3"" of type '" "CvReleaseFunc""'"); + } + } + { + int res = SWIG_ConvertFunctionPtr(args(3), (void**)(&arg4), SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "4"" of type '" "CvReadFunc""'"); + } + } + { + try { + result = (CvType *)new CvType((char const *)arg1,arg2,arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvType, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvType__SWIG_3 (const octave_value_list& args, int nargout) { + char *arg1 = (char *) 0 ; + CvIsInstanceFunc arg2 = (CvIsInstanceFunc) 0 ; + CvReleaseFunc arg3 = (CvReleaseFunc) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvType *result = 0 ; + + if (!SWIG_check_num_args("new_CvType",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvType" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = (char *)(buf1); + { + int res = SWIG_ConvertFunctionPtr(args(1), (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__int); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "2"" of type '" "CvIsInstanceFunc""'"); + } + } + { + int res = SWIG_ConvertFunctionPtr(args(2), (void**)(&arg3), SWIGTYPE_p_f_p_p_void__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "3"" of type '" "CvReleaseFunc""'"); + } + } + { + try { + result = (CvType *)new CvType((char const *)arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvType, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvType__SWIG_4 (const octave_value_list& args, int nargout) { + char *arg1 = (char *) 0 ; + CvIsInstanceFunc arg2 = (CvIsInstanceFunc) 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvType *result = 0 ; + + if (!SWIG_check_num_args("new_CvType",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CvType" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = (char *)(buf1); + { + int res = SWIG_ConvertFunctionPtr(args(1), (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void__int); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_CvType" "', argument " "2"" of type '" "CvIsInstanceFunc""'"); + } + } + { + try { + result = (CvType *)new CvType((char const *)arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvType, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvType (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 == 2) { + int _v; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_q_const__void__int); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvType__SWIG_4(args, nargout); + } + } + } + if (argc == 3) { + int _v; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_q_const__void__int); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_p_void__void); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvType__SWIG_3(args, nargout); + } + } + } + } + if (argc == 4) { + int _v; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_q_const__void__int); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_p_void__void); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[3], &ptr, SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvType__SWIG_2(args, nargout); + } + } + } + } + } + if (argc == 5) { + int _v; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_q_const__void__int); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_p_void__void); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[3], &ptr, SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[4], &ptr, SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvType__SWIG_1(args, nargout); + } + } + } + } + } + } + if (argc == 6) { + int _v; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_p_q_const__void__int); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f_p_p_void__void); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[3], &ptr, SWIGTYPE_p_f_p_CvFileStorage_p_CvFileNode__p_void); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[4], &ptr, SWIGTYPE_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void); + _v = SWIG_CheckState(res); + if (_v) { + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[5], &ptr, SWIGTYPE_p_f_p_q_const__void__p_void); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CvType__SWIG_0(args, nargout); + } + } + } + } + } + } + } + + error("No matching function for overload"); + return octave_value_list(); +} + + +static octave_value_list _wrap_delete_CvType (const octave_value_list& args, int nargout) { + CvType *arg1 = (CvType *) 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_CvType",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvType, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvType" "', argument " "1"" of type '" "CvType *""'"); + } + arg1 = (CvType *)(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_CvType_info_set (const octave_value_list& args, int nargout) { + CvType *arg1 = (CvType *) 0 ; + CvTypeInfo *arg2 = (CvTypeInfo *) 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("CvType_info_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvType_info_set" "', argument " "1"" of type '" "CvType *""'"); + } + arg1 = (CvType *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTypeInfo, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvType_info_set" "', argument " "2"" of type '" "CvTypeInfo *""'"); + } + arg2 = (CvTypeInfo *)(argp2); + if (arg1) (arg1)->info = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvType_info_get (const octave_value_list& args, int nargout) { + CvType *arg1 = (CvType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypeInfo *result = 0 ; + + if (!SWIG_check_num_args("CvType_info_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvType_info_get" "', argument " "1"" of type '" "CvType *""'"); + } + arg1 = (CvType *)(argp1); + result = (CvTypeInfo *) ((arg1)->info); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypeInfo, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvType_first_set(const octave_value_list& args,int nargout) { + if (!SWIG_check_num_args("CvType_first_set",args.length(),1,1,0)) return octave_value_list(); + + { + void *argp = 0; + int res = SWIG_ConvertPtr(args(0), &argp, SWIGTYPE_p_CvTypeInfo, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in variable '""CvType::first""' of type '""CvTypeInfo *""'"); + } + CvType::first = (CvTypeInfo *)(argp); + } +fail: + return octave_value_list(); +} + + +static octave_value_list _wrap_CvType_first_get(const octave_value_list& args,int nargout) { + octave_value obj; + + obj = SWIG_NewPointerObj(SWIG_as_voidptr(CvType::first), SWIGTYPE_p_CvTypeInfo, 0 ); + return obj; +} + + +static octave_value_list _wrap_CvType_last_set(const octave_value_list& args,int nargout) { + if (!SWIG_check_num_args("CvType_last_set",args.length(),1,1,0)) return octave_value_list(); + + { + void *argp = 0; + int res = SWIG_ConvertPtr(args(0), &argp, SWIGTYPE_p_CvTypeInfo, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in variable '""CvType::last""' of type '""CvTypeInfo *""'"); + } + CvType::last = (CvTypeInfo *)(argp); + } +fail: + return octave_value_list(); +} + + +static octave_value_list _wrap_CvType_last_get(const octave_value_list& args,int nargout) { + octave_value obj; + + obj = SWIG_NewPointerObj(SWIG_as_voidptr(CvType::last), SWIGTYPE_p_CvTypeInfo, 0 ); + return obj; +} + + +static swig_octave_member swig_CvType_members[] = { +{"info",0,_wrap_CvType_info_get,_wrap_CvType_info_set,0,0}, +{"first",0,_wrap_CvType_first_get,_wrap_CvType_first_set,1,0}, +{"last",0,_wrap_CvType_last_get,_wrap_CvType_last_set,1,0}, +{0,0,0,0} +}; +static const char *swig_CvType_base_names[] = {0}; +static const swig_type_info *swig_CvType_base[] = {0}; +static swig_octave_class _wrap_class_CvType = {"CvType", &SWIGTYPE_p_CvType,0,_wrap_new_CvType,0,_wrap_delete_CvType,swig_CvType_members,swig_CvType_base_names,swig_CvType_base }; + +static octave_value_list _wrap_CvMoments_m00_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m00_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m00_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m00_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->m00 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m00_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m00_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m00_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->m00); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m10_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m10_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m10_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m10_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->m10 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m10_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m10_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m10_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->m10); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m01_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m01_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m01_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m01_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->m01 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m01_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m01_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m01_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->m01); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m20_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m20_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m20_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m20_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->m20 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m20_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m20_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m20_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->m20); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m11_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m11_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m11_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m11_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->m11 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m11_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m11_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m11_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->m11); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m02_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m02_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m02_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m02_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->m02 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m02_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m02_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m02_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->m02); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m30_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m30_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m30_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m30_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->m30 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m30_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m30_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m30_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->m30); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m21_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m21_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m21_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m21_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->m21 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m21_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m21_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m21_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->m21); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m12_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m12_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m12_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m12_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->m12 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m12_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m12_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m12_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->m12); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m03_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m03_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m03_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_m03_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->m03 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_m03_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_m03_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_m03_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->m03); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu20_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu20_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu20_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu20_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->mu20 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu20_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu20_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu20_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->mu20); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu11_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu11_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu11_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu11_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->mu11 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu11_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu11_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu11_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->mu11); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu02_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu02_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu02_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu02_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->mu02 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu02_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu02_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu02_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->mu02); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu30_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu30_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu30_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu30_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->mu30 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu30_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu30_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu30_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->mu30); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu21_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu21_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu21_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu21_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->mu21 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu21_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu21_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu21_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->mu21); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu12_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu12_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu12_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu12_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->mu12 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu12_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu12_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu12_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->mu12); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu03_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu03_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu03_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_mu03_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->mu03 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_mu03_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_mu03_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_mu03_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->mu03); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_inv_sqrt_m00_set (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_inv_sqrt_m00_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_inv_sqrt_m00_set" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMoments_inv_sqrt_m00_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->inv_sqrt_m00 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMoments_inv_sqrt_m00_get (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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("CvMoments_inv_sqrt_m00_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMoments_inv_sqrt_m00_get" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(argp1); + result = (double) ((arg1)->inv_sqrt_m00); + _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_CvMoments (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMoments *result = 0 ; + + if (!SWIG_check_num_args("new_CvMoments",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvMoments *)new CvMoments(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMoments, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvMoments (const octave_value_list& args, int nargout) { + CvMoments *arg1 = (CvMoments *) 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_CvMoments",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMoments, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMoments" "', argument " "1"" of type '" "CvMoments *""'"); + } + arg1 = (CvMoments *)(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_CvMoments_members[] = { +{"m00",0,_wrap_CvMoments_m00_get,_wrap_CvMoments_m00_set,0,0}, +{"m10",0,_wrap_CvMoments_m10_get,_wrap_CvMoments_m10_set,0,0}, +{"m01",0,_wrap_CvMoments_m01_get,_wrap_CvMoments_m01_set,0,0}, +{"m20",0,_wrap_CvMoments_m20_get,_wrap_CvMoments_m20_set,0,0}, +{"m11",0,_wrap_CvMoments_m11_get,_wrap_CvMoments_m11_set,0,0}, +{"m02",0,_wrap_CvMoments_m02_get,_wrap_CvMoments_m02_set,0,0}, +{"m30",0,_wrap_CvMoments_m30_get,_wrap_CvMoments_m30_set,0,0}, +{"m21",0,_wrap_CvMoments_m21_get,_wrap_CvMoments_m21_set,0,0}, +{"m12",0,_wrap_CvMoments_m12_get,_wrap_CvMoments_m12_set,0,0}, +{"m03",0,_wrap_CvMoments_m03_get,_wrap_CvMoments_m03_set,0,0}, +{"mu20",0,_wrap_CvMoments_mu20_get,_wrap_CvMoments_mu20_set,0,0}, +{"mu11",0,_wrap_CvMoments_mu11_get,_wrap_CvMoments_mu11_set,0,0}, +{"mu02",0,_wrap_CvMoments_mu02_get,_wrap_CvMoments_mu02_set,0,0}, +{"mu30",0,_wrap_CvMoments_mu30_get,_wrap_CvMoments_mu30_set,0,0}, +{"mu21",0,_wrap_CvMoments_mu21_get,_wrap_CvMoments_mu21_set,0,0}, +{"mu12",0,_wrap_CvMoments_mu12_get,_wrap_CvMoments_mu12_set,0,0}, +{"mu03",0,_wrap_CvMoments_mu03_get,_wrap_CvMoments_mu03_set,0,0}, +{"inv_sqrt_m00",0,_wrap_CvMoments_inv_sqrt_m00_get,_wrap_CvMoments_inv_sqrt_m00_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvMoments_base_names[] = {0}; +static const swig_type_info *swig_CvMoments_base[] = {0}; +static swig_octave_class _wrap_class_CvMoments = {"CvMoments", &SWIGTYPE_p_CvMoments,0,_wrap_new_CvMoments,0,_wrap_delete_CvMoments,swig_CvMoments_members,swig_CvMoments_base_names,swig_CvMoments_base }; + +static octave_value_list _wrap_CvHuMoments_hu1_set (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu1_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu1_set" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu1_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->hu1 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHuMoments_hu1_get (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu1_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu1_get" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + result = (double) ((arg1)->hu1); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHuMoments_hu2_set (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu2_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu2_set" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu2_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->hu2 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHuMoments_hu2_get (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu2_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu2_get" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + result = (double) ((arg1)->hu2); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHuMoments_hu3_set (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu3_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu3_set" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu3_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->hu3 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHuMoments_hu3_get (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu3_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu3_get" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + result = (double) ((arg1)->hu3); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHuMoments_hu4_set (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu4_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu4_set" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu4_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->hu4 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHuMoments_hu4_get (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu4_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu4_get" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + result = (double) ((arg1)->hu4); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHuMoments_hu5_set (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu5_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu5_set" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu5_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->hu5 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHuMoments_hu5_get (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu5_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu5_get" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + result = (double) ((arg1)->hu5); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHuMoments_hu6_set (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu6_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu6_set" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu6_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->hu6 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHuMoments_hu6_get (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu6_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu6_get" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + result = (double) ((arg1)->hu6); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHuMoments_hu7_set (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu7_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu7_set" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHuMoments_hu7_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->hu7 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHuMoments_hu7_get (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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("CvHuMoments_hu7_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHuMoments_hu7_get" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(argp1); + result = (double) ((arg1)->hu7); + _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_CvHuMoments (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvHuMoments *result = 0 ; + + if (!SWIG_check_num_args("new_CvHuMoments",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvHuMoments *)new CvHuMoments(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHuMoments, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvHuMoments (const octave_value_list& args, int nargout) { + CvHuMoments *arg1 = (CvHuMoments *) 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_CvHuMoments",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHuMoments, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHuMoments" "', argument " "1"" of type '" "CvHuMoments *""'"); + } + arg1 = (CvHuMoments *)(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_CvHuMoments_members[] = { +{"hu1",0,_wrap_CvHuMoments_hu1_get,_wrap_CvHuMoments_hu1_set,0,0}, +{"hu2",0,_wrap_CvHuMoments_hu2_get,_wrap_CvHuMoments_hu2_set,0,0}, +{"hu3",0,_wrap_CvHuMoments_hu3_get,_wrap_CvHuMoments_hu3_set,0,0}, +{"hu4",0,_wrap_CvHuMoments_hu4_get,_wrap_CvHuMoments_hu4_set,0,0}, +{"hu5",0,_wrap_CvHuMoments_hu5_get,_wrap_CvHuMoments_hu5_set,0,0}, +{"hu6",0,_wrap_CvHuMoments_hu6_get,_wrap_CvHuMoments_hu6_set,0,0}, +{"hu7",0,_wrap_CvHuMoments_hu7_get,_wrap_CvHuMoments_hu7_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvHuMoments_base_names[] = {0}; +static const swig_type_info *swig_CvHuMoments_base[] = {0}; +static swig_octave_class _wrap_class_CvHuMoments = {"CvHuMoments", &SWIGTYPE_p_CvHuMoments,0,_wrap_new_CvHuMoments,0,_wrap_delete_CvHuMoments,swig_CvHuMoments_members,swig_CvHuMoments_base_names,swig_CvHuMoments_base }; + +static octave_value_list _wrap_CvConnectedComp_area_set (const octave_value_list& args, int nargout) { + CvConnectedComp *arg1 = (CvConnectedComp *) 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("CvConnectedComp_area_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_area_set" "', argument " "1"" of type '" "CvConnectedComp *""'"); + } + arg1 = (CvConnectedComp *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvConnectedComp_area_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->area = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConnectedComp_area_get (const octave_value_list& args, int nargout) { + CvConnectedComp *arg1 = (CvConnectedComp *) 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("CvConnectedComp_area_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_area_get" "', argument " "1"" of type '" "CvConnectedComp *""'"); + } + arg1 = (CvConnectedComp *)(argp1); + result = (double) ((arg1)->area); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConnectedComp_value_set (const octave_value_list& args, int nargout) { + CvConnectedComp *arg1 = (CvConnectedComp *) 0 ; + CvScalar *arg2 = (CvScalar *) 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("CvConnectedComp_value_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_value_set" "', argument " "1"" of type '" "CvConnectedComp *""'"); + } + arg1 = (CvConnectedComp *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvScalar, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConnectedComp_value_set" "', argument " "2"" of type '" "CvScalar *""'"); + } + arg2 = (CvScalar *)(argp2); + 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_CvConnectedComp_value_get (const octave_value_list& args, int nargout) { + CvConnectedComp *arg1 = (CvConnectedComp *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvScalar *result = 0 ; + + if (!SWIG_check_num_args("CvConnectedComp_value_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_value_get" "', argument " "1"" of type '" "CvConnectedComp *""'"); + } + arg1 = (CvConnectedComp *)(argp1); + result = (CvScalar *)& ((arg1)->value); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvScalar, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConnectedComp_rect_set (const octave_value_list& args, int nargout) { + CvConnectedComp *arg1 = (CvConnectedComp *) 0 ; + CvRect *arg2 = (CvRect *) 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("CvConnectedComp_rect_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_rect_set" "', argument " "1"" of type '" "CvConnectedComp *""'"); + } + arg1 = (CvConnectedComp *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConnectedComp_rect_set" "', argument " "2"" of type '" "CvRect *""'"); + } + arg2 = (CvRect *)(argp2); + if (arg1) (arg1)->rect = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConnectedComp_rect_get (const octave_value_list& args, int nargout) { + CvConnectedComp *arg1 = (CvConnectedComp *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvRect *result = 0 ; + + if (!SWIG_check_num_args("CvConnectedComp_rect_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_rect_get" "', argument " "1"" of type '" "CvConnectedComp *""'"); + } + arg1 = (CvConnectedComp *)(argp1); + result = (CvRect *)& ((arg1)->rect); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConnectedComp_contour_set (const octave_value_list& args, int nargout) { + CvConnectedComp *arg1 = (CvConnectedComp *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvConnectedComp_contour_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_contour_set" "', argument " "1"" of type '" "CvConnectedComp *""'"); + } + arg1 = (CvConnectedComp *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->contour = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConnectedComp_contour_get (const octave_value_list& args, int nargout) { + CvConnectedComp *arg1 = (CvConnectedComp *) 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("CvConnectedComp_contour_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConnectedComp_contour_get" "', argument " "1"" of type '" "CvConnectedComp *""'"); + } + arg1 = (CvConnectedComp *)(argp1); + result = (CvSeq *) ((arg1)->contour); + _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_new_CvConnectedComp (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvConnectedComp *result = 0 ; + + if (!SWIG_check_num_args("new_CvConnectedComp",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvConnectedComp *)new CvConnectedComp(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvConnectedComp, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvConnectedComp (const octave_value_list& args, int nargout) { + CvConnectedComp *arg1 = (CvConnectedComp *) 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_CvConnectedComp",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConnectedComp, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvConnectedComp" "', argument " "1"" of type '" "CvConnectedComp *""'"); + } + arg1 = (CvConnectedComp *)(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_CvConnectedComp_members[] = { +{"area",0,_wrap_CvConnectedComp_area_get,_wrap_CvConnectedComp_area_set,0,0}, +{"value",0,_wrap_CvConnectedComp_value_get,_wrap_CvConnectedComp_value_set,0,0}, +{"rect",0,_wrap_CvConnectedComp_rect_get,_wrap_CvConnectedComp_rect_set,0,0}, +{"contour",0,_wrap_CvConnectedComp_contour_get,_wrap_CvConnectedComp_contour_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvConnectedComp_base_names[] = {0}; +static const swig_type_info *swig_CvConnectedComp_base[] = {0}; +static swig_octave_class _wrap_class_CvConnectedComp = {"CvConnectedComp", &SWIGTYPE_p_CvConnectedComp,0,_wrap_new_CvConnectedComp,0,_wrap_delete_CvConnectedComp,swig_CvConnectedComp_members,swig_CvConnectedComp_base_names,swig_CvConnectedComp_base }; + +static octave_value_list _wrap_CvChainPtReader_header_size_set (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_header_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_header_size_set" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChainPtReader_header_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->header_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_header_size_get (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_header_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_header_size_get" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + result = (int) ((arg1)->header_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_CvChainPtReader_seq_set (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvChainPtReader_seq_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_seq_set" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->seq = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_seq_get (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_seq_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_seq_get" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + result = (CvSeq *) ((arg1)->seq); + _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_CvChainPtReader_block_set (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 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("CvChainPtReader_block_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_block_set" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChainPtReader_block_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->block = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_block_get (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvChainPtReader_block_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_block_get" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + result = (CvSeqBlock *) ((arg1)->block); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_ptr_set (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_ptr_set" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(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 '" "CvChainPtReader_ptr_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(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_CvChainPtReader_ptr_get (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_ptr_get" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + result = (schar *) ((arg1)->ptr); + _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_CvChainPtReader_block_min_set (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_block_min_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_block_min_set" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(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 '" "CvChainPtReader_block_min_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->block_min = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_block_min_get (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_block_min_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_block_min_get" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + result = (schar *) ((arg1)->block_min); + _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_CvChainPtReader_block_max_set (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_block_max_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_block_max_set" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(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 '" "CvChainPtReader_block_max_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->block_max = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_block_max_get (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_block_max_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_block_max_get" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + result = (schar *) ((arg1)->block_max); + _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_CvChainPtReader_delta_index_set (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_delta_index_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_delta_index_set" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChainPtReader_delta_index_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->delta_index = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_delta_index_get (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_delta_index_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_delta_index_get" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + result = (int) ((arg1)->delta_index); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_prev_elem_set (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_prev_elem_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_prev_elem_set" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(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 '" "CvChainPtReader_prev_elem_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->prev_elem = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_prev_elem_get (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_prev_elem_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_prev_elem_get" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + result = (schar *) ((arg1)->prev_elem); + _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_CvChainPtReader_code_set (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_code_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_code_set" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + ecode2 = SWIG_AsVal_char(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvChainPtReader_code_set" "', argument " "2"" of type '" "char""'"); + } + arg2 = (char)(val2); + if (arg1) (arg1)->code = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_code_get (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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("CvChainPtReader_code_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_code_get" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + result = (char) ((arg1)->code); + _outv = SWIG_From_char((char)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_pt_set (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 0 ; + CvPoint *arg2 = (CvPoint *) 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("CvChainPtReader_pt_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_pt_set" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChainPtReader_pt_set" "', argument " "2"" of type '" "CvPoint *""'"); + } + arg2 = (CvPoint *)(argp2); + if (arg1) (arg1)->pt = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_pt_get (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvChainPtReader_pt_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_pt_get" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + result = (CvPoint *)& ((arg1)->pt); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_deltas_set (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 0 ; + schar (*arg2)[2] ; + 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("CvChainPtReader_deltas_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_deltas_set" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_a_2__signed_char, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvChainPtReader_deltas_set" "', argument " "2"" of type '" "schar [8][2]""'"); + } + arg2 = (schar (*)[2])(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)8; ++ii) { + if (arg2[ii]) { + size_t jj = 0; + for (; jj < (size_t)2; ++jj) arg1->deltas[ii][jj] = arg2[ii][jj]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""deltas""' of type '""schar [8][2]""'"); + } + } + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""deltas""' of type '""schar [8][2]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvChainPtReader_deltas_get (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + schar (*result)[2] = 0 ; + + if (!SWIG_check_num_args("CvChainPtReader_deltas_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvChainPtReader_deltas_get" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(argp1); + result = (schar (*)[2])(schar (*)[2]) ((arg1)->deltas); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_2__signed_char, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvChainPtReader (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvChainPtReader *result = 0 ; + + if (!SWIG_check_num_args("new_CvChainPtReader",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvChainPtReader *)new CvChainPtReader(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvChainPtReader, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvChainPtReader (const octave_value_list& args, int nargout) { + CvChainPtReader *arg1 = (CvChainPtReader *) 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_CvChainPtReader",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvChainPtReader, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvChainPtReader" "', argument " "1"" of type '" "CvChainPtReader *""'"); + } + arg1 = (CvChainPtReader *)(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_CvChainPtReader_members[] = { +{"header_size",0,_wrap_CvChainPtReader_header_size_get,_wrap_CvChainPtReader_header_size_set,0,0}, +{"seq",0,_wrap_CvChainPtReader_seq_get,_wrap_CvChainPtReader_seq_set,0,0}, +{"block",0,_wrap_CvChainPtReader_block_get,_wrap_CvChainPtReader_block_set,0,0}, +{"ptr",0,_wrap_CvChainPtReader_ptr_get,_wrap_CvChainPtReader_ptr_set,0,0}, +{"block_min",0,_wrap_CvChainPtReader_block_min_get,_wrap_CvChainPtReader_block_min_set,0,0}, +{"block_max",0,_wrap_CvChainPtReader_block_max_get,_wrap_CvChainPtReader_block_max_set,0,0}, +{"delta_index",0,_wrap_CvChainPtReader_delta_index_get,_wrap_CvChainPtReader_delta_index_set,0,0}, +{"prev_elem",0,_wrap_CvChainPtReader_prev_elem_get,_wrap_CvChainPtReader_prev_elem_set,0,0}, +{"code",0,_wrap_CvChainPtReader_code_get,_wrap_CvChainPtReader_code_set,0,0}, +{"pt",0,_wrap_CvChainPtReader_pt_get,_wrap_CvChainPtReader_pt_set,0,0}, +{"deltas",0,_wrap_CvChainPtReader_deltas_get,_wrap_CvChainPtReader_deltas_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvChainPtReader_base_names[] = {0}; +static const swig_type_info *swig_CvChainPtReader_base[] = {0}; +static swig_octave_class _wrap_class_CvChainPtReader = {"CvChainPtReader", &SWIGTYPE_p_CvChainPtReader,0,_wrap_new_CvChainPtReader,0,_wrap_delete_CvChainPtReader,swig_CvChainPtReader_members,swig_CvChainPtReader_base_names,swig_CvChainPtReader_base }; + +static octave_value_list _wrap_CvContourTree_flags_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_flags_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContourTree_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_flags_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_flags_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_header_size_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_header_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_header_size_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContourTree_header_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->header_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_header_size_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_header_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_header_size_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (int) ((arg1)->header_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_CvContourTree_h_prev_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvContourTree_h_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_h_prev_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_h_prev_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_h_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_h_prev_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (CvSeq *) ((arg1)->h_prev); + _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_CvContourTree_h_next_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvContourTree_h_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_h_next_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_h_next_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_h_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_h_next_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (CvSeq *) ((arg1)->h_next); + _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_CvContourTree_v_prev_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvContourTree_v_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_v_prev_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_v_prev_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_v_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_v_prev_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (CvSeq *) ((arg1)->v_prev); + _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_CvContourTree_v_next_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvContourTree_v_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_v_next_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_v_next_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_v_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_v_next_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (CvSeq *) ((arg1)->v_next); + _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_CvContourTree_total_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_total_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_total_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContourTree_total_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->total = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_total_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_total_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_total_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (int) ((arg1)->total); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_elem_size_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_elem_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_elem_size_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContourTree_elem_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->elem_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_elem_size_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_elem_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_elem_size_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (int) ((arg1)->elem_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_CvContourTree_block_max_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_block_max_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_block_max_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(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 '" "CvContourTree_block_max_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->block_max = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_block_max_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_block_max_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_block_max_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (schar *) ((arg1)->block_max); + _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_CvContourTree_ptr_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_ptr_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(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 '" "CvContourTree_ptr_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(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_CvContourTree_ptr_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_ptr_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (schar *) ((arg1)->ptr); + _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_CvContourTree_delta_elems_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_delta_elems_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_delta_elems_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvContourTree_delta_elems_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->delta_elems = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_delta_elems_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_delta_elems_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_delta_elems_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (int) ((arg1)->delta_elems); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_storage_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_storage_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_storage_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(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 '" "CvContourTree_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_CvContourTree_storage_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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("CvContourTree_storage_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_storage_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(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_CvContourTree_free_blocks_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 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("CvContourTree_free_blocks_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_free_blocks_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContourTree_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->free_blocks = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_free_blocks_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvContourTree_free_blocks_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_free_blocks_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (CvSeqBlock *) ((arg1)->free_blocks); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_first_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 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("CvContourTree_first_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_first_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContourTree_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->first = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_first_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvContourTree_first_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_first_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (CvSeqBlock *) ((arg1)->first); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_p1_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 0 ; + CvPoint *arg2 = (CvPoint *) 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("CvContourTree_p1_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_p1_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContourTree_p1_set" "', argument " "2"" of type '" "CvPoint *""'"); + } + arg2 = (CvPoint *)(argp2); + if (arg1) (arg1)->p1 = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_p1_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvContourTree_p1_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_p1_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (CvPoint *)& ((arg1)->p1); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_p2_set (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 0 ; + CvPoint *arg2 = (CvPoint *) 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("CvContourTree_p2_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_p2_set" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvContourTree_p2_set" "', argument " "2"" of type '" "CvPoint *""'"); + } + arg2 = (CvPoint *)(argp2); + if (arg1) (arg1)->p2 = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvContourTree_p2_get (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvContourTree_p2_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvContourTree_p2_get" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(argp1); + result = (CvPoint *)& ((arg1)->p2); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvContourTree (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvContourTree *result = 0 ; + + if (!SWIG_check_num_args("new_CvContourTree",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvContourTree *)new CvContourTree(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvContourTree, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvContourTree (const octave_value_list& args, int nargout) { + CvContourTree *arg1 = (CvContourTree *) 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_CvContourTree",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvContourTree, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvContourTree" "', argument " "1"" of type '" "CvContourTree *""'"); + } + arg1 = (CvContourTree *)(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_CvContourTree_members[] = { +{"flags",0,_wrap_CvContourTree_flags_get,_wrap_CvContourTree_flags_set,0,0}, +{"header_size",0,_wrap_CvContourTree_header_size_get,_wrap_CvContourTree_header_size_set,0,0}, +{"h_prev",0,_wrap_CvContourTree_h_prev_get,_wrap_CvContourTree_h_prev_set,0,0}, +{"h_next",0,_wrap_CvContourTree_h_next_get,_wrap_CvContourTree_h_next_set,0,0}, +{"v_prev",0,_wrap_CvContourTree_v_prev_get,_wrap_CvContourTree_v_prev_set,0,0}, +{"v_next",0,_wrap_CvContourTree_v_next_get,_wrap_CvContourTree_v_next_set,0,0}, +{"total",0,_wrap_CvContourTree_total_get,_wrap_CvContourTree_total_set,0,0}, +{"elem_size",0,_wrap_CvContourTree_elem_size_get,_wrap_CvContourTree_elem_size_set,0,0}, +{"block_max",0,_wrap_CvContourTree_block_max_get,_wrap_CvContourTree_block_max_set,0,0}, +{"ptr",0,_wrap_CvContourTree_ptr_get,_wrap_CvContourTree_ptr_set,0,0}, +{"delta_elems",0,_wrap_CvContourTree_delta_elems_get,_wrap_CvContourTree_delta_elems_set,0,0}, +{"storage",0,_wrap_CvContourTree_storage_get,_wrap_CvContourTree_storage_set,0,0}, +{"free_blocks",0,_wrap_CvContourTree_free_blocks_get,_wrap_CvContourTree_free_blocks_set,0,0}, +{"first",0,_wrap_CvContourTree_first_get,_wrap_CvContourTree_first_set,0,0}, +{"p1",0,_wrap_CvContourTree_p1_get,_wrap_CvContourTree_p1_set,0,0}, +{"p2",0,_wrap_CvContourTree_p2_get,_wrap_CvContourTree_p2_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvContourTree_base_names[] = {0}; +static const swig_type_info *swig_CvContourTree_base[] = {0}; +static swig_octave_class _wrap_class_CvContourTree = {"CvContourTree", &SWIGTYPE_p_CvContourTree,0,_wrap_new_CvContourTree,0,_wrap_delete_CvContourTree,swig_CvContourTree_members,swig_CvContourTree_base_names,swig_CvContourTree_base }; + +static octave_value_list _wrap_CvConvexityDefect_start_set (const octave_value_list& args, int nargout) { + CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ; + CvPoint *arg2 = (CvPoint *) 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("CvConvexityDefect_start_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_start_set" "', argument " "1"" of type '" "CvConvexityDefect *""'"); + } + arg1 = (CvConvexityDefect *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConvexityDefect_start_set" "', argument " "2"" of type '" "CvPoint *""'"); + } + arg2 = (CvPoint *)(argp2); + if (arg1) (arg1)->start = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConvexityDefect_start_get (const octave_value_list& args, int nargout) { + CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvConvexityDefect_start_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_start_get" "', argument " "1"" of type '" "CvConvexityDefect *""'"); + } + arg1 = (CvConvexityDefect *)(argp1); + result = (CvPoint *) ((arg1)->start); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConvexityDefect_end_set (const octave_value_list& args, int nargout) { + CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ; + CvPoint *arg2 = (CvPoint *) 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("CvConvexityDefect_end_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_end_set" "', argument " "1"" of type '" "CvConvexityDefect *""'"); + } + arg1 = (CvConvexityDefect *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConvexityDefect_end_set" "', argument " "2"" of type '" "CvPoint *""'"); + } + arg2 = (CvPoint *)(argp2); + if (arg1) (arg1)->end = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConvexityDefect_end_get (const octave_value_list& args, int nargout) { + CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvConvexityDefect_end_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_end_get" "', argument " "1"" of type '" "CvConvexityDefect *""'"); + } + arg1 = (CvConvexityDefect *)(argp1); + result = (CvPoint *) ((arg1)->end); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConvexityDefect_depth_point_set (const octave_value_list& args, int nargout) { + CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ; + CvPoint *arg2 = (CvPoint *) 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("CvConvexityDefect_depth_point_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_depth_point_set" "', argument " "1"" of type '" "CvConvexityDefect *""'"); + } + arg1 = (CvConvexityDefect *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConvexityDefect_depth_point_set" "', argument " "2"" of type '" "CvPoint *""'"); + } + arg2 = (CvPoint *)(argp2); + if (arg1) (arg1)->depth_point = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConvexityDefect_depth_point_get (const octave_value_list& args, int nargout) { + CvConvexityDefect *arg1 = (CvConvexityDefect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvConvexityDefect_depth_point_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_depth_point_get" "', argument " "1"" of type '" "CvConvexityDefect *""'"); + } + arg1 = (CvConvexityDefect *)(argp1); + result = (CvPoint *) ((arg1)->depth_point); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConvexityDefect_depth_set (const octave_value_list& args, int nargout) { + CvConvexityDefect *arg1 = (CvConvexityDefect *) 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("CvConvexityDefect_depth_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_depth_set" "', argument " "1"" of type '" "CvConvexityDefect *""'"); + } + arg1 = (CvConvexityDefect *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvConvexityDefect_depth_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(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_CvConvexityDefect_depth_get (const octave_value_list& args, int nargout) { + CvConvexityDefect *arg1 = (CvConvexityDefect *) 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("CvConvexityDefect_depth_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConvexityDefect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConvexityDefect_depth_get" "', argument " "1"" of type '" "CvConvexityDefect *""'"); + } + arg1 = (CvConvexityDefect *)(argp1); + result = (float) ((arg1)->depth); + _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_CvConvexityDefect (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvConvexityDefect *result = 0 ; + + if (!SWIG_check_num_args("new_CvConvexityDefect",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvConvexityDefect *)new CvConvexityDefect(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvConvexityDefect, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvConvexityDefect (const octave_value_list& args, int nargout) { + CvConvexityDefect *arg1 = (CvConvexityDefect *) 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_CvConvexityDefect",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConvexityDefect, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvConvexityDefect" "', argument " "1"" of type '" "CvConvexityDefect *""'"); + } + arg1 = (CvConvexityDefect *)(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_CvConvexityDefect_members[] = { +{"start",0,_wrap_CvConvexityDefect_start_get,_wrap_CvConvexityDefect_start_set,0,0}, +{"end",0,_wrap_CvConvexityDefect_end_get,_wrap_CvConvexityDefect_end_set,0,0}, +{"depth_point",0,_wrap_CvConvexityDefect_depth_point_get,_wrap_CvConvexityDefect_depth_point_set,0,0}, +{"depth",0,_wrap_CvConvexityDefect_depth_get,_wrap_CvConvexityDefect_depth_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvConvexityDefect_base_names[] = {0}; +static const swig_type_info *swig_CvConvexityDefect_base[] = {0}; +static swig_octave_class _wrap_class_CvConvexityDefect = {"CvConvexityDefect", &SWIGTYPE_p_CvConvexityDefect,0,_wrap_new_CvConvexityDefect,0,_wrap_delete_CvConvexityDefect,swig_CvConvexityDefect_members,swig_CvConvexityDefect_base_names,swig_CvConvexityDefect_base }; + +static octave_value_list _wrap_CvQuadEdge2D_flags_set (const octave_value_list& args, int nargout) { + CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 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("CvQuadEdge2D_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvQuadEdge2D_flags_set" "', argument " "1"" of type '" "CvQuadEdge2D *""'"); + } + arg1 = (CvQuadEdge2D *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvQuadEdge2D_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvQuadEdge2D_flags_get (const octave_value_list& args, int nargout) { + CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 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("CvQuadEdge2D_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvQuadEdge2D_flags_get" "', argument " "1"" of type '" "CvQuadEdge2D *""'"); + } + arg1 = (CvQuadEdge2D *)(argp1); + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvQuadEdge2D_pt_set (const octave_value_list& args, int nargout) { + CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 0 ; + CvSubdiv2DPoint **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("CvQuadEdge2D_pt_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvQuadEdge2D_pt_set" "', argument " "1"" of type '" "CvQuadEdge2D *""'"); + } + arg1 = (CvQuadEdge2D *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_CvSubdiv2DPoint, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvQuadEdge2D_pt_set" "', argument " "2"" of type '" "CvSubdiv2DPoint *[4]""'"); + } + arg2 = (CvSubdiv2DPoint **)(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)4; ++ii) arg1->pt[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""pt""' of type '""CvSubdiv2DPoint *[4]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvQuadEdge2D_pt_get (const octave_value_list& args, int nargout) { + CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSubdiv2DPoint **result = 0 ; + + if (!SWIG_check_num_args("CvQuadEdge2D_pt_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvQuadEdge2D_pt_get" "', argument " "1"" of type '" "CvQuadEdge2D *""'"); + } + arg1 = (CvQuadEdge2D *)(argp1); + result = (CvSubdiv2DPoint **)(CvSubdiv2DPoint **) ((arg1)->pt); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvSubdiv2DPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvQuadEdge2D_next_set (const octave_value_list& args, int nargout) { + CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 0 ; + CvSubdiv2DEdge *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("CvQuadEdge2D_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvQuadEdge2D_next_set" "', argument " "1"" of type '" "CvQuadEdge2D *""'"); + } + arg1 = (CvQuadEdge2D *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_size_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvQuadEdge2D_next_set" "', argument " "2"" of type '" "CvSubdiv2DEdge [4]""'"); + } + arg2 = (CvSubdiv2DEdge *)(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)4; ++ii) arg1->next[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""next""' of type '""CvSubdiv2DEdge [4]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvQuadEdge2D_next_get (const octave_value_list& args, int nargout) { + CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 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("CvQuadEdge2D_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvQuadEdge2D_next_get" "', argument " "1"" of type '" "CvQuadEdge2D *""'"); + } + arg1 = (CvQuadEdge2D *)(argp1); + result = (CvSubdiv2DEdge *)(CvSubdiv2DEdge *) ((arg1)->next); + _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_new_CvQuadEdge2D (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvQuadEdge2D *result = 0 ; + + if (!SWIG_check_num_args("new_CvQuadEdge2D",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvQuadEdge2D *)new CvQuadEdge2D(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvQuadEdge2D, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvQuadEdge2D (const octave_value_list& args, int nargout) { + CvQuadEdge2D *arg1 = (CvQuadEdge2D *) 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_CvQuadEdge2D",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvQuadEdge2D, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvQuadEdge2D" "', argument " "1"" of type '" "CvQuadEdge2D *""'"); + } + arg1 = (CvQuadEdge2D *)(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_CvQuadEdge2D_members[] = { +{"flags",0,_wrap_CvQuadEdge2D_flags_get,_wrap_CvQuadEdge2D_flags_set,0,0}, +{"pt",0,_wrap_CvQuadEdge2D_pt_get,_wrap_CvQuadEdge2D_pt_set,0,0}, +{"next",0,_wrap_CvQuadEdge2D_next_get,_wrap_CvQuadEdge2D_next_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvQuadEdge2D_base_names[] = {0}; +static const swig_type_info *swig_CvQuadEdge2D_base[] = {0}; +static swig_octave_class _wrap_class_CvQuadEdge2D = {"CvQuadEdge2D", &SWIGTYPE_p_CvQuadEdge2D,0,_wrap_new_CvQuadEdge2D,0,_wrap_delete_CvQuadEdge2D,swig_CvQuadEdge2D_members,swig_CvQuadEdge2D_base_names,swig_CvQuadEdge2D_base }; + +static octave_value_list _wrap_CvSubdiv2DPoint_flags_set (const octave_value_list& args, int nargout) { + CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 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("CvSubdiv2DPoint_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DPoint_flags_set" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'"); + } + arg1 = (CvSubdiv2DPoint *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2DPoint_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2DPoint_flags_get (const octave_value_list& args, int nargout) { + CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 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("CvSubdiv2DPoint_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DPoint_flags_get" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'"); + } + arg1 = (CvSubdiv2DPoint *)(argp1); + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2DPoint_first_set (const octave_value_list& args, int nargout) { + CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 0 ; + CvSubdiv2DEdge arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + CvSubdiv2DEdge_Wrapper *wrapper2 ; + CvQuadEdge2D *qedge2 ; + void *vptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSubdiv2DPoint_first_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DPoint_first_set" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'"); + } + arg1 = (CvSubdiv2DPoint *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){ + wrapper2 = (CvSubdiv2DEdge_Wrapper *) vptr2; + arg2 = wrapper2->ref(); + } + else if( SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){ + qedge2 = (CvQuadEdge2D *) vptr2; + arg2 = (CvSubdiv2DEdge)qedge2; + } + else{ + SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge"); + SWIG_fail; + } + } + if (arg1) (arg1)->first = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2DPoint_first_get (const octave_value_list& args, int nargout) { + CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSubdiv2DEdge result; + + if (!SWIG_check_num_args("CvSubdiv2DPoint_first_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DPoint_first_get" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'"); + } + arg1 = (CvSubdiv2DPoint *)(argp1); + result = ((arg1)->first); + { + CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( result ); + _outv = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 1 ); + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2DPoint_pt_set (const octave_value_list& args, int nargout) { + CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 0 ; + CvPoint2D32f *arg2 = (CvPoint2D32f *) 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("CvSubdiv2DPoint_pt_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DPoint_pt_set" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'"); + } + arg1 = (CvSubdiv2DPoint *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2DPoint_pt_set" "', argument " "2"" of type '" "CvPoint2D32f *""'"); + } + arg2 = (CvPoint2D32f *)(argp2); + if (arg1) (arg1)->pt = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2DPoint_pt_get (const octave_value_list& args, int nargout) { + CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint2D32f *result = 0 ; + + if (!SWIG_check_num_args("CvSubdiv2DPoint_pt_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2DPoint_pt_get" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'"); + } + arg1 = (CvSubdiv2DPoint *)(argp1); + result = (CvPoint2D32f *)& ((arg1)->pt); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSubdiv2DPoint (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSubdiv2DPoint *result = 0 ; + + if (!SWIG_check_num_args("new_CvSubdiv2DPoint",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSubdiv2DPoint *)new CvSubdiv2DPoint(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2DPoint, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSubdiv2DPoint (const octave_value_list& args, int nargout) { + CvSubdiv2DPoint *arg1 = (CvSubdiv2DPoint *) 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_CvSubdiv2DPoint",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2DPoint, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSubdiv2DPoint" "', argument " "1"" of type '" "CvSubdiv2DPoint *""'"); + } + arg1 = (CvSubdiv2DPoint *)(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_CvSubdiv2DPoint_members[] = { +{"flags",0,_wrap_CvSubdiv2DPoint_flags_get,_wrap_CvSubdiv2DPoint_flags_set,0,0}, +{"first",0,_wrap_CvSubdiv2DPoint_first_get,_wrap_CvSubdiv2DPoint_first_set,0,0}, +{"pt",0,_wrap_CvSubdiv2DPoint_pt_get,_wrap_CvSubdiv2DPoint_pt_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSubdiv2DPoint_base_names[] = {0}; +static const swig_type_info *swig_CvSubdiv2DPoint_base[] = {0}; +static swig_octave_class _wrap_class_CvSubdiv2DPoint = {"CvSubdiv2DPoint", &SWIGTYPE_p_CvSubdiv2DPoint,0,_wrap_new_CvSubdiv2DPoint,0,_wrap_delete_CvSubdiv2DPoint,swig_CvSubdiv2DPoint_members,swig_CvSubdiv2DPoint_base_names,swig_CvSubdiv2DPoint_base }; + +static octave_value_list _wrap_CvSubdiv2D_flags_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_flags_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_flags_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_flags_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_header_size_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_header_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_header_size_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_header_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->header_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_header_size_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_header_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_header_size_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (int) ((arg1)->header_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_CvSubdiv2D_h_prev_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvSubdiv2D_h_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_h_prev_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_h_prev_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_h_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_h_prev_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (CvSeq *) ((arg1)->h_prev); + _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_CvSubdiv2D_h_next_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvSubdiv2D_h_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_h_next_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->h_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_h_next_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_h_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_h_next_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (CvSeq *) ((arg1)->h_next); + _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_CvSubdiv2D_v_prev_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvSubdiv2D_v_prev_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_v_prev_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_prev = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_v_prev_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_v_prev_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_v_prev_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (CvSeq *) ((arg1)->v_prev); + _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_CvSubdiv2D_v_next_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + CvSeq *arg2 = (CvSeq *) 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("CvSubdiv2D_v_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_v_next_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvSeq, 0) == -1 && + 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_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(1), &ptr2, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg2 = (CvSeq *) ptr2; + } + if (arg1) (arg1)->v_next = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_v_next_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_v_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_v_next_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (CvSeq *) ((arg1)->v_next); + _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_CvSubdiv2D_total_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_total_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_total_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_total_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->total = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_total_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_total_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_total_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (int) ((arg1)->total); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_elem_size_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_elem_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_elem_size_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_elem_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->elem_size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_elem_size_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_elem_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_elem_size_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (int) ((arg1)->elem_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_CvSubdiv2D_block_max_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_block_max_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_block_max_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(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 '" "CvSubdiv2D_block_max_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(argp2); + if (arg1) (arg1)->block_max = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_block_max_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_block_max_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_block_max_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (schar *) ((arg1)->block_max); + _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_CvSubdiv2D_ptr_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_ptr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_ptr_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(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 '" "CvSubdiv2D_ptr_set" "', argument " "2"" of type '" "schar *""'"); + } + arg2 = (schar *)(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_CvSubdiv2D_ptr_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_ptr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_ptr_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (schar *) ((arg1)->ptr); + _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_CvSubdiv2D_delta_elems_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_delta_elems_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_delta_elems_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_delta_elems_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->delta_elems = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_delta_elems_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_delta_elems_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_delta_elems_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (int) ((arg1)->delta_elems); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_storage_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_storage_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_storage_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(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 '" "CvSubdiv2D_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_CvSubdiv2D_storage_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_storage_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_storage_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(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_CvSubdiv2D_free_blocks_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 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("CvSubdiv2D_free_blocks_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_free_blocks_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_free_blocks_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->free_blocks = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_free_blocks_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvSubdiv2D_free_blocks_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_free_blocks_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (CvSeqBlock *) ((arg1)->free_blocks); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_first_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + CvSeqBlock *arg2 = (CvSeqBlock *) 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("CvSubdiv2D_first_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_first_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSeqBlock, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_first_set" "', argument " "2"" of type '" "CvSeqBlock *""'"); + } + arg2 = (CvSeqBlock *)(argp2); + if (arg1) (arg1)->first = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_first_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeqBlock *result = 0 ; + + if (!SWIG_check_num_args("CvSubdiv2D_first_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_first_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (CvSeqBlock *) ((arg1)->first); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSeqBlock, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_free_elems_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + CvSetElem *arg2 = (CvSetElem *) 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("CvSubdiv2D_free_elems_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_free_elems_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSetElem, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_free_elems_set" "', argument " "2"" of type '" "CvSetElem *""'"); + } + arg2 = (CvSetElem *)(argp2); + if (arg1) (arg1)->free_elems = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_free_elems_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSetElem *result = 0 ; + + if (!SWIG_check_num_args("CvSubdiv2D_free_elems_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_free_elems_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (CvSetElem *) ((arg1)->free_elems); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSetElem, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_active_count_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_active_count_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_active_count_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_active_count_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->active_count = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_active_count_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_active_count_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_active_count_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (int) ((arg1)->active_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_CvSubdiv2D_quad_edges_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_quad_edges_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_quad_edges_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_quad_edges_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->quad_edges = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_quad_edges_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_quad_edges_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_quad_edges_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (int) ((arg1)->quad_edges); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_is_geometry_valid_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_is_geometry_valid_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_is_geometry_valid_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSubdiv2D_is_geometry_valid_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->is_geometry_valid = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_is_geometry_valid_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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("CvSubdiv2D_is_geometry_valid_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_is_geometry_valid_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (int) ((arg1)->is_geometry_valid); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_recent_edge_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + CvSubdiv2DEdge arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + CvSubdiv2DEdge_Wrapper *wrapper2 ; + CvQuadEdge2D *qedge2 ; + void *vptr2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSubdiv2D_recent_edge_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_recent_edge_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + { + if( SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){ + wrapper2 = (CvSubdiv2DEdge_Wrapper *) vptr2; + arg2 = wrapper2->ref(); + } + else if( SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){ + qedge2 = (CvQuadEdge2D *) vptr2; + arg2 = (CvSubdiv2DEdge)qedge2; + } + else{ + SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge"); + SWIG_fail; + } + } + if (arg1) (arg1)->recent_edge = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_recent_edge_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSubdiv2DEdge result; + + if (!SWIG_check_num_args("CvSubdiv2D_recent_edge_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_recent_edge_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = ((arg1)->recent_edge); + { + CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( result ); + _outv = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 1 ); + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_topleft_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + CvPoint2D32f *arg2 = (CvPoint2D32f *) 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("CvSubdiv2D_topleft_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_topleft_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_topleft_set" "', argument " "2"" of type '" "CvPoint2D32f *""'"); + } + arg2 = (CvPoint2D32f *)(argp2); + if (arg1) (arg1)->topleft = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_topleft_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint2D32f *result = 0 ; + + if (!SWIG_check_num_args("CvSubdiv2D_topleft_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_topleft_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (CvPoint2D32f *)& ((arg1)->topleft); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_bottomright_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + CvPoint2D32f *arg2 = (CvPoint2D32f *) 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("CvSubdiv2D_bottomright_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_bottomright_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_bottomright_set" "', argument " "2"" of type '" "CvPoint2D32f *""'"); + } + arg2 = (CvPoint2D32f *)(argp2); + if (arg1) (arg1)->bottomright = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_bottomright_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint2D32f *result = 0 ; + + if (!SWIG_check_num_args("CvSubdiv2D_bottomright_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_bottomright_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + result = (CvPoint2D32f *)& ((arg1)->bottomright); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_edges_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + CvTypedSeq< CvQuadEdge2D > *arg2 = (CvTypedSeq< CvQuadEdge2D > *) 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("CvSubdiv2D_edges_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_edges_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_edges_set" "', argument " "2"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'"); + } + arg2 = (CvTypedSeq< CvQuadEdge2D > *)(argp2); + { + try { + CvSubdiv2D_typed_edges_set(arg1,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_CvSubdiv2D_edges_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvQuadEdge2D > *result = 0 ; + + if (!SWIG_check_num_args("CvSubdiv2D_edges_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_edges_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + { + try { + result = (CvTypedSeq< CvQuadEdge2D > *)CvSubdiv2D_typed_edges_get(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_typed_edges_get (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvQuadEdge2D > *result = 0 ; + + if (!SWIG_check_num_args("CvSubdiv2D_typed_edges_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_typed_edges_get" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + { + try { + result = (CvTypedSeq< CvQuadEdge2D > *)CvSubdiv2D_typed_edges_get(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSubdiv2D_typed_edges_set (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 0 ; + CvTypedSeq< CvQuadEdge2D > *arg2 = (CvTypedSeq< CvQuadEdge2D > *) 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("CvSubdiv2D_typed_edges_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSubdiv2D_typed_edges_set" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSubdiv2D_typed_edges_set" "', argument " "2"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'"); + } + arg2 = (CvTypedSeq< CvQuadEdge2D > *)(argp2); + { + try { + CvSubdiv2D_typed_edges_set(arg1,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_new_CvSubdiv2D (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSubdiv2D *result = 0 ; + + if (!SWIG_check_num_args("new_CvSubdiv2D",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSubdiv2D *)new CvSubdiv2D(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2D, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSubdiv2D (const octave_value_list& args, int nargout) { + CvSubdiv2D *arg1 = (CvSubdiv2D *) 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_CvSubdiv2D",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSubdiv2D, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSubdiv2D" "', argument " "1"" of type '" "CvSubdiv2D *""'"); + } + arg1 = (CvSubdiv2D *)(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_CvSubdiv2D_members[] = { +{"flags",0,_wrap_CvSubdiv2D_flags_get,_wrap_CvSubdiv2D_flags_set,0,0}, +{"header_size",0,_wrap_CvSubdiv2D_header_size_get,_wrap_CvSubdiv2D_header_size_set,0,0}, +{"h_prev",0,_wrap_CvSubdiv2D_h_prev_get,_wrap_CvSubdiv2D_h_prev_set,0,0}, +{"h_next",0,_wrap_CvSubdiv2D_h_next_get,_wrap_CvSubdiv2D_h_next_set,0,0}, +{"v_prev",0,_wrap_CvSubdiv2D_v_prev_get,_wrap_CvSubdiv2D_v_prev_set,0,0}, +{"v_next",0,_wrap_CvSubdiv2D_v_next_get,_wrap_CvSubdiv2D_v_next_set,0,0}, +{"total",0,_wrap_CvSubdiv2D_total_get,_wrap_CvSubdiv2D_total_set,0,0}, +{"elem_size",0,_wrap_CvSubdiv2D_elem_size_get,_wrap_CvSubdiv2D_elem_size_set,0,0}, +{"block_max",0,_wrap_CvSubdiv2D_block_max_get,_wrap_CvSubdiv2D_block_max_set,0,0}, +{"ptr",0,_wrap_CvSubdiv2D_ptr_get,_wrap_CvSubdiv2D_ptr_set,0,0}, +{"delta_elems",0,_wrap_CvSubdiv2D_delta_elems_get,_wrap_CvSubdiv2D_delta_elems_set,0,0}, +{"storage",0,_wrap_CvSubdiv2D_storage_get,_wrap_CvSubdiv2D_storage_set,0,0}, +{"free_blocks",0,_wrap_CvSubdiv2D_free_blocks_get,_wrap_CvSubdiv2D_free_blocks_set,0,0}, +{"first",0,_wrap_CvSubdiv2D_first_get,_wrap_CvSubdiv2D_first_set,0,0}, +{"free_elems",0,_wrap_CvSubdiv2D_free_elems_get,_wrap_CvSubdiv2D_free_elems_set,0,0}, +{"active_count",0,_wrap_CvSubdiv2D_active_count_get,_wrap_CvSubdiv2D_active_count_set,0,0}, +{"quad_edges",0,_wrap_CvSubdiv2D_quad_edges_get,_wrap_CvSubdiv2D_quad_edges_set,0,0}, +{"is_geometry_valid",0,_wrap_CvSubdiv2D_is_geometry_valid_get,_wrap_CvSubdiv2D_is_geometry_valid_set,0,0}, +{"recent_edge",0,_wrap_CvSubdiv2D_recent_edge_get,_wrap_CvSubdiv2D_recent_edge_set,0,0}, +{"topleft",0,_wrap_CvSubdiv2D_topleft_get,_wrap_CvSubdiv2D_topleft_set,0,0}, +{"bottomright",0,_wrap_CvSubdiv2D_bottomright_get,_wrap_CvSubdiv2D_bottomright_set,0,0}, +{"edges",0,_wrap_CvSubdiv2D_edges_get,_wrap_CvSubdiv2D_edges_set,0,0}, +{"typed_edges_get",_wrap_CvSubdiv2D_typed_edges_get,0,0,0,0}, +{"typed_edges_set",_wrap_CvSubdiv2D_typed_edges_set,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSubdiv2D_base_names[] = {0}; +static const swig_type_info *swig_CvSubdiv2D_base[] = {0}; +static swig_octave_class _wrap_class_CvSubdiv2D = {"CvSubdiv2D", &SWIGTYPE_p_CvSubdiv2D,0,_wrap_new_CvSubdiv2D,0,_wrap_delete_CvSubdiv2D,swig_CvSubdiv2D_members,swig_CvSubdiv2D_base_names,swig_CvSubdiv2D_base }; + +static octave_value_list _wrap_CvMatrix3_m_set (const octave_value_list& args, int nargout) { + CvMatrix3 *arg1 = (CvMatrix3 *) 0 ; + float (*arg2)[3] ; + 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("CvMatrix3_m_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix3_m_set" "', argument " "1"" of type '" "CvMatrix3 *""'"); + } + arg1 = (CvMatrix3 *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_a_3__float, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvMatrix3_m_set" "', argument " "2"" of type '" "float [3][3]""'"); + } + arg2 = (float (*)[3])(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)3; ++ii) { + if (arg2[ii]) { + size_t jj = 0; + for (; jj < (size_t)3; ++jj) arg1->m[ii][jj] = arg2[ii][jj]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""m""' of type '""float [3][3]""'"); + } + } + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""m""' of type '""float [3][3]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMatrix3_m_get (const octave_value_list& args, int nargout) { + CvMatrix3 *arg1 = (CvMatrix3 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + float (*result)[3] = 0 ; + + if (!SWIG_check_num_args("CvMatrix3_m_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix3, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMatrix3_m_get" "', argument " "1"" of type '" "CvMatrix3 *""'"); + } + arg1 = (CvMatrix3 *)(argp1); + result = (float (*)[3])(float (*)[3]) ((arg1)->m); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_3__float, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMatrix3 (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMatrix3 *result = 0 ; + + if (!SWIG_check_num_args("new_CvMatrix3",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvMatrix3 *)new CvMatrix3(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMatrix3, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvMatrix3 (const octave_value_list& args, int nargout) { + CvMatrix3 *arg1 = (CvMatrix3 *) 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_CvMatrix3",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMatrix3, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMatrix3" "', argument " "1"" of type '" "CvMatrix3 *""'"); + } + arg1 = (CvMatrix3 *)(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_CvMatrix3_members[] = { +{"m",0,_wrap_CvMatrix3_m_get,_wrap_CvMatrix3_m_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvMatrix3_base_names[] = {0}; +static const swig_type_info *swig_CvMatrix3_base[] = {0}; +static swig_octave_class _wrap_class_CvMatrix3 = {"CvMatrix3", &SWIGTYPE_p_CvMatrix3,0,_wrap_new_CvMatrix3,0,_wrap_delete_CvMatrix3,swig_CvMatrix3_members,swig_CvMatrix3_base_names,swig_CvMatrix3_base }; + +static octave_value_list _wrap_CvConDensation_MP_set (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_MP_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_MP_set" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvConDensation_MP_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->MP = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_MP_get (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_MP_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_MP_get" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + result = (int) ((arg1)->MP); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_DP_set (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_DP_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_DP_set" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvConDensation_DP_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->DP = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_DP_get (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_DP_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_DP_get" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + result = (int) ((arg1)->DP); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_DynamMatr_set (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_DynamMatr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_DynamMatr_set" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(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 '" "CvConDensation_DynamMatr_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->DynamMatr = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_DynamMatr_get (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_DynamMatr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_DynamMatr_get" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + result = (float *) ((arg1)->DynamMatr); + _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_CvConDensation_State_set (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_State_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_State_set" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(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 '" "CvConDensation_State_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->State = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_State_get (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_State_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_State_get" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + result = (float *) ((arg1)->State); + _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_CvConDensation_SamplesNum_set (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_SamplesNum_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_SamplesNum_set" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvConDensation_SamplesNum_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->SamplesNum = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_SamplesNum_get (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_SamplesNum_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_SamplesNum_get" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + result = (int) ((arg1)->SamplesNum); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_flSamples_set (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_flSamples_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flSamples_set" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + { + if ((SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_float, 1)) == -1){ + SWIG_fail; + } + buffer2 = (float *) vptr2; + arg2=&buffer2; + } + if (arg1) (arg1)->flSamples = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_flSamples_get (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_flSamples_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flSamples_get" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + result = (float **) ((arg1)->flSamples); + _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_CvConDensation_flNewSamples_set (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_flNewSamples_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flNewSamples_set" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + { + if ((SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_float, 1)) == -1){ + SWIG_fail; + } + buffer2 = (float *) vptr2; + arg2=&buffer2; + } + if (arg1) (arg1)->flNewSamples = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_flNewSamples_get (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_flNewSamples_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flNewSamples_get" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + result = (float **) ((arg1)->flNewSamples); + _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_CvConDensation_flConfidence_set (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_flConfidence_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flConfidence_set" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(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 '" "CvConDensation_flConfidence_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->flConfidence = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_flConfidence_get (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_flConfidence_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flConfidence_get" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + result = (float *) ((arg1)->flConfidence); + _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_CvConDensation_flCumulative_set (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_flCumulative_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flCumulative_set" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(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 '" "CvConDensation_flCumulative_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->flCumulative = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_flCumulative_get (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_flCumulative_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_flCumulative_get" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + result = (float *) ((arg1)->flCumulative); + _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_CvConDensation_Temp_set (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_Temp_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_Temp_set" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(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 '" "CvConDensation_Temp_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->Temp = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_Temp_get (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_Temp_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_Temp_get" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + result = (float *) ((arg1)->Temp); + _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_CvConDensation_RandomSample_set (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_RandomSample_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_RandomSample_set" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(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 '" "CvConDensation_RandomSample_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->RandomSample = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_RandomSample_get (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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("CvConDensation_RandomSample_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_RandomSample_get" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + result = (float *) ((arg1)->RandomSample); + _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_CvConDensation_RandS_set (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 0 ; + CvRandState *arg2 = (CvRandState *) 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("CvConDensation_RandS_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_RandS_set" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvRandState, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvConDensation_RandS_set" "', argument " "2"" of type '" "CvRandState *""'"); + } + arg2 = (CvRandState *)(argp2); + if (arg1) (arg1)->RandS = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvConDensation_RandS_get (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvRandState *result = 0 ; + + if (!SWIG_check_num_args("CvConDensation_RandS_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvConDensation_RandS_get" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + result = (CvRandState *) ((arg1)->RandS); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRandState, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvConDensation (const octave_value_list& args, int nargout) { + CvConDensation *arg1 = (CvConDensation *) 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_CvConDensation",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvConDensation, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvConDensation" "', argument " "1"" of type '" "CvConDensation *""'"); + } + arg1 = (CvConDensation *)(argp1); + { + try { + delete_CvConDensation(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_CvConDensation_members[] = { +{"MP",0,_wrap_CvConDensation_MP_get,_wrap_CvConDensation_MP_set,0,0}, +{"DP",0,_wrap_CvConDensation_DP_get,_wrap_CvConDensation_DP_set,0,0}, +{"DynamMatr",0,_wrap_CvConDensation_DynamMatr_get,_wrap_CvConDensation_DynamMatr_set,0,0}, +{"State",0,_wrap_CvConDensation_State_get,_wrap_CvConDensation_State_set,0,0}, +{"SamplesNum",0,_wrap_CvConDensation_SamplesNum_get,_wrap_CvConDensation_SamplesNum_set,0,0}, +{"flSamples",0,_wrap_CvConDensation_flSamples_get,_wrap_CvConDensation_flSamples_set,0,0}, +{"flNewSamples",0,_wrap_CvConDensation_flNewSamples_get,_wrap_CvConDensation_flNewSamples_set,0,0}, +{"flConfidence",0,_wrap_CvConDensation_flConfidence_get,_wrap_CvConDensation_flConfidence_set,0,0}, +{"flCumulative",0,_wrap_CvConDensation_flCumulative_get,_wrap_CvConDensation_flCumulative_set,0,0}, +{"Temp",0,_wrap_CvConDensation_Temp_get,_wrap_CvConDensation_Temp_set,0,0}, +{"RandomSample",0,_wrap_CvConDensation_RandomSample_get,_wrap_CvConDensation_RandomSample_set,0,0}, +{"RandS",0,_wrap_CvConDensation_RandS_get,_wrap_CvConDensation_RandS_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvConDensation_base_names[] = {0}; +static const swig_type_info *swig_CvConDensation_base[] = {0}; +static swig_octave_class _wrap_class_CvConDensation = {"CvConDensation", &SWIGTYPE_p_CvConDensation,0,0,0,_wrap_delete_CvConDensation,swig_CvConDensation_members,swig_CvConDensation_base_names,swig_CvConDensation_base }; + +static octave_value_list _wrap_CvKalman_MP_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_MP_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_MP_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvKalman_MP_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->MP = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_MP_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_MP_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_MP_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (int) ((arg1)->MP); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_DP_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_DP_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_DP_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvKalman_DP_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->DP = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_DP_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_DP_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_DP_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (int) ((arg1)->DP); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_CP_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_CP_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_CP_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvKalman_CP_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->CP = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_CP_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_CP_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_CP_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (int) ((arg1)->CP); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_PosterState_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_PosterState_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PosterState_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_PosterState_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->PosterState = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_PosterState_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_PosterState_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PosterState_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (float *) ((arg1)->PosterState); + _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_CvKalman_PriorState_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_PriorState_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PriorState_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_PriorState_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->PriorState = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_PriorState_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_PriorState_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PriorState_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (float *) ((arg1)->PriorState); + _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_CvKalman_DynamMatr_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_DynamMatr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_DynamMatr_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_DynamMatr_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->DynamMatr = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_DynamMatr_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_DynamMatr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_DynamMatr_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (float *) ((arg1)->DynamMatr); + _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_CvKalman_MeasurementMatr_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_MeasurementMatr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_MeasurementMatr_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_MeasurementMatr_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->MeasurementMatr = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_MeasurementMatr_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_MeasurementMatr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_MeasurementMatr_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (float *) ((arg1)->MeasurementMatr); + _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_CvKalman_MNCovariance_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_MNCovariance_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_MNCovariance_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_MNCovariance_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->MNCovariance = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_MNCovariance_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_MNCovariance_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_MNCovariance_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (float *) ((arg1)->MNCovariance); + _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_CvKalman_PNCovariance_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_PNCovariance_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PNCovariance_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_PNCovariance_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->PNCovariance = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_PNCovariance_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_PNCovariance_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PNCovariance_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (float *) ((arg1)->PNCovariance); + _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_CvKalman_KalmGainMatr_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_KalmGainMatr_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_KalmGainMatr_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_KalmGainMatr_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->KalmGainMatr = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_KalmGainMatr_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_KalmGainMatr_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_KalmGainMatr_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (float *) ((arg1)->KalmGainMatr); + _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_CvKalman_PriorErrorCovariance_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_PriorErrorCovariance_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PriorErrorCovariance_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_PriorErrorCovariance_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->PriorErrorCovariance = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_PriorErrorCovariance_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_PriorErrorCovariance_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PriorErrorCovariance_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (float *) ((arg1)->PriorErrorCovariance); + _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_CvKalman_PosterErrorCovariance_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_PosterErrorCovariance_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PosterErrorCovariance_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_PosterErrorCovariance_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->PosterErrorCovariance = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_PosterErrorCovariance_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_PosterErrorCovariance_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_PosterErrorCovariance_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (float *) ((arg1)->PosterErrorCovariance); + _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_CvKalman_Temp1_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_Temp1_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_Temp1_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_Temp1_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->Temp1 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_Temp1_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_Temp1_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_Temp1_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (float *) ((arg1)->Temp1); + _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_CvKalman_Temp2_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_Temp2_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_Temp2_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_Temp2_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->Temp2 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_Temp2_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_Temp2_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_Temp2_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (float *) ((arg1)->Temp2); + _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_CvKalman_state_pre_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_state_pre_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_state_pre_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_state_pre_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->state_pre = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_state_pre_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_state_pre_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_state_pre_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->state_pre); + _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_CvKalman_state_post_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_state_post_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_state_post_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_state_post_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->state_post = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_state_post_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_state_post_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_state_post_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->state_post); + _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_CvKalman_transition_matrix_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_transition_matrix_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_transition_matrix_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_transition_matrix_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->transition_matrix = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_transition_matrix_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_transition_matrix_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_transition_matrix_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->transition_matrix); + _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_CvKalman_control_matrix_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_control_matrix_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_control_matrix_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_control_matrix_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->control_matrix = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_control_matrix_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_control_matrix_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_control_matrix_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->control_matrix); + _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_CvKalman_measurement_matrix_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_measurement_matrix_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_measurement_matrix_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_measurement_matrix_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->measurement_matrix = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_measurement_matrix_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_measurement_matrix_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_measurement_matrix_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->measurement_matrix); + _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_CvKalman_process_noise_cov_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_process_noise_cov_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_process_noise_cov_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_process_noise_cov_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->process_noise_cov = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_process_noise_cov_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_process_noise_cov_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_process_noise_cov_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->process_noise_cov); + _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_CvKalman_measurement_noise_cov_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_measurement_noise_cov_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_measurement_noise_cov_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_measurement_noise_cov_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->measurement_noise_cov = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_measurement_noise_cov_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_measurement_noise_cov_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_measurement_noise_cov_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->measurement_noise_cov); + _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_CvKalman_error_cov_pre_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_error_cov_pre_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_error_cov_pre_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_error_cov_pre_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->error_cov_pre = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_error_cov_pre_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_error_cov_pre_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_error_cov_pre_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->error_cov_pre); + _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_CvKalman_gain_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_gain_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_gain_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_gain_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->gain = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_gain_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_gain_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_gain_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->gain); + _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_CvKalman_error_cov_post_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_error_cov_post_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_error_cov_post_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_error_cov_post_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->error_cov_post = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_error_cov_post_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_error_cov_post_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_error_cov_post_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->error_cov_post); + _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_CvKalman_temp1_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_temp1_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp1_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_temp1_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->temp1 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_temp1_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_temp1_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp1_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->temp1); + _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_CvKalman_temp2_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_temp2_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp2_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_temp2_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->temp2 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_temp2_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_temp2_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp2_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->temp2); + _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_CvKalman_temp3_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_temp3_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp3_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_temp3_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->temp3 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_temp3_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_temp3_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp3_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->temp3); + _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_CvKalman_temp4_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_temp4_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp4_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_temp4_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->temp4 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_temp4_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_temp4_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp4_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->temp4); + _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_CvKalman_temp5_set (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_temp5_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp5_set" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(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 '" "CvKalman_temp5_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->temp5 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvKalman_temp5_get (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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("CvKalman_temp5_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvKalman_temp5_get" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + result = (CvMat *) ((arg1)->temp5); + _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_delete_CvKalman (const octave_value_list& args, int nargout) { + CvKalman *arg1 = (CvKalman *) 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_CvKalman",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvKalman, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvKalman" "', argument " "1"" of type '" "CvKalman *""'"); + } + arg1 = (CvKalman *)(argp1); + { + try { + delete_CvKalman(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_CvKalman_members[] = { +{"MP",0,_wrap_CvKalman_MP_get,_wrap_CvKalman_MP_set,0,0}, +{"DP",0,_wrap_CvKalman_DP_get,_wrap_CvKalman_DP_set,0,0}, +{"CP",0,_wrap_CvKalman_CP_get,_wrap_CvKalman_CP_set,0,0}, +{"PosterState",0,_wrap_CvKalman_PosterState_get,_wrap_CvKalman_PosterState_set,0,0}, +{"PriorState",0,_wrap_CvKalman_PriorState_get,_wrap_CvKalman_PriorState_set,0,0}, +{"DynamMatr",0,_wrap_CvKalman_DynamMatr_get,_wrap_CvKalman_DynamMatr_set,0,0}, +{"MeasurementMatr",0,_wrap_CvKalman_MeasurementMatr_get,_wrap_CvKalman_MeasurementMatr_set,0,0}, +{"MNCovariance",0,_wrap_CvKalman_MNCovariance_get,_wrap_CvKalman_MNCovariance_set,0,0}, +{"PNCovariance",0,_wrap_CvKalman_PNCovariance_get,_wrap_CvKalman_PNCovariance_set,0,0}, +{"KalmGainMatr",0,_wrap_CvKalman_KalmGainMatr_get,_wrap_CvKalman_KalmGainMatr_set,0,0}, +{"PriorErrorCovariance",0,_wrap_CvKalman_PriorErrorCovariance_get,_wrap_CvKalman_PriorErrorCovariance_set,0,0}, +{"PosterErrorCovariance",0,_wrap_CvKalman_PosterErrorCovariance_get,_wrap_CvKalman_PosterErrorCovariance_set,0,0}, +{"Temp1",0,_wrap_CvKalman_Temp1_get,_wrap_CvKalman_Temp1_set,0,0}, +{"Temp2",0,_wrap_CvKalman_Temp2_get,_wrap_CvKalman_Temp2_set,0,0}, +{"state_pre",0,_wrap_CvKalman_state_pre_get,_wrap_CvKalman_state_pre_set,0,0}, +{"state_post",0,_wrap_CvKalman_state_post_get,_wrap_CvKalman_state_post_set,0,0}, +{"transition_matrix",0,_wrap_CvKalman_transition_matrix_get,_wrap_CvKalman_transition_matrix_set,0,0}, +{"control_matrix",0,_wrap_CvKalman_control_matrix_get,_wrap_CvKalman_control_matrix_set,0,0}, +{"measurement_matrix",0,_wrap_CvKalman_measurement_matrix_get,_wrap_CvKalman_measurement_matrix_set,0,0}, +{"process_noise_cov",0,_wrap_CvKalman_process_noise_cov_get,_wrap_CvKalman_process_noise_cov_set,0,0}, +{"measurement_noise_cov",0,_wrap_CvKalman_measurement_noise_cov_get,_wrap_CvKalman_measurement_noise_cov_set,0,0}, +{"error_cov_pre",0,_wrap_CvKalman_error_cov_pre_get,_wrap_CvKalman_error_cov_pre_set,0,0}, +{"gain",0,_wrap_CvKalman_gain_get,_wrap_CvKalman_gain_set,0,0}, +{"error_cov_post",0,_wrap_CvKalman_error_cov_post_get,_wrap_CvKalman_error_cov_post_set,0,0}, +{"temp1",0,_wrap_CvKalman_temp1_get,_wrap_CvKalman_temp1_set,0,0}, +{"temp2",0,_wrap_CvKalman_temp2_get,_wrap_CvKalman_temp2_set,0,0}, +{"temp3",0,_wrap_CvKalman_temp3_get,_wrap_CvKalman_temp3_set,0,0}, +{"temp4",0,_wrap_CvKalman_temp4_get,_wrap_CvKalman_temp4_set,0,0}, +{"temp5",0,_wrap_CvKalman_temp5_get,_wrap_CvKalman_temp5_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvKalman_base_names[] = {0}; +static const swig_type_info *swig_CvKalman_base[] = {0}; +static swig_octave_class _wrap_class_CvKalman = {"CvKalman", &SWIGTYPE_p_CvKalman,0,0,0,_wrap_delete_CvKalman,swig_CvKalman_members,swig_CvKalman_base_names,swig_CvKalman_base }; + +static octave_value_list _wrap_CvHaarFeature_tilted_set (const octave_value_list& args, int nargout) { + CvHaarFeature *arg1 = (CvHaarFeature *) 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("CvHaarFeature_tilted_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarFeature, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_tilted_set" "', argument " "1"" of type '" "CvHaarFeature *""'"); + } + arg1 = (CvHaarFeature *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarFeature_tilted_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->tilted = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarFeature_tilted_get (const octave_value_list& args, int nargout) { + CvHaarFeature *arg1 = (CvHaarFeature *) 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("CvHaarFeature_tilted_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarFeature, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_tilted_get" "', argument " "1"" of type '" "CvHaarFeature *""'"); + } + arg1 = (CvHaarFeature *)(argp1); + result = (int) ((arg1)->tilted); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarFeature_rect_get (const octave_value_list& args, int nargout) { + CvHaarFeature *arg1 = (CvHaarFeature *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvHaarFeature_rect *result = 0 ; + + if (!SWIG_check_num_args("CvHaarFeature_rect_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarFeature, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_rect_get" "', argument " "1"" of type '" "CvHaarFeature *""'"); + } + arg1 = (CvHaarFeature *)(argp1); + result = (CvHaarFeature_rect *)(CvHaarFeature_rect *) ((arg1)->rect); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarFeature_rect, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvHaarFeature (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvHaarFeature *result = 0 ; + + if (!SWIG_check_num_args("new_CvHaarFeature",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvHaarFeature *)new CvHaarFeature(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarFeature, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvHaarFeature (const octave_value_list& args, int nargout) { + CvHaarFeature *arg1 = (CvHaarFeature *) 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_CvHaarFeature",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarFeature, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHaarFeature" "', argument " "1"" of type '" "CvHaarFeature *""'"); + } + arg1 = (CvHaarFeature *)(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_CvHaarFeature_members[] = { +{"tilted",0,_wrap_CvHaarFeature_tilted_get,_wrap_CvHaarFeature_tilted_set,0,0}, +{"rect",0,_wrap_CvHaarFeature_rect_get,octave_set_immutable,0,0}, +{0,0,0,0} +}; +static const char *swig_CvHaarFeature_base_names[] = {0}; +static const swig_type_info *swig_CvHaarFeature_base[] = {0}; +static swig_octave_class _wrap_class_CvHaarFeature = {"CvHaarFeature", &SWIGTYPE_p_CvHaarFeature,0,_wrap_new_CvHaarFeature,0,_wrap_delete_CvHaarFeature,swig_CvHaarFeature_members,swig_CvHaarFeature_base_names,swig_CvHaarFeature_base }; + +static octave_value_list _wrap_CvHaarFeature_rect_r_set (const octave_value_list& args, int nargout) { + CvHaarFeature_rect *arg1 = (CvHaarFeature_rect *) 0 ; + CvRect *arg2 = (CvRect *) 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("CvHaarFeature_rect_r_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarFeature_rect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_rect_r_set" "', argument " "1"" of type '" "CvHaarFeature_rect *""'"); + } + arg1 = (CvHaarFeature_rect *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarFeature_rect_r_set" "', argument " "2"" of type '" "CvRect *""'"); + } + arg2 = (CvRect *)(argp2); + 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_CvHaarFeature_rect_r_get (const octave_value_list& args, int nargout) { + CvHaarFeature_rect *arg1 = (CvHaarFeature_rect *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvRect *result = 0 ; + + if (!SWIG_check_num_args("CvHaarFeature_rect_r_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarFeature_rect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_rect_r_get" "', argument " "1"" of type '" "CvHaarFeature_rect *""'"); + } + arg1 = (CvHaarFeature_rect *)(argp1); + result = (CvRect *)& ((arg1)->r); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarFeature_rect_weight_set (const octave_value_list& args, int nargout) { + CvHaarFeature_rect *arg1 = (CvHaarFeature_rect *) 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("CvHaarFeature_rect_weight_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarFeature_rect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_rect_weight_set" "', argument " "1"" of type '" "CvHaarFeature_rect *""'"); + } + arg1 = (CvHaarFeature_rect *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarFeature_rect_weight_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->weight = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarFeature_rect_weight_get (const octave_value_list& args, int nargout) { + CvHaarFeature_rect *arg1 = (CvHaarFeature_rect *) 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("CvHaarFeature_rect_weight_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarFeature_rect, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarFeature_rect_weight_get" "', argument " "1"" of type '" "CvHaarFeature_rect *""'"); + } + arg1 = (CvHaarFeature_rect *)(argp1); + result = (float) ((arg1)->weight); + _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_CvHaarFeature_rect (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvHaarFeature_rect *result = 0 ; + + if (!SWIG_check_num_args("new_CvHaarFeature_rect",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvHaarFeature_rect *)new CvHaarFeature_rect(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarFeature_rect, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvHaarFeature_rect (const octave_value_list& args, int nargout) { + CvHaarFeature_rect *arg1 = (CvHaarFeature_rect *) 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_CvHaarFeature_rect",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarFeature_rect, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHaarFeature_rect" "', argument " "1"" of type '" "CvHaarFeature_rect *""'"); + } + arg1 = (CvHaarFeature_rect *)(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_CvHaarFeature_rect_members[] = { +{"r",0,_wrap_CvHaarFeature_rect_r_get,_wrap_CvHaarFeature_rect_r_set,0,0}, +{"weight",0,_wrap_CvHaarFeature_rect_weight_get,_wrap_CvHaarFeature_rect_weight_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvHaarFeature_rect_base_names[] = {0}; +static const swig_type_info *swig_CvHaarFeature_rect_base[] = {0}; +static swig_octave_class _wrap_class_CvHaarFeature_rect = {"CvHaarFeature_rect", &SWIGTYPE_p_CvHaarFeature_rect,0,_wrap_new_CvHaarFeature_rect,0,_wrap_delete_CvHaarFeature_rect,swig_CvHaarFeature_rect_members,swig_CvHaarFeature_rect_base_names,swig_CvHaarFeature_rect_base }; + +static octave_value_list _wrap_CvHaarClassifier_count_set (const octave_value_list& args, int nargout) { + CvHaarClassifier *arg1 = (CvHaarClassifier *) 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("CvHaarClassifier_count_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_count_set" "', argument " "1"" of type '" "CvHaarClassifier *""'"); + } + arg1 = (CvHaarClassifier *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarClassifier_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_CvHaarClassifier_count_get (const octave_value_list& args, int nargout) { + CvHaarClassifier *arg1 = (CvHaarClassifier *) 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("CvHaarClassifier_count_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_count_get" "', argument " "1"" of type '" "CvHaarClassifier *""'"); + } + arg1 = (CvHaarClassifier *)(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_CvHaarClassifier_haar_feature_set (const octave_value_list& args, int nargout) { + CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ; + CvHaarFeature *arg2 = (CvHaarFeature *) 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("CvHaarClassifier_haar_feature_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_haar_feature_set" "', argument " "1"" of type '" "CvHaarClassifier *""'"); + } + arg1 = (CvHaarClassifier *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvHaarFeature, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifier_haar_feature_set" "', argument " "2"" of type '" "CvHaarFeature *""'"); + } + arg2 = (CvHaarFeature *)(argp2); + if (arg1) (arg1)->haar_feature = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarClassifier_haar_feature_get (const octave_value_list& args, int nargout) { + CvHaarClassifier *arg1 = (CvHaarClassifier *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvHaarFeature *result = 0 ; + + if (!SWIG_check_num_args("CvHaarClassifier_haar_feature_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_haar_feature_get" "', argument " "1"" of type '" "CvHaarClassifier *""'"); + } + arg1 = (CvHaarClassifier *)(argp1); + result = (CvHaarFeature *) ((arg1)->haar_feature); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarFeature, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarClassifier_threshold_set (const octave_value_list& args, int nargout) { + CvHaarClassifier *arg1 = (CvHaarClassifier *) 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("CvHaarClassifier_threshold_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_threshold_set" "', argument " "1"" of type '" "CvHaarClassifier *""'"); + } + arg1 = (CvHaarClassifier *)(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 '" "CvHaarClassifier_threshold_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(argp2); + if (arg1) (arg1)->threshold = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarClassifier_threshold_get (const octave_value_list& args, int nargout) { + CvHaarClassifier *arg1 = (CvHaarClassifier *) 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("CvHaarClassifier_threshold_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_threshold_get" "', argument " "1"" of type '" "CvHaarClassifier *""'"); + } + arg1 = (CvHaarClassifier *)(argp1); + result = (float *) ((arg1)->threshold); + _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_CvHaarClassifier_left_set (const octave_value_list& args, int nargout) { + CvHaarClassifier *arg1 = (CvHaarClassifier *) 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("CvHaarClassifier_left_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_left_set" "', argument " "1"" of type '" "CvHaarClassifier *""'"); + } + arg1 = (CvHaarClassifier *)(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 '" "CvHaarClassifier_left_set" "', argument " "2"" of type '" "int *""'"); + } + arg2 = (int *)(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_CvHaarClassifier_left_get (const octave_value_list& args, int nargout) { + CvHaarClassifier *arg1 = (CvHaarClassifier *) 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("CvHaarClassifier_left_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_left_get" "', argument " "1"" of type '" "CvHaarClassifier *""'"); + } + arg1 = (CvHaarClassifier *)(argp1); + result = (int *) ((arg1)->left); + _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_CvHaarClassifier_right_set (const octave_value_list& args, int nargout) { + CvHaarClassifier *arg1 = (CvHaarClassifier *) 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("CvHaarClassifier_right_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_right_set" "', argument " "1"" of type '" "CvHaarClassifier *""'"); + } + arg1 = (CvHaarClassifier *)(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 '" "CvHaarClassifier_right_set" "', argument " "2"" of type '" "int *""'"); + } + arg2 = (int *)(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_CvHaarClassifier_right_get (const octave_value_list& args, int nargout) { + CvHaarClassifier *arg1 = (CvHaarClassifier *) 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("CvHaarClassifier_right_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_right_get" "', argument " "1"" of type '" "CvHaarClassifier *""'"); + } + arg1 = (CvHaarClassifier *)(argp1); + result = (int *) ((arg1)->right); + _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_CvHaarClassifier_alpha_set (const octave_value_list& args, int nargout) { + CvHaarClassifier *arg1 = (CvHaarClassifier *) 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("CvHaarClassifier_alpha_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_alpha_set" "', argument " "1"" of type '" "CvHaarClassifier *""'"); + } + arg1 = (CvHaarClassifier *)(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 '" "CvHaarClassifier_alpha_set" "', argument " "2"" of type '" "float *""'"); + } + arg2 = (float *)(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_CvHaarClassifier_alpha_get (const octave_value_list& args, int nargout) { + CvHaarClassifier *arg1 = (CvHaarClassifier *) 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("CvHaarClassifier_alpha_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifier_alpha_get" "', argument " "1"" of type '" "CvHaarClassifier *""'"); + } + arg1 = (CvHaarClassifier *)(argp1); + result = (float *) ((arg1)->alpha); + _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_CvHaarClassifier (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvHaarClassifier *result = 0 ; + + if (!SWIG_check_num_args("new_CvHaarClassifier",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvHaarClassifier *)new CvHaarClassifier(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarClassifier, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvHaarClassifier (const octave_value_list& args, int nargout) { + CvHaarClassifier *arg1 = (CvHaarClassifier *) 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_CvHaarClassifier",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifier, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHaarClassifier" "', argument " "1"" of type '" "CvHaarClassifier *""'"); + } + arg1 = (CvHaarClassifier *)(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_CvHaarClassifier_members[] = { +{"count",0,_wrap_CvHaarClassifier_count_get,_wrap_CvHaarClassifier_count_set,0,0}, +{"haar_feature",0,_wrap_CvHaarClassifier_haar_feature_get,_wrap_CvHaarClassifier_haar_feature_set,0,0}, +{"threshold",0,_wrap_CvHaarClassifier_threshold_get,_wrap_CvHaarClassifier_threshold_set,0,0}, +{"left",0,_wrap_CvHaarClassifier_left_get,_wrap_CvHaarClassifier_left_set,0,0}, +{"right",0,_wrap_CvHaarClassifier_right_get,_wrap_CvHaarClassifier_right_set,0,0}, +{"alpha",0,_wrap_CvHaarClassifier_alpha_get,_wrap_CvHaarClassifier_alpha_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvHaarClassifier_base_names[] = {0}; +static const swig_type_info *swig_CvHaarClassifier_base[] = {0}; +static swig_octave_class _wrap_class_CvHaarClassifier = {"CvHaarClassifier", &SWIGTYPE_p_CvHaarClassifier,0,_wrap_new_CvHaarClassifier,0,_wrap_delete_CvHaarClassifier,swig_CvHaarClassifier_members,swig_CvHaarClassifier_base_names,swig_CvHaarClassifier_base }; + +static octave_value_list _wrap_CvHaarStageClassifier_count_set (const octave_value_list& args, int nargout) { + CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 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("CvHaarStageClassifier_count_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_count_set" "', argument " "1"" of type '" "CvHaarStageClassifier *""'"); + } + arg1 = (CvHaarStageClassifier *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarStageClassifier_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_CvHaarStageClassifier_count_get (const octave_value_list& args, int nargout) { + CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 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("CvHaarStageClassifier_count_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_count_get" "', argument " "1"" of type '" "CvHaarStageClassifier *""'"); + } + arg1 = (CvHaarStageClassifier *)(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_CvHaarStageClassifier_threshold_set (const octave_value_list& args, int nargout) { + CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 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("CvHaarStageClassifier_threshold_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_threshold_set" "', argument " "1"" of type '" "CvHaarStageClassifier *""'"); + } + arg1 = (CvHaarStageClassifier *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarStageClassifier_threshold_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->threshold = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarStageClassifier_threshold_get (const octave_value_list& args, int nargout) { + CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 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("CvHaarStageClassifier_threshold_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_threshold_get" "', argument " "1"" of type '" "CvHaarStageClassifier *""'"); + } + arg1 = (CvHaarStageClassifier *)(argp1); + result = (float) ((arg1)->threshold); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarStageClassifier_classifier_set (const octave_value_list& args, int nargout) { + CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ; + CvHaarClassifier *arg2 = (CvHaarClassifier *) 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("CvHaarStageClassifier_classifier_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_classifier_set" "', argument " "1"" of type '" "CvHaarStageClassifier *""'"); + } + arg1 = (CvHaarStageClassifier *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvHaarClassifier, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarStageClassifier_classifier_set" "', argument " "2"" of type '" "CvHaarClassifier *""'"); + } + arg2 = (CvHaarClassifier *)(argp2); + if (arg1) (arg1)->classifier = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarStageClassifier_classifier_get (const octave_value_list& args, int nargout) { + CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvHaarClassifier *result = 0 ; + + if (!SWIG_check_num_args("CvHaarStageClassifier_classifier_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_classifier_get" "', argument " "1"" of type '" "CvHaarStageClassifier *""'"); + } + arg1 = (CvHaarStageClassifier *)(argp1); + result = (CvHaarClassifier *) ((arg1)->classifier); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarClassifier, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarStageClassifier_next_set (const octave_value_list& args, int nargout) { + CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 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("CvHaarStageClassifier_next_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_next_set" "', argument " "1"" of type '" "CvHaarStageClassifier *""'"); + } + arg1 = (CvHaarStageClassifier *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarStageClassifier_next_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + 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_CvHaarStageClassifier_next_get (const octave_value_list& args, int nargout) { + CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 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("CvHaarStageClassifier_next_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_next_get" "', argument " "1"" of type '" "CvHaarStageClassifier *""'"); + } + arg1 = (CvHaarStageClassifier *)(argp1); + result = (int) ((arg1)->next); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarStageClassifier_child_set (const octave_value_list& args, int nargout) { + CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 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("CvHaarStageClassifier_child_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_child_set" "', argument " "1"" of type '" "CvHaarStageClassifier *""'"); + } + arg1 = (CvHaarStageClassifier *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarStageClassifier_child_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->child = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarStageClassifier_child_get (const octave_value_list& args, int nargout) { + CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 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("CvHaarStageClassifier_child_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_child_get" "', argument " "1"" of type '" "CvHaarStageClassifier *""'"); + } + arg1 = (CvHaarStageClassifier *)(argp1); + result = (int) ((arg1)->child); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarStageClassifier_parent_set (const octave_value_list& args, int nargout) { + CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 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("CvHaarStageClassifier_parent_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_parent_set" "', argument " "1"" of type '" "CvHaarStageClassifier *""'"); + } + arg1 = (CvHaarStageClassifier *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarStageClassifier_parent_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + 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_CvHaarStageClassifier_parent_get (const octave_value_list& args, int nargout) { + CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 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("CvHaarStageClassifier_parent_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarStageClassifier_parent_get" "', argument " "1"" of type '" "CvHaarStageClassifier *""'"); + } + arg1 = (CvHaarStageClassifier *)(argp1); + result = (int) ((arg1)->parent); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvHaarStageClassifier (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvHaarStageClassifier *result = 0 ; + + if (!SWIG_check_num_args("new_CvHaarStageClassifier",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvHaarStageClassifier *)new CvHaarStageClassifier(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarStageClassifier, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvHaarStageClassifier (const octave_value_list& args, int nargout) { + CvHaarStageClassifier *arg1 = (CvHaarStageClassifier *) 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_CvHaarStageClassifier",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarStageClassifier, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHaarStageClassifier" "', argument " "1"" of type '" "CvHaarStageClassifier *""'"); + } + arg1 = (CvHaarStageClassifier *)(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_CvHaarStageClassifier_members[] = { +{"count",0,_wrap_CvHaarStageClassifier_count_get,_wrap_CvHaarStageClassifier_count_set,0,0}, +{"threshold",0,_wrap_CvHaarStageClassifier_threshold_get,_wrap_CvHaarStageClassifier_threshold_set,0,0}, +{"classifier",0,_wrap_CvHaarStageClassifier_classifier_get,_wrap_CvHaarStageClassifier_classifier_set,0,0}, +{"next",0,_wrap_CvHaarStageClassifier_next_get,_wrap_CvHaarStageClassifier_next_set,0,0}, +{"child",0,_wrap_CvHaarStageClassifier_child_get,_wrap_CvHaarStageClassifier_child_set,0,0}, +{"parent",0,_wrap_CvHaarStageClassifier_parent_get,_wrap_CvHaarStageClassifier_parent_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvHaarStageClassifier_base_names[] = {0}; +static const swig_type_info *swig_CvHaarStageClassifier_base[] = {0}; +static swig_octave_class _wrap_class_CvHaarStageClassifier = {"CvHaarStageClassifier", &SWIGTYPE_p_CvHaarStageClassifier,0,_wrap_new_CvHaarStageClassifier,0,_wrap_delete_CvHaarStageClassifier,swig_CvHaarStageClassifier_members,swig_CvHaarStageClassifier_base_names,swig_CvHaarStageClassifier_base }; + +static octave_value_list _wrap_CvHaarClassifierCascade_flags_set (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 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("CvHaarClassifierCascade_flags_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_flags_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarClassifierCascade_flags_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->flags = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarClassifierCascade_flags_get (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 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("CvHaarClassifierCascade_flags_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_flags_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + result = (int) ((arg1)->flags); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarClassifierCascade_count_set (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 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("CvHaarClassifierCascade_count_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_count_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarClassifierCascade_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_CvHaarClassifierCascade_count_get (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 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("CvHaarClassifierCascade_count_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_count_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(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_CvHaarClassifierCascade_orig_window_size_set (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ; + CvSize *arg2 = (CvSize *) 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("CvHaarClassifierCascade_orig_window_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_orig_window_size_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSize, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifierCascade_orig_window_size_set" "', argument " "2"" of type '" "CvSize *""'"); + } + arg2 = (CvSize *)(argp2); + if (arg1) (arg1)->orig_window_size = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarClassifierCascade_orig_window_size_get (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSize *result = 0 ; + + if (!SWIG_check_num_args("CvHaarClassifierCascade_orig_window_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_orig_window_size_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + result = (CvSize *)& ((arg1)->orig_window_size); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSize, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarClassifierCascade_real_window_size_set (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ; + CvSize *arg2 = (CvSize *) 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("CvHaarClassifierCascade_real_window_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_real_window_size_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvSize, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifierCascade_real_window_size_set" "', argument " "2"" of type '" "CvSize *""'"); + } + arg2 = (CvSize *)(argp2); + if (arg1) (arg1)->real_window_size = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarClassifierCascade_real_window_size_get (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSize *result = 0 ; + + if (!SWIG_check_num_args("CvHaarClassifierCascade_real_window_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_real_window_size_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + result = (CvSize *)& ((arg1)->real_window_size); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSize, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarClassifierCascade_scale_set (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 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("CvHaarClassifierCascade_scale_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_scale_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvHaarClassifierCascade_scale_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->scale = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarClassifierCascade_scale_get (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 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("CvHaarClassifierCascade_scale_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_scale_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + result = (double) ((arg1)->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_CvHaarClassifierCascade_stage_classifier_set (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ; + CvHaarStageClassifier *arg2 = (CvHaarStageClassifier *) 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("CvHaarClassifierCascade_stage_classifier_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_stage_classifier_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvHaarStageClassifier, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifierCascade_stage_classifier_set" "', argument " "2"" of type '" "CvHaarStageClassifier *""'"); + } + arg2 = (CvHaarStageClassifier *)(argp2); + if (arg1) (arg1)->stage_classifier = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarClassifierCascade_stage_classifier_get (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvHaarStageClassifier *result = 0 ; + + if (!SWIG_check_num_args("CvHaarClassifierCascade_stage_classifier_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_stage_classifier_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + result = (CvHaarStageClassifier *) ((arg1)->stage_classifier); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHaarStageClassifier, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarClassifierCascade_hid_cascade_set (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ; + CvHidHaarClassifierCascade *arg2 = (CvHidHaarClassifierCascade *) 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("CvHaarClassifierCascade_hid_cascade_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_hid_cascade_set" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvHidHaarClassifierCascade, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvHaarClassifierCascade_hid_cascade_set" "', argument " "2"" of type '" "CvHidHaarClassifierCascade *""'"); + } + arg2 = (CvHidHaarClassifierCascade *)(argp2); + if (arg1) (arg1)->hid_cascade = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvHaarClassifierCascade_hid_cascade_get (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvHidHaarClassifierCascade *result = 0 ; + + if (!SWIG_check_num_args("CvHaarClassifierCascade_hid_cascade_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvHaarClassifierCascade_hid_cascade_get" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + result = (CvHidHaarClassifierCascade *) ((arg1)->hid_cascade); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvHidHaarClassifierCascade, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvHaarClassifierCascade (const octave_value_list& args, int nargout) { + CvHaarClassifierCascade *arg1 = (CvHaarClassifierCascade *) 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_CvHaarClassifierCascade",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvHaarClassifierCascade, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvHaarClassifierCascade" "', argument " "1"" of type '" "CvHaarClassifierCascade *""'"); + } + arg1 = (CvHaarClassifierCascade *)(argp1); + { + try { + delete_CvHaarClassifierCascade(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_CvHaarClassifierCascade_members[] = { +{"flags",0,_wrap_CvHaarClassifierCascade_flags_get,_wrap_CvHaarClassifierCascade_flags_set,0,0}, +{"count",0,_wrap_CvHaarClassifierCascade_count_get,_wrap_CvHaarClassifierCascade_count_set,0,0}, +{"orig_window_size",0,_wrap_CvHaarClassifierCascade_orig_window_size_get,_wrap_CvHaarClassifierCascade_orig_window_size_set,0,0}, +{"real_window_size",0,_wrap_CvHaarClassifierCascade_real_window_size_get,_wrap_CvHaarClassifierCascade_real_window_size_set,0,0}, +{"scale",0,_wrap_CvHaarClassifierCascade_scale_get,_wrap_CvHaarClassifierCascade_scale_set,0,0}, +{"stage_classifier",0,_wrap_CvHaarClassifierCascade_stage_classifier_get,_wrap_CvHaarClassifierCascade_stage_classifier_set,0,0}, +{"hid_cascade",0,_wrap_CvHaarClassifierCascade_hid_cascade_get,_wrap_CvHaarClassifierCascade_hid_cascade_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvHaarClassifierCascade_base_names[] = {0}; +static const swig_type_info *swig_CvHaarClassifierCascade_base[] = {0}; +static swig_octave_class _wrap_class_CvHaarClassifierCascade = {"CvHaarClassifierCascade", &SWIGTYPE_p_CvHaarClassifierCascade,0,0,0,_wrap_delete_CvHaarClassifierCascade,swig_CvHaarClassifierCascade_members,swig_CvHaarClassifierCascade_base_names,swig_CvHaarClassifierCascade_base }; + +static octave_value_list _wrap_CvAvgComp_rect_set (const octave_value_list& args, int nargout) { + CvAvgComp *arg1 = (CvAvgComp *) 0 ; + CvRect *arg2 = (CvRect *) 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("CvAvgComp_rect_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvAvgComp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAvgComp_rect_set" "', argument " "1"" of type '" "CvAvgComp *""'"); + } + arg1 = (CvAvgComp *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvAvgComp_rect_set" "', argument " "2"" of type '" "CvRect *""'"); + } + arg2 = (CvRect *)(argp2); + if (arg1) (arg1)->rect = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvAvgComp_rect_get (const octave_value_list& args, int nargout) { + CvAvgComp *arg1 = (CvAvgComp *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvRect *result = 0 ; + + if (!SWIG_check_num_args("CvAvgComp_rect_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvAvgComp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAvgComp_rect_get" "', argument " "1"" of type '" "CvAvgComp *""'"); + } + arg1 = (CvAvgComp *)(argp1); + result = (CvRect *)& ((arg1)->rect); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvAvgComp_neighbors_set (const octave_value_list& args, int nargout) { + CvAvgComp *arg1 = (CvAvgComp *) 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("CvAvgComp_neighbors_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvAvgComp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAvgComp_neighbors_set" "', argument " "1"" of type '" "CvAvgComp *""'"); + } + arg1 = (CvAvgComp *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvAvgComp_neighbors_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->neighbors = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvAvgComp_neighbors_get (const octave_value_list& args, int nargout) { + CvAvgComp *arg1 = (CvAvgComp *) 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("CvAvgComp_neighbors_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvAvgComp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvAvgComp_neighbors_get" "', argument " "1"" of type '" "CvAvgComp *""'"); + } + arg1 = (CvAvgComp *)(argp1); + result = (int) ((arg1)->neighbors); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvAvgComp (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvAvgComp *result = 0 ; + + if (!SWIG_check_num_args("new_CvAvgComp",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvAvgComp *)new CvAvgComp(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvAvgComp, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvAvgComp (const octave_value_list& args, int nargout) { + CvAvgComp *arg1 = (CvAvgComp *) 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_CvAvgComp",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvAvgComp, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvAvgComp" "', argument " "1"" of type '" "CvAvgComp *""'"); + } + arg1 = (CvAvgComp *)(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_CvAvgComp_members[] = { +{"rect",0,_wrap_CvAvgComp_rect_get,_wrap_CvAvgComp_rect_set,0,0}, +{"neighbors",0,_wrap_CvAvgComp_neighbors_get,_wrap_CvAvgComp_neighbors_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvAvgComp_base_names[] = {0}; +static const swig_type_info *swig_CvAvgComp_base[] = {0}; +static swig_octave_class _wrap_class_CvAvgComp = {"CvAvgComp", &SWIGTYPE_p_CvAvgComp,0,_wrap_new_CvAvgComp,0,_wrap_delete_CvAvgComp,swig_CvAvgComp_members,swig_CvAvgComp_base_names,swig_CvAvgComp_base }; + +static octave_value_list _wrap_cvCopyMakeBorder (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + CvPoint arg3 ; + int arg4 ; + CvScalar arg5 = (CvScalar) cvScalarAll(0) ; + bool freearg1 = false ; + bool freearg2 = false ; + int val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvCopyMakeBorder",args.length(),5,4,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + arg3 = OctObject_to_CvPoint(args(2)); + } + ecode4 = SWIG_AsVal_int(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCopyMakeBorder" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + if (4x; + arg5 [i].y = p->y; + } + } + { + // as input, we only need the size of the wanted features + + // memorize the size of the wanted features + tmpCount6 = (int)OctInt_AsLong (args(5)); + + // create the array for the C call + arg6 = (CvPoint2D32f *) malloc(tmpCount6 * sizeof (CvPoint2D32f)); + + // the size of the array for the C call + arg7 = tmpCount6; + } + { + res8 = SWIG_ConvertPtr(args(6), &argp8, SWIGTYPE_p_CvSize, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "8"" of type '" "CvSize""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "8"" of type '" "CvSize""'"); + } else { + arg8 = *((CvSize *)(argp8)); + } + } + ecode9 = SWIG_AsVal_int(args(7), &val9); + if (!SWIG_IsOK(ecode9)) { + SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "9"" of type '" "int""'"); + } + arg9 = (int)(val9); + { + // as input, we still need the size of the status array + + // memorize the size of the status array + tmpCountStatus10 = (int)OctInt_AsLong (args(8)); + + // create the status array for the C call + arg10 = (char *)malloc (tmpCountStatus10 * sizeof (char)); + } + res11 = SWIG_ConvertPtr(args(9), &argp11,SWIGTYPE_p_float, 0 | 0 ); + if (!SWIG_IsOK(res11)) { + SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "11"" of type '" "float *""'"); + } + arg11 = (float *)(argp11); + { + res12 = SWIG_ConvertPtr(args(10), &argp12, SWIGTYPE_p_CvTermCriteria, 0 ); + if (!SWIG_IsOK(res12)) { + SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "12"" of type '" "CvTermCriteria""'"); + } + if (!argp12) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "12"" of type '" "CvTermCriteria""'"); + } else { + arg12 = *((CvTermCriteria *)(argp12)); + } + } + ecode13 = SWIG_AsVal_int(args(11), &val13); + if (!SWIG_IsOK(ecode13)) { + SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "cvCalcOpticalFlowPyrLK" "', argument " "13"" of type '" "int""'"); + } + arg13 = (int)(val13); + { + try { + cvCalcOpticalFlowPyrLK((void const *)arg1,(void const *)arg2,arg3,arg4,(CvPoint2D32f const *)arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + int i; + octave_value to_add; + + // create the list to return + to_add = OctList_New (tmpCount6); + + // extract all the points values of the result, and add it to the + // final resulting list + for (i = 0; i < tmpCount6; i++) { + OctList_SetItem (to_add, i, + SWIG_NewPointerObj (&(arg6 [i]), + SWIGTYPE_p_CvPoint2D32f, 0)); + } + + _outp = SWIG_AppendResult(_outp, &to_add, 1); + } + { + int i; + octave_value to_add; + + // create the list to return + to_add = OctList_New (tmpCountStatus10); + + // extract all the integer values of the result, and add it to the + // final resulting list + for (i = 0; i < tmpCountStatus10; i++) { + OctList_SetItem (to_add, i, OctBool_FromLong (arg10 [i])); + } + + _outp = SWIG_AppendResult(_outp, &to_add, 1); + } + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } + { + if(arg3!=NULL && freearg3){ + cvReleaseData( arg3 ); + cvFree(&(arg3)); + } + } + { + if(arg4!=NULL && freearg4){ + cvReleaseData( arg4 ); + cvFree(&(arg4)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvCalcAffineFlowPyrLK (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + CvArr *arg3 = (CvArr *) 0 ; + CvArr *arg4 = (CvArr *) 0 ; + CvPoint2D32f *arg5 = (CvPoint2D32f *) 0 ; + CvPoint2D32f *arg6 = (CvPoint2D32f *) 0 ; + float *arg7 = (float *) 0 ; + int arg8 ; + CvSize arg9 ; + int arg10 ; + char *arg11 = (char *) 0 ; + float *arg12 = (float *) 0 ; + CvTermCriteria arg13 ; + int arg14 ; + bool freearg1 = false ; + bool freearg2 = false ; + bool freearg3 = false ; + bool freearg4 = false ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + int val8 ; + int ecode8 = 0 ; + void *argp9 ; + int res9 = 0 ; + int val10 ; + int ecode10 = 0 ; + int tmpCountStatus11 ; + void *argp12 = 0 ; + int res12 = 0 ; + void *argp13 ; + int res13 = 0 ; + int val14 ; + int ecode14 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvCalcAffineFlowPyrLK",args.length(),14,14,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + arg3 = OctObject_to_CvArr(args(2), &freearg3); + } + { + arg4 = OctObject_to_CvArr(args(3), &freearg4); + } + { + int i; + int size; + + // get the size of the input array + size = OctList_Size (args(4)); + + // allocate the needed memory + arg5 = (CvPoint2D32f *)malloc (size * sizeof (CvPoint2D32f)); + + // extract all the points values from the list + for (i = 0; i < size; i++) { + octave_value item = OctList_GetItem (args(4), i); + + void * vptr; + SWIG_Octave_ConvertPtr (item, &vptr, + SWIGTYPE_p_CvPoint2D32f, + SWIG_POINTER_EXCEPTION); + CvPoint2D32f *p = (CvPoint2D32f *)vptr; + arg5 [i].x = p->x; + arg5 [i].y = p->y; + } + } + res6 = SWIG_ConvertPtr(args(5), &argp6,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "6"" of type '" "CvPoint2D32f *""'"); + } + arg6 = (CvPoint2D32f *)(argp6); + res7 = SWIG_ConvertPtr(args(6), &argp7,SWIGTYPE_p_float, 0 | 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "7"" of type '" "float *""'"); + } + arg7 = (float *)(argp7); + ecode8 = SWIG_AsVal_int(args(7), &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "8"" of type '" "int""'"); + } + arg8 = (int)(val8); + { + res9 = SWIG_ConvertPtr(args(8), &argp9, SWIGTYPE_p_CvSize, 0 ); + if (!SWIG_IsOK(res9)) { + SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "9"" of type '" "CvSize""'"); + } + if (!argp9) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcAffineFlowPyrLK" "', argument " "9"" of type '" "CvSize""'"); + } else { + arg9 = *((CvSize *)(argp9)); + } + } + ecode10 = SWIG_AsVal_int(args(9), &val10); + if (!SWIG_IsOK(ecode10)) { + SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "10"" of type '" "int""'"); + } + arg10 = (int)(val10); + { + // as input, we still need the size of the status array + + // memorize the size of the status array + tmpCountStatus11 = (int)OctInt_AsLong (args(10)); + + // create the status array for the C call + arg11 = (char *)malloc (tmpCountStatus11 * sizeof (char)); + } + res12 = SWIG_ConvertPtr(args(11), &argp12,SWIGTYPE_p_float, 0 | 0 ); + if (!SWIG_IsOK(res12)) { + SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "12"" of type '" "float *""'"); + } + arg12 = (float *)(argp12); + { + res13 = SWIG_ConvertPtr(args(12), &argp13, SWIGTYPE_p_CvTermCriteria, 0 ); + if (!SWIG_IsOK(res13)) { + SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "13"" of type '" "CvTermCriteria""'"); + } + if (!argp13) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalcAffineFlowPyrLK" "', argument " "13"" of type '" "CvTermCriteria""'"); + } else { + arg13 = *((CvTermCriteria *)(argp13)); + } + } + ecode14 = SWIG_AsVal_int(args(13), &val14); + if (!SWIG_IsOK(ecode14)) { + SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "cvCalcAffineFlowPyrLK" "', argument " "14"" of type '" "int""'"); + } + arg14 = (int)(val14); + { + try { + cvCalcAffineFlowPyrLK((void const *)arg1,(void const *)arg2,arg3,arg4,(CvPoint2D32f const *)arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + int i; + octave_value to_add; + + // create the list to return + to_add = OctList_New (tmpCountStatus11); + + // extract all the integer values of the result, and add it to the + // final resulting list + for (i = 0; i < tmpCountStatus11; i++) { + OctList_SetItem (to_add, i, OctBool_FromLong (arg11 [i])); + } + + _outp = SWIG_AppendResult(_outp, &to_add, 1); + } + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } + { + if(arg3!=NULL && freearg3){ + cvReleaseData( arg3 ); + cvFree(&(arg3)); + } + } + { + if(arg4!=NULL && freearg4){ + cvReleaseData( arg4 ); + cvFree(&(arg4)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvEstimateRigidTransform (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + CvMat *arg3 = (CvMat *) 0 ; + int arg4 ; + bool freearg1 = false ; + bool freearg2 = false ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + int result; + + if (!SWIG_check_num_args("cvEstimateRigidTransform",args.length(),4,4,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvMat, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cvEstimateRigidTransform" "', argument " "3"" of type '" "CvMat *""'"); + } + arg3 = (CvMat *)(argp3); + ecode4 = SWIG_AsVal_int(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvEstimateRigidTransform" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + { + try { + result = (int)cvEstimateRigidTransform((void const *)arg1,(void const *)arg2,arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvUpdateMotionHistory (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + double arg3 ; + double arg4 ; + bool freearg1 = false ; + bool freearg2 = false ; + double 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("cvUpdateMotionHistory",args.length(),4,4,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + ecode3 = SWIG_AsVal_double(args(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cvUpdateMotionHistory" "', 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 '" "cvUpdateMotionHistory" "', argument " "4"" of type '" "double""'"); + } + arg4 = (double)(val4); + { + try { + cvUpdateMotionHistory((void const *)arg1,arg2,arg3,arg4); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } + { + if(arg2!=NULL && freearg2){ + cvReleaseData( arg2 ); + cvFree(&(arg2)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvCalcMotionGradient (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + CvArr *arg3 = (CvArr *) 0 ; + double arg4 ; + double arg5 ; + int arg6 = (int) 3 ; + bool freearg1 = false ; + bool freearg2 = false ; + bool freearg3 = false ; + double val4 ; + int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvCalcMotionGradient",args.length(),6,5,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + arg3 = OctObject_to_CvArr(args(2), &freearg3); + } + ecode4 = SWIG_AsVal_double(args(3), &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cvCalcMotionGradient" "', 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 '" "cvCalcMotionGradient" "', argument " "5"" of type '" "double""'"); + } + arg5 = (double)(val5); + if (5ref(); + } + else if( SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){ + qedge1 = (CvQuadEdge2D *) vptr1; + arg1 = (CvSubdiv2DEdge)qedge1; + } + else{ + SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge"); + SWIG_fail; + } + } + { + try { + result = cvSubdiv2DNextEdge(arg1); + } + catch (...) + { + SWIG_fail; + } + } + { + CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( result ); + _outv = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 1 ); + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvSubdiv2DRotateEdge (const octave_value_list& args, int nargout) { + CvSubdiv2DEdge arg1 ; + int arg2 ; + CvSubdiv2DEdge_Wrapper *wrapper1 ; + CvQuadEdge2D *qedge1 ; + void *vptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSubdiv2DEdge result; + + if (!SWIG_check_num_args("cvSubdiv2DRotateEdge",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){ + wrapper1 = (CvSubdiv2DEdge_Wrapper *) vptr1; + arg1 = wrapper1->ref(); + } + else if( SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){ + qedge1 = (CvQuadEdge2D *) vptr1; + arg1 = (CvSubdiv2DEdge)qedge1; + } + else{ + SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge"); + SWIG_fail; + } + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSubdiv2DRotateEdge" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = cvSubdiv2DRotateEdge(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( result ); + _outv = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 1 ); + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvSubdiv2DSymEdge (const octave_value_list& args, int nargout) { + CvSubdiv2DEdge arg1 ; + CvSubdiv2DEdge_Wrapper *wrapper1 ; + CvQuadEdge2D *qedge1 ; + void *vptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSubdiv2DEdge result; + + if (!SWIG_check_num_args("cvSubdiv2DSymEdge",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){ + wrapper1 = (CvSubdiv2DEdge_Wrapper *) vptr1; + arg1 = wrapper1->ref(); + } + else if( SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){ + qedge1 = (CvQuadEdge2D *) vptr1; + arg1 = (CvSubdiv2DEdge)qedge1; + } + else{ + SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge"); + SWIG_fail; + } + } + { + try { + result = cvSubdiv2DSymEdge(arg1); + } + catch (...) + { + SWIG_fail; + } + } + { + CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( result ); + _outv = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 1 ); + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvSubdiv2DGetEdge (const octave_value_list& args, int nargout) { + CvSubdiv2DEdge arg1 ; + CvNextEdgeType arg2 ; + CvSubdiv2DEdge_Wrapper *wrapper1 ; + CvQuadEdge2D *qedge1 ; + void *vptr1 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSubdiv2DEdge result; + + if (!SWIG_check_num_args("cvSubdiv2DGetEdge",args.length(),2,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){ + wrapper1 = (CvSubdiv2DEdge_Wrapper *) vptr1; + arg1 = wrapper1->ref(); + } + else if( SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){ + qedge1 = (CvQuadEdge2D *) vptr1; + arg1 = (CvSubdiv2DEdge)qedge1; + } + else{ + SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge"); + SWIG_fail; + } + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSubdiv2DGetEdge" "', argument " "2"" of type '" "CvNextEdgeType""'"); + } + arg2 = (CvNextEdgeType)(val2); + { + try { + result = cvSubdiv2DGetEdge(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + { + CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( result ); + _outv = SWIG_NewPointerObj( wrapper, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 1 ); + } + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvSubdiv2DEdgeOrg (const octave_value_list& args, int nargout) { + CvSubdiv2DEdge arg1 ; + CvSubdiv2DEdge_Wrapper *wrapper1 ; + CvQuadEdge2D *qedge1 ; + void *vptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSubdiv2DPoint *result = 0 ; + + if (!SWIG_check_num_args("cvSubdiv2DEdgeOrg",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){ + wrapper1 = (CvSubdiv2DEdge_Wrapper *) vptr1; + arg1 = wrapper1->ref(); + } + else if( SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){ + qedge1 = (CvQuadEdge2D *) vptr1; + arg1 = (CvSubdiv2DEdge)qedge1; + } + else{ + SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge"); + SWIG_fail; + } + } + { + try { + result = (CvSubdiv2DPoint *)cvSubdiv2DEdgeOrg(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvSubdiv2DEdgeDst (const octave_value_list& args, int nargout) { + CvSubdiv2DEdge arg1 ; + CvSubdiv2DEdge_Wrapper *wrapper1 ; + CvQuadEdge2D *qedge1 ; + void *vptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSubdiv2DPoint *result = 0 ; + + if (!SWIG_check_num_args("cvSubdiv2DEdgeDst",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvSubdiv2DEdge_Wrapper, 0) != -1 ){ + wrapper1 = (CvSubdiv2DEdge_Wrapper *) vptr1; + arg1 = wrapper1->ref(); + } + else if( SWIG_ConvertPtr(args(0), &vptr1, SWIGTYPE_p_CvQuadEdge2D, 0) != -1 ){ + qedge1 = (CvQuadEdge2D *) vptr1; + arg1 = (CvSubdiv2DEdge)qedge1; + } + else{ + SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge"); + SWIG_fail; + } + } + { + try { + result = (CvSubdiv2DPoint *)cvSubdiv2DEdgeDst(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSubdiv2DPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvTriangleArea (const octave_value_list& args, int nargout) { + CvPoint2D32f arg1 ; + CvPoint2D32f arg2 ; + CvPoint2D32f arg3 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + double result; + + if (!SWIG_check_num_args("cvTriangleArea",args.length(),3,3,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvPoint2D32f(args(0)); + } + { + arg2 = OctObject_to_CvPoint2D32f(args(1)); + } + { + arg3 = OctObject_to_CvPoint2D32f(args(2)); + } + { + try { + result = (double)cvTriangleArea(arg1,arg2,arg3); + } + 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_cvFindDominantPoints (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + CvMemStorage *arg2 = (CvMemStorage *) 0 ; + int arg3 = (int) 1 ; + double arg4 = (double) 0 ; + double arg5 = (double) 0 ; + double arg6 = (double) 0 ; + double arg7 = (double) 0 ; + void *ptr1 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + double val4 ; + int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSeq *result = 0 ; + + if (!SWIG_check_num_args("cvFindDominantPoints",args.length(),7,2,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvMemStorage, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvFindDominantPoints" "', argument " "2"" of type '" "CvMemStorage *""'"); + } + arg2 = (CvMemStorage *)(argp2); + if (2x; + arg2 [i].y = p->y; + } + } + { + res4 = SWIG_ConvertPtr(args(2), &argp4, SWIGTYPE_p_CvSize, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvFindCornerSubPix" "', argument " "4"" of type '" "CvSize""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvFindCornerSubPix" "', argument " "4"" of type '" "CvSize""'"); + } else { + arg4 = *((CvSize *)(argp4)); + } + } + { + res5 = SWIG_ConvertPtr(args(3), &argp5, SWIGTYPE_p_CvSize, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvFindCornerSubPix" "', argument " "5"" of type '" "CvSize""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvFindCornerSubPix" "', argument " "5"" of type '" "CvSize""'"); + } else { + arg5 = *((CvSize *)(argp5)); + } + } + { + res6 = SWIG_ConvertPtr(args(4), &argp6, SWIGTYPE_p_CvTermCriteria, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cvFindCornerSubPix" "', argument " "6"" of type '" "CvTermCriteria""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvFindCornerSubPix" "', argument " "6"" of type '" "CvTermCriteria""'"); + } else { + arg6 = *((CvTermCriteria *)(argp6)); + } + } + { + try { + cvFindCornerSubPix((void const *)arg1,arg2,arg3,arg4,arg5,arg6); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + int i; + octave_value to_add; + + // create the list to return + to_add = OctList_New (cornersCount2); + + // extract all the corner values of the result, and add it to the + // final resulting list + for (i = 0; i < cornersCount2; i++) { + OctList_SetItem (to_add, i, + SWIG_NewPointerObj (&(corners2 [i]), + SWIGTYPE_p_CvPoint2D32f, 0)); + } + + _outp = SWIG_AppendResult( _outp, &to_add, 1); + } + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvGoodFeaturesToTrack (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + CvArr *arg3 = (CvArr *) 0 ; + CvPoint2D32f *arg4 = (CvPoint2D32f *) 0 ; + int *arg5 = (int *) 0 ; + double arg6 ; + double arg7 ; + CvArr *arg8 = (CvArr *) NULL ; + int arg9 = (int) 3 ; + int arg10 = (int) 0 ; + double arg11 = (double) 0.04 ; + bool freearg1 = false ; + bool freearg2 = false ; + bool freearg3 = false ; + int tmpCount4 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; + bool freearg8 = false ; + int val9 ; + int ecode9 = 0 ; + int val10 ; + int ecode10 = 0 ; + double val11 ; + int ecode11 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvGoodFeaturesToTrack",args.length(),10,6,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + arg3 = OctObject_to_CvArr(args(2), &freearg3); + } + { + // as input, we still need the size of the corners array + + // memorize the size of the status corners + tmpCount4 = (int)OctInt_AsLong (args(3)); + + // create the corners array for the C call + arg4 = (CvPoint2D32f *)malloc (tmpCount4 * sizeof (CvPoint2D32f)); + + // the size of the array for the C call + arg5 = &tmpCount4; + } + ecode6 = SWIG_AsVal_double(args(4), &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "cvGoodFeaturesToTrack" "', argument " "6"" of type '" "double""'"); + } + arg6 = (double)(val6); + ecode7 = SWIG_AsVal_double(args(5), &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "cvGoodFeaturesToTrack" "', argument " "7"" of type '" "double""'"); + } + arg7 = (double)(val7); + if (6pt = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFPoint_pt_get (const octave_value_list& args, int nargout) { + CvSURFPoint *arg1 = (CvSURFPoint *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint2D32f *result = 0 ; + + if (!SWIG_check_num_args("CvSURFPoint_pt_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_pt_get" "', argument " "1"" of type '" "CvSURFPoint *""'"); + } + arg1 = (CvSURFPoint *)(argp1); + result = (CvPoint2D32f *)& ((arg1)->pt); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFPoint_laplacian_set (const octave_value_list& args, int nargout) { + CvSURFPoint *arg1 = (CvSURFPoint *) 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("CvSURFPoint_laplacian_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_laplacian_set" "', argument " "1"" of type '" "CvSURFPoint *""'"); + } + arg1 = (CvSURFPoint *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFPoint_laplacian_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->laplacian = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFPoint_laplacian_get (const octave_value_list& args, int nargout) { + CvSURFPoint *arg1 = (CvSURFPoint *) 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("CvSURFPoint_laplacian_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_laplacian_get" "', argument " "1"" of type '" "CvSURFPoint *""'"); + } + arg1 = (CvSURFPoint *)(argp1); + result = (int) ((arg1)->laplacian); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFPoint_size_set (const octave_value_list& args, int nargout) { + CvSURFPoint *arg1 = (CvSURFPoint *) 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("CvSURFPoint_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_size_set" "', argument " "1"" of type '" "CvSURFPoint *""'"); + } + arg1 = (CvSURFPoint *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFPoint_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFPoint_size_get (const octave_value_list& args, int nargout) { + CvSURFPoint *arg1 = (CvSURFPoint *) 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("CvSURFPoint_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_size_get" "', argument " "1"" of type '" "CvSURFPoint *""'"); + } + arg1 = (CvSURFPoint *)(argp1); + result = (int) ((arg1)->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_CvSURFPoint_dir_set (const octave_value_list& args, int nargout) { + CvSURFPoint *arg1 = (CvSURFPoint *) 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("CvSURFPoint_dir_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_dir_set" "', argument " "1"" of type '" "CvSURFPoint *""'"); + } + arg1 = (CvSURFPoint *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFPoint_dir_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->dir = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFPoint_dir_get (const octave_value_list& args, int nargout) { + CvSURFPoint *arg1 = (CvSURFPoint *) 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("CvSURFPoint_dir_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_dir_get" "', argument " "1"" of type '" "CvSURFPoint *""'"); + } + arg1 = (CvSURFPoint *)(argp1); + result = (float) ((arg1)->dir); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFPoint_hessian_set (const octave_value_list& args, int nargout) { + CvSURFPoint *arg1 = (CvSURFPoint *) 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("CvSURFPoint_hessian_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_hessian_set" "', argument " "1"" of type '" "CvSURFPoint *""'"); + } + arg1 = (CvSURFPoint *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFPoint_hessian_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->hessian = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFPoint_hessian_get (const octave_value_list& args, int nargout) { + CvSURFPoint *arg1 = (CvSURFPoint *) 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("CvSURFPoint_hessian_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFPoint_hessian_get" "', argument " "1"" of type '" "CvSURFPoint *""'"); + } + arg1 = (CvSURFPoint *)(argp1); + result = (float) ((arg1)->hessian); + _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_CvSURFPoint (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSURFPoint *result = 0 ; + + if (!SWIG_check_num_args("new_CvSURFPoint",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSURFPoint *)new CvSURFPoint(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSURFPoint, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSURFPoint (const octave_value_list& args, int nargout) { + CvSURFPoint *arg1 = (CvSURFPoint *) 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_CvSURFPoint",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFPoint, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSURFPoint" "', argument " "1"" of type '" "CvSURFPoint *""'"); + } + arg1 = (CvSURFPoint *)(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_CvSURFPoint_members[] = { +{"pt",0,_wrap_CvSURFPoint_pt_get,_wrap_CvSURFPoint_pt_set,0,0}, +{"laplacian",0,_wrap_CvSURFPoint_laplacian_get,_wrap_CvSURFPoint_laplacian_set,0,0}, +{"size",0,_wrap_CvSURFPoint_size_get,_wrap_CvSURFPoint_size_set,0,0}, +{"dir",0,_wrap_CvSURFPoint_dir_get,_wrap_CvSURFPoint_dir_set,0,0}, +{"hessian",0,_wrap_CvSURFPoint_hessian_get,_wrap_CvSURFPoint_hessian_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSURFPoint_base_names[] = {0}; +static const swig_type_info *swig_CvSURFPoint_base[] = {0}; +static swig_octave_class _wrap_class_CvSURFPoint = {"CvSURFPoint", &SWIGTYPE_p_CvSURFPoint,0,_wrap_new_CvSURFPoint,0,_wrap_delete_CvSURFPoint,swig_CvSURFPoint_members,swig_CvSURFPoint_base_names,swig_CvSURFPoint_base }; + +static octave_value_list _wrap_cvSURFPoint (const octave_value_list& args, int nargout) { + CvPoint2D32f arg1 ; + int arg2 ; + int arg3 ; + float arg4 = (float) 0 ; + float arg5 = (float) 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + float val4 ; + int ecode4 = 0 ; + float val5 ; + int ecode5 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSURFPoint result; + + if (!SWIG_check_num_args("cvSURFPoint",args.length(),5,3,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvPoint2D32f(args(0)); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvSURFPoint" "', 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 '" "cvSURFPoint" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + if (3extended = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFParams_extended_get (const octave_value_list& args, int nargout) { + CvSURFParams *arg1 = (CvSURFParams *) 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("CvSURFParams_extended_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_extended_get" "', argument " "1"" of type '" "CvSURFParams *""'"); + } + arg1 = (CvSURFParams *)(argp1); + result = (int) ((arg1)->extended); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFParams_hessianThreshold_set (const octave_value_list& args, int nargout) { + CvSURFParams *arg1 = (CvSURFParams *) 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("CvSURFParams_hessianThreshold_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_hessianThreshold_set" "', argument " "1"" of type '" "CvSURFParams *""'"); + } + arg1 = (CvSURFParams *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFParams_hessianThreshold_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->hessianThreshold = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFParams_hessianThreshold_get (const octave_value_list& args, int nargout) { + CvSURFParams *arg1 = (CvSURFParams *) 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("CvSURFParams_hessianThreshold_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_hessianThreshold_get" "', argument " "1"" of type '" "CvSURFParams *""'"); + } + arg1 = (CvSURFParams *)(argp1); + result = (double) ((arg1)->hessianThreshold); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFParams_nOctaves_set (const octave_value_list& args, int nargout) { + CvSURFParams *arg1 = (CvSURFParams *) 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("CvSURFParams_nOctaves_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_nOctaves_set" "', argument " "1"" of type '" "CvSURFParams *""'"); + } + arg1 = (CvSURFParams *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFParams_nOctaves_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->nOctaves = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFParams_nOctaves_get (const octave_value_list& args, int nargout) { + CvSURFParams *arg1 = (CvSURFParams *) 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("CvSURFParams_nOctaves_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_nOctaves_get" "', argument " "1"" of type '" "CvSURFParams *""'"); + } + arg1 = (CvSURFParams *)(argp1); + result = (int) ((arg1)->nOctaves); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFParams_nOctaveLayers_set (const octave_value_list& args, int nargout) { + CvSURFParams *arg1 = (CvSURFParams *) 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("CvSURFParams_nOctaveLayers_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_nOctaveLayers_set" "', argument " "1"" of type '" "CvSURFParams *""'"); + } + arg1 = (CvSURFParams *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSURFParams_nOctaveLayers_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->nOctaveLayers = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSURFParams_nOctaveLayers_get (const octave_value_list& args, int nargout) { + CvSURFParams *arg1 = (CvSURFParams *) 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("CvSURFParams_nOctaveLayers_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSURFParams_nOctaveLayers_get" "', argument " "1"" of type '" "CvSURFParams *""'"); + } + arg1 = (CvSURFParams *)(argp1); + result = (int) ((arg1)->nOctaveLayers); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSURFParams (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSURFParams *result = 0 ; + + if (!SWIG_check_num_args("new_CvSURFParams",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvSURFParams *)new CvSURFParams(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvSURFParams, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSURFParams (const octave_value_list& args, int nargout) { + CvSURFParams *arg1 = (CvSURFParams *) 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_CvSURFParams",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvSURFParams, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSURFParams" "', argument " "1"" of type '" "CvSURFParams *""'"); + } + arg1 = (CvSURFParams *)(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_CvSURFParams_members[] = { +{"extended",0,_wrap_CvSURFParams_extended_get,_wrap_CvSURFParams_extended_set,0,0}, +{"hessianThreshold",0,_wrap_CvSURFParams_hessianThreshold_get,_wrap_CvSURFParams_hessianThreshold_set,0,0}, +{"nOctaves",0,_wrap_CvSURFParams_nOctaves_get,_wrap_CvSURFParams_nOctaves_set,0,0}, +{"nOctaveLayers",0,_wrap_CvSURFParams_nOctaveLayers_get,_wrap_CvSURFParams_nOctaveLayers_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSURFParams_base_names[] = {0}; +static const swig_type_info *swig_CvSURFParams_base[] = {0}; +static swig_octave_class _wrap_class_CvSURFParams = {"CvSURFParams", &SWIGTYPE_p_CvSURFParams,0,_wrap_new_CvSURFParams,0,_wrap_delete_CvSURFParams,swig_CvSURFParams_members,swig_CvSURFParams_base_names,swig_CvSURFParams_base }; + +static octave_value_list _wrap_cvSURFParams (const octave_value_list& args, int nargout) { + double arg1 ; + int arg2 = (int) 0 ; + double val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvSURFParams result; + + if (!SWIG_check_num_args("cvSURFParams",args.length(),2,1,0)) { + SWIG_fail; + } + ecode1 = SWIG_AsVal_double(args(0), &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cvSURFParams" "', argument " "1"" of type '" "double""'"); + } + arg1 = (double)(val1); + if (1delta = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_delta_get (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_delta_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_delta_get" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + result = (int) ((arg1)->delta); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_maxArea_set (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_maxArea_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_maxArea_set" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMSERParams_maxArea_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->maxArea = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_maxArea_get (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_maxArea_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_maxArea_get" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + result = (int) ((arg1)->maxArea); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_minArea_set (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_minArea_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_minArea_set" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMSERParams_minArea_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->minArea = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_minArea_get (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_minArea_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_minArea_get" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + result = (int) ((arg1)->minArea); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_maxVariation_set (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_maxVariation_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_maxVariation_set" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMSERParams_maxVariation_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->maxVariation = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_maxVariation_get (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_maxVariation_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_maxVariation_get" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + result = (float) ((arg1)->maxVariation); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_minDiversity_set (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_minDiversity_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_minDiversity_set" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMSERParams_minDiversity_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->minDiversity = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_minDiversity_get (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_minDiversity_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_minDiversity_get" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + result = (float) ((arg1)->minDiversity); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_maxEvolution_set (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_maxEvolution_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_maxEvolution_set" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMSERParams_maxEvolution_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->maxEvolution = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_maxEvolution_get (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_maxEvolution_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_maxEvolution_get" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + result = (int) ((arg1)->maxEvolution); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_areaThreshold_set (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_areaThreshold_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_areaThreshold_set" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMSERParams_areaThreshold_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->areaThreshold = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_areaThreshold_get (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_areaThreshold_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_areaThreshold_get" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + result = (double) ((arg1)->areaThreshold); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_minMargin_set (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_minMargin_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_minMargin_set" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + ecode2 = SWIG_AsVal_double(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMSERParams_minMargin_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (arg1) (arg1)->minMargin = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_minMargin_get (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_minMargin_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_minMargin_get" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + result = (double) ((arg1)->minMargin); + _outv = SWIG_From_double((double)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_edgeBlurSize_set (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_edgeBlurSize_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_edgeBlurSize_set" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvMSERParams_edgeBlurSize_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->edgeBlurSize = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvMSERParams_edgeBlurSize_get (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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("CvMSERParams_edgeBlurSize_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvMSERParams_edgeBlurSize_get" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(argp1); + result = (int) ((arg1)->edgeBlurSize); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvMSERParams (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMSERParams *result = 0 ; + + if (!SWIG_check_num_args("new_CvMSERParams",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvMSERParams *)new CvMSERParams(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvMSERParams, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvMSERParams (const octave_value_list& args, int nargout) { + CvMSERParams *arg1 = (CvMSERParams *) 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_CvMSERParams",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvMSERParams, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvMSERParams" "', argument " "1"" of type '" "CvMSERParams *""'"); + } + arg1 = (CvMSERParams *)(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_CvMSERParams_members[] = { +{"delta",0,_wrap_CvMSERParams_delta_get,_wrap_CvMSERParams_delta_set,0,0}, +{"maxArea",0,_wrap_CvMSERParams_maxArea_get,_wrap_CvMSERParams_maxArea_set,0,0}, +{"minArea",0,_wrap_CvMSERParams_minArea_get,_wrap_CvMSERParams_minArea_set,0,0}, +{"maxVariation",0,_wrap_CvMSERParams_maxVariation_get,_wrap_CvMSERParams_maxVariation_set,0,0}, +{"minDiversity",0,_wrap_CvMSERParams_minDiversity_get,_wrap_CvMSERParams_minDiversity_set,0,0}, +{"maxEvolution",0,_wrap_CvMSERParams_maxEvolution_get,_wrap_CvMSERParams_maxEvolution_set,0,0}, +{"areaThreshold",0,_wrap_CvMSERParams_areaThreshold_get,_wrap_CvMSERParams_areaThreshold_set,0,0}, +{"minMargin",0,_wrap_CvMSERParams_minMargin_get,_wrap_CvMSERParams_minMargin_set,0,0}, +{"edgeBlurSize",0,_wrap_CvMSERParams_edgeBlurSize_get,_wrap_CvMSERParams_edgeBlurSize_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvMSERParams_base_names[] = {0}; +static const swig_type_info *swig_CvMSERParams_base[] = {0}; +static swig_octave_class _wrap_class_CvMSERParams = {"CvMSERParams", &SWIGTYPE_p_CvMSERParams,0,_wrap_new_CvMSERParams,0,_wrap_delete_CvMSERParams,swig_CvMSERParams_members,swig_CvMSERParams_base_names,swig_CvMSERParams_base }; + +static octave_value_list _wrap_cvMSERParams (const octave_value_list& args, int nargout) { + int arg1 = (int) 5 ; + int arg2 = (int) 60 ; + int arg3 = (int) 14400 ; + float arg4 = (float) .25 ; + float arg5 = (float) .2 ; + int arg6 = (int) 200 ; + double arg7 = (double) 1.01 ; + double arg8 = (double) .003 ; + int arg9 = (int) 5 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + float val4 ; + int ecode4 = 0 ; + float val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; + int val9 ; + int ecode9 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvMSERParams result; + + if (!SWIG_check_num_args("cvMSERParams",args.length(),9,0,0)) { + SWIG_fail; + } + if (0pt = *arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarKeypoint_pt_get (const octave_value_list& args, int nargout) { + CvStarKeypoint *arg1 = (CvStarKeypoint *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvStarKeypoint_pt_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarKeypoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarKeypoint_pt_get" "', argument " "1"" of type '" "CvStarKeypoint *""'"); + } + arg1 = (CvStarKeypoint *)(argp1); + result = (CvPoint *)& ((arg1)->pt); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarKeypoint_size_set (const octave_value_list& args, int nargout) { + CvStarKeypoint *arg1 = (CvStarKeypoint *) 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("CvStarKeypoint_size_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarKeypoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarKeypoint_size_set" "', argument " "1"" of type '" "CvStarKeypoint *""'"); + } + arg1 = (CvStarKeypoint *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStarKeypoint_size_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->size = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarKeypoint_size_get (const octave_value_list& args, int nargout) { + CvStarKeypoint *arg1 = (CvStarKeypoint *) 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("CvStarKeypoint_size_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarKeypoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarKeypoint_size_get" "', argument " "1"" of type '" "CvStarKeypoint *""'"); + } + arg1 = (CvStarKeypoint *)(argp1); + result = (int) ((arg1)->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_CvStarKeypoint_response_set (const octave_value_list& args, int nargout) { + CvStarKeypoint *arg1 = (CvStarKeypoint *) 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("CvStarKeypoint_response_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarKeypoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarKeypoint_response_set" "', argument " "1"" of type '" "CvStarKeypoint *""'"); + } + arg1 = (CvStarKeypoint *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStarKeypoint_response_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->response = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarKeypoint_response_get (const octave_value_list& args, int nargout) { + CvStarKeypoint *arg1 = (CvStarKeypoint *) 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("CvStarKeypoint_response_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarKeypoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarKeypoint_response_get" "', argument " "1"" of type '" "CvStarKeypoint *""'"); + } + arg1 = (CvStarKeypoint *)(argp1); + result = (float) ((arg1)->response); + _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_CvStarKeypoint (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvStarKeypoint *result = 0 ; + + if (!SWIG_check_num_args("new_CvStarKeypoint",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvStarKeypoint *)new CvStarKeypoint(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStarKeypoint, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvStarKeypoint (const octave_value_list& args, int nargout) { + CvStarKeypoint *arg1 = (CvStarKeypoint *) 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_CvStarKeypoint",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarKeypoint, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvStarKeypoint" "', argument " "1"" of type '" "CvStarKeypoint *""'"); + } + arg1 = (CvStarKeypoint *)(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_CvStarKeypoint_members[] = { +{"pt",0,_wrap_CvStarKeypoint_pt_get,_wrap_CvStarKeypoint_pt_set,0,0}, +{"size",0,_wrap_CvStarKeypoint_size_get,_wrap_CvStarKeypoint_size_set,0,0}, +{"response",0,_wrap_CvStarKeypoint_response_get,_wrap_CvStarKeypoint_response_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvStarKeypoint_base_names[] = {0}; +static const swig_type_info *swig_CvStarKeypoint_base[] = {0}; +static swig_octave_class _wrap_class_CvStarKeypoint = {"CvStarKeypoint", &SWIGTYPE_p_CvStarKeypoint,0,_wrap_new_CvStarKeypoint,0,_wrap_delete_CvStarKeypoint,swig_CvStarKeypoint_members,swig_CvStarKeypoint_base_names,swig_CvStarKeypoint_base }; + +static octave_value_list _wrap_cvStarKeypoint (const octave_value_list& args, int nargout) { + CvPoint arg1 ; + int arg2 ; + float arg3 ; + int val2 ; + int ecode2 = 0 ; + float val3 ; + int ecode3 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvStarKeypoint result; + + if (!SWIG_check_num_args("cvStarKeypoint",args.length(),3,3,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvPoint(args(0)); + } + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cvStarKeypoint" "', 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 '" "cvStarKeypoint" "', argument " "3"" of type '" "float""'"); + } + arg3 = (float)(val3); + { + try { + result = cvStarKeypoint(arg1,arg2,arg3); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj((new CvStarKeypoint((const CvStarKeypoint&)(result))), SWIGTYPE_p_CvStarKeypoint, SWIG_POINTER_OWN | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarDetectorParams_maxSize_set (const octave_value_list& args, int nargout) { + CvStarDetectorParams *arg1 = (CvStarDetectorParams *) 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("CvStarDetectorParams_maxSize_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarDetectorParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarDetectorParams_maxSize_set" "', argument " "1"" of type '" "CvStarDetectorParams *""'"); + } + arg1 = (CvStarDetectorParams *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStarDetectorParams_maxSize_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->maxSize = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarDetectorParams_maxSize_get (const octave_value_list& args, int nargout) { + CvStarDetectorParams *arg1 = (CvStarDetectorParams *) 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("CvStarDetectorParams_maxSize_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarDetectorParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarDetectorParams_maxSize_get" "', argument " "1"" of type '" "CvStarDetectorParams *""'"); + } + arg1 = (CvStarDetectorParams *)(argp1); + result = (int) ((arg1)->maxSize); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarDetectorParams_responseThreshold_set (const octave_value_list& args, int nargout) { + CvStarDetectorParams *arg1 = (CvStarDetectorParams *) 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("CvStarDetectorParams_responseThreshold_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarDetectorParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarDetectorParams_responseThreshold_set" "', argument " "1"" of type '" "CvStarDetectorParams *""'"); + } + arg1 = (CvStarDetectorParams *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStarDetectorParams_responseThreshold_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->responseThreshold = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarDetectorParams_responseThreshold_get (const octave_value_list& args, int nargout) { + CvStarDetectorParams *arg1 = (CvStarDetectorParams *) 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("CvStarDetectorParams_responseThreshold_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarDetectorParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarDetectorParams_responseThreshold_get" "', argument " "1"" of type '" "CvStarDetectorParams *""'"); + } + arg1 = (CvStarDetectorParams *)(argp1); + result = (int) ((arg1)->responseThreshold); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarDetectorParams_lineThresholdProjected_set (const octave_value_list& args, int nargout) { + CvStarDetectorParams *arg1 = (CvStarDetectorParams *) 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("CvStarDetectorParams_lineThresholdProjected_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarDetectorParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarDetectorParams_lineThresholdProjected_set" "', argument " "1"" of type '" "CvStarDetectorParams *""'"); + } + arg1 = (CvStarDetectorParams *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStarDetectorParams_lineThresholdProjected_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->lineThresholdProjected = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarDetectorParams_lineThresholdProjected_get (const octave_value_list& args, int nargout) { + CvStarDetectorParams *arg1 = (CvStarDetectorParams *) 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("CvStarDetectorParams_lineThresholdProjected_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarDetectorParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarDetectorParams_lineThresholdProjected_get" "', argument " "1"" of type '" "CvStarDetectorParams *""'"); + } + arg1 = (CvStarDetectorParams *)(argp1); + result = (int) ((arg1)->lineThresholdProjected); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarDetectorParams_lineThresholdBinarized_set (const octave_value_list& args, int nargout) { + CvStarDetectorParams *arg1 = (CvStarDetectorParams *) 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("CvStarDetectorParams_lineThresholdBinarized_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarDetectorParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarDetectorParams_lineThresholdBinarized_set" "', argument " "1"" of type '" "CvStarDetectorParams *""'"); + } + arg1 = (CvStarDetectorParams *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStarDetectorParams_lineThresholdBinarized_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->lineThresholdBinarized = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarDetectorParams_lineThresholdBinarized_get (const octave_value_list& args, int nargout) { + CvStarDetectorParams *arg1 = (CvStarDetectorParams *) 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("CvStarDetectorParams_lineThresholdBinarized_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarDetectorParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarDetectorParams_lineThresholdBinarized_get" "', argument " "1"" of type '" "CvStarDetectorParams *""'"); + } + arg1 = (CvStarDetectorParams *)(argp1); + result = (int) ((arg1)->lineThresholdBinarized); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarDetectorParams_suppressNonmaxSize_set (const octave_value_list& args, int nargout) { + CvStarDetectorParams *arg1 = (CvStarDetectorParams *) 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("CvStarDetectorParams_suppressNonmaxSize_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarDetectorParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarDetectorParams_suppressNonmaxSize_set" "', argument " "1"" of type '" "CvStarDetectorParams *""'"); + } + arg1 = (CvStarDetectorParams *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStarDetectorParams_suppressNonmaxSize_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->suppressNonmaxSize = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStarDetectorParams_suppressNonmaxSize_get (const octave_value_list& args, int nargout) { + CvStarDetectorParams *arg1 = (CvStarDetectorParams *) 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("CvStarDetectorParams_suppressNonmaxSize_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarDetectorParams, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStarDetectorParams_suppressNonmaxSize_get" "', argument " "1"" of type '" "CvStarDetectorParams *""'"); + } + arg1 = (CvStarDetectorParams *)(argp1); + result = (int) ((arg1)->suppressNonmaxSize); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvStarDetectorParams (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvStarDetectorParams *result = 0 ; + + if (!SWIG_check_num_args("new_CvStarDetectorParams",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvStarDetectorParams *)new CvStarDetectorParams(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStarDetectorParams, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvStarDetectorParams (const octave_value_list& args, int nargout) { + CvStarDetectorParams *arg1 = (CvStarDetectorParams *) 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_CvStarDetectorParams",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStarDetectorParams, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvStarDetectorParams" "', argument " "1"" of type '" "CvStarDetectorParams *""'"); + } + arg1 = (CvStarDetectorParams *)(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_CvStarDetectorParams_members[] = { +{"maxSize",0,_wrap_CvStarDetectorParams_maxSize_get,_wrap_CvStarDetectorParams_maxSize_set,0,0}, +{"responseThreshold",0,_wrap_CvStarDetectorParams_responseThreshold_get,_wrap_CvStarDetectorParams_responseThreshold_set,0,0}, +{"lineThresholdProjected",0,_wrap_CvStarDetectorParams_lineThresholdProjected_get,_wrap_CvStarDetectorParams_lineThresholdProjected_set,0,0}, +{"lineThresholdBinarized",0,_wrap_CvStarDetectorParams_lineThresholdBinarized_get,_wrap_CvStarDetectorParams_lineThresholdBinarized_set,0,0}, +{"suppressNonmaxSize",0,_wrap_CvStarDetectorParams_suppressNonmaxSize_get,_wrap_CvStarDetectorParams_suppressNonmaxSize_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvStarDetectorParams_base_names[] = {0}; +static const swig_type_info *swig_CvStarDetectorParams_base[] = {0}; +static swig_octave_class _wrap_class_CvStarDetectorParams = {"CvStarDetectorParams", &SWIGTYPE_p_CvStarDetectorParams,0,_wrap_new_CvStarDetectorParams,0,_wrap_delete_CvStarDetectorParams,swig_CvStarDetectorParams_members,swig_CvStarDetectorParams_base_names,swig_CvStarDetectorParams_base }; + +static octave_value_list _wrap_cvStarDetectorParams (const octave_value_list& args, int nargout) { + int arg1 = (int) 45 ; + int arg2 = (int) 30 ; + int arg3 = (int) 10 ; + int arg4 = (int) 8 ; + int arg5 = (int) 5 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 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; + CvStarDetectorParams result; + + if (!SWIG_check_num_args("cvStarDetectorParams",args.length(),5,0,0)) { + SWIG_fail; + } + if (0width*pattern_size2->height; + + tmp_corners2 = (CvPoint2D32f *) malloc(sizeof(CvPoint2D32f)*tmp_ncorners2); + arg2 = *pattern_size2; + arg3 = tmp_corners2; + arg4 = &tmp_ncorners2; + } + if (2x = tmp_corners2[i].x; + pt->y = tmp_corners2[i].y; + + OctList_SetItem (to_add, i, + SWIG_NewPointerObj( pt, SWIGTYPE_p_CvPoint2D32f, 0)); + } + + _outp = SWIG_AppendResult( _outp, &to_add, 1); + free(tmp_corners2); + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvDrawChessboardCorners (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvSize arg2 ; + CvPoint2D32f *arg3 = (CvPoint2D32f *) 0 ; + int arg4 ; + int arg5 ; + bool freearg1 = false ; + void *argp2 ; + int res2 = 0 ; + int cornersCount3 ; + CvPoint2D32f *corners3 ; + int val5 ; + int ecode5 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvDrawChessboardCorners",args.length(),4,4,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + res2 = SWIG_ConvertPtr(args(1), &argp2, SWIGTYPE_p_CvSize, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cvDrawChessboardCorners" "', argument " "2"" of type '" "CvSize""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvDrawChessboardCorners" "', argument " "2"" of type '" "CvSize""'"); + } else { + arg2 = *((CvSize *)(argp2)); + } + } + { + int i; + + if(!OctList_Check(args(2))){ + error("Expected a list"); + SWIG_fail; + } + + // get the size of the input array + cornersCount3 = OctList_Size (args(2)); + arg4 = cornersCount3; + + // allocate the needed memory + corners3 = (CvPoint2D32f *)malloc (arg4 * sizeof (CvPoint2D32f)); + arg3 = corners3; + + // the size of the array for the C call + + // extract all the points values from the list + for (i = 0; i < arg4; i++) { + octave_value item = OctList_GetItem (args(2), i); + + void *vptr; + SWIG_Octave_ConvertPtr (item, &vptr, + SWIGTYPE_p_CvPoint2D32f, + SWIG_POINTER_EXCEPTION); + CvPoint2D32f *p = (CvPoint2D32f *) vptr;; + arg3 [i].x = p->x; + arg3 [i].y = p->y; + } + } + ecode5 = SWIG_AsVal_int(args(3), &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cvDrawChessboardCorners" "', argument " "5"" of type '" "int""'"); + } + arg5 = (int)(val5); + { + try { + cvDrawChessboardCorners(arg1,arg2,arg3,arg4,arg5); + } + catch (...) + { + SWIG_fail; + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); + { + int i; + octave_value to_add; + + // create the list to return + to_add = OctList_New (cornersCount3); + + // extract all the corner values of the result, and add it to the + // final resulting list + for (i = 0; i < cornersCount3; i++) { + OctList_SetItem (to_add, i, + SWIG_NewPointerObj (&(corners3 [i]), + SWIGTYPE_p_CvPoint2D32f, 0)); + } + + _outp = SWIG_AppendResult( _outp, &to_add, 1); + } + { + if(arg1!=NULL && freearg1){ + cvReleaseData( arg1 ); + cvFree(&(arg1)); + } + } +fail: + return _out; +} + + +static octave_value_list _wrap_cvCalibrateCamera2 (const octave_value_list& args, int nargout) { + CvMat *arg1 = (CvMat *) 0 ; + CvMat *arg2 = (CvMat *) 0 ; + CvMat *arg3 = (CvMat *) 0 ; + CvSize arg4 ; + CvMat *arg5 = (CvMat *) 0 ; + CvMat *arg6 = (CvMat *) 0 ; + CvMat *arg7 = (CvMat *) NULL ; + CvMat *arg8 = (CvMat *) NULL ; + int arg9 = (int) 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 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + int val9 ; + int ecode9 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvCalibrateCamera2",args.length(),9,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 '" "cvCalibrateCamera2" "', 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 '" "cvCalibrateCamera2" "', 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 '" "cvCalibrateCamera2" "', argument " "3"" of type '" "CvMat const *""'"); + } + arg3 = (CvMat *)(argp3); + { + res4 = SWIG_ConvertPtr(args(3), &argp4, SWIGTYPE_p_CvSize, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cvCalibrateCamera2" "', argument " "4"" of type '" "CvSize""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cvCalibrateCamera2" "', argument " "4"" of type '" "CvSize""'"); + } else { + arg4 = *((CvSize *)(argp4)); + } + } + res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvMat, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvCalibrateCamera2" "', argument " "5"" of type '" "CvMat *""'"); + } + 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 '" "cvCalibrateCamera2" "', argument " "6"" of type '" "CvMat *""'"); + } + arg6 = (CvMat *)(argp6); + if (6preFilterType = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_preFilterType_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_preFilterType_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilterType_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (int) ((arg1)->preFilterType); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_preFilterSize_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_preFilterSize_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilterSize_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_preFilterSize_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->preFilterSize = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_preFilterSize_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_preFilterSize_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilterSize_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (int) ((arg1)->preFilterSize); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_preFilterCap_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_preFilterCap_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilterCap_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_preFilterCap_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->preFilterCap = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_preFilterCap_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_preFilterCap_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilterCap_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (int) ((arg1)->preFilterCap); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_SADWindowSize_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_SADWindowSize_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_SADWindowSize_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_SADWindowSize_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->SADWindowSize = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_SADWindowSize_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_SADWindowSize_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_SADWindowSize_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (int) ((arg1)->SADWindowSize); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_minDisparity_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_minDisparity_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_minDisparity_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_minDisparity_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->minDisparity = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_minDisparity_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_minDisparity_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_minDisparity_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (int) ((arg1)->minDisparity); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_numberOfDisparities_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_numberOfDisparities_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_numberOfDisparities_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_numberOfDisparities_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->numberOfDisparities = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_numberOfDisparities_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_numberOfDisparities_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_numberOfDisparities_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (int) ((arg1)->numberOfDisparities); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_textureThreshold_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_textureThreshold_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_textureThreshold_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_textureThreshold_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->textureThreshold = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_textureThreshold_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_textureThreshold_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_textureThreshold_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (int) ((arg1)->textureThreshold); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_uniquenessRatio_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_uniquenessRatio_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_uniquenessRatio_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_uniquenessRatio_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->uniquenessRatio = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_uniquenessRatio_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_uniquenessRatio_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_uniquenessRatio_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (int) ((arg1)->uniquenessRatio); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_speckleWindowSize_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_speckleWindowSize_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_speckleWindowSize_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_speckleWindowSize_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->speckleWindowSize = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_speckleWindowSize_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_speckleWindowSize_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_speckleWindowSize_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (int) ((arg1)->speckleWindowSize); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_speckleRange_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_speckleRange_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_speckleRange_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_speckleRange_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->speckleRange = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_speckleRange_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_speckleRange_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_speckleRange_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (int) ((arg1)->speckleRange); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_trySmallerWindows_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_trySmallerWindows_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_trySmallerWindows_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoBMState_trySmallerWindows_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->trySmallerWindows = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_trySmallerWindows_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_trySmallerWindows_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_trySmallerWindows_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (int) ((arg1)->trySmallerWindows); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_preFilteredImg0_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_preFilteredImg0_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilteredImg0_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(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 '" "CvStereoBMState_preFilteredImg0_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->preFilteredImg0 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_preFilteredImg0_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_preFilteredImg0_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilteredImg0_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (CvMat *) ((arg1)->preFilteredImg0); + _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_CvStereoBMState_preFilteredImg1_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_preFilteredImg1_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilteredImg1_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(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 '" "CvStereoBMState_preFilteredImg1_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->preFilteredImg1 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_preFilteredImg1_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_preFilteredImg1_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_preFilteredImg1_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (CvMat *) ((arg1)->preFilteredImg1); + _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_CvStereoBMState_slidingSumBuf_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_slidingSumBuf_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_slidingSumBuf_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(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 '" "CvStereoBMState_slidingSumBuf_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->slidingSumBuf = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_slidingSumBuf_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_slidingSumBuf_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_slidingSumBuf_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (CvMat *) ((arg1)->slidingSumBuf); + _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_CvStereoBMState_dbmin_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_dbmin_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_dbmin_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(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 '" "CvStereoBMState_dbmin_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->dbmin = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_dbmin_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_dbmin_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_dbmin_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (CvMat *) ((arg1)->dbmin); + _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_CvStereoBMState_dbmax_set (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_dbmax_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_dbmax_set" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(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 '" "CvStereoBMState_dbmax_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->dbmax = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoBMState_dbmax_get (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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("CvStereoBMState_dbmax_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoBMState_dbmax_get" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(argp1); + result = (CvMat *) ((arg1)->dbmax); + _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_CvStereoBMState (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvStereoBMState *result = 0 ; + + if (!SWIG_check_num_args("new_CvStereoBMState",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvStereoBMState *)new CvStereoBMState(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStereoBMState, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvStereoBMState (const octave_value_list& args, int nargout) { + CvStereoBMState *arg1 = (CvStereoBMState *) 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_CvStereoBMState",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoBMState, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvStereoBMState" "', argument " "1"" of type '" "CvStereoBMState *""'"); + } + arg1 = (CvStereoBMState *)(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_CvStereoBMState_members[] = { +{"preFilterType",0,_wrap_CvStereoBMState_preFilterType_get,_wrap_CvStereoBMState_preFilterType_set,0,0}, +{"preFilterSize",0,_wrap_CvStereoBMState_preFilterSize_get,_wrap_CvStereoBMState_preFilterSize_set,0,0}, +{"preFilterCap",0,_wrap_CvStereoBMState_preFilterCap_get,_wrap_CvStereoBMState_preFilterCap_set,0,0}, +{"SADWindowSize",0,_wrap_CvStereoBMState_SADWindowSize_get,_wrap_CvStereoBMState_SADWindowSize_set,0,0}, +{"minDisparity",0,_wrap_CvStereoBMState_minDisparity_get,_wrap_CvStereoBMState_minDisparity_set,0,0}, +{"numberOfDisparities",0,_wrap_CvStereoBMState_numberOfDisparities_get,_wrap_CvStereoBMState_numberOfDisparities_set,0,0}, +{"textureThreshold",0,_wrap_CvStereoBMState_textureThreshold_get,_wrap_CvStereoBMState_textureThreshold_set,0,0}, +{"uniquenessRatio",0,_wrap_CvStereoBMState_uniquenessRatio_get,_wrap_CvStereoBMState_uniquenessRatio_set,0,0}, +{"speckleWindowSize",0,_wrap_CvStereoBMState_speckleWindowSize_get,_wrap_CvStereoBMState_speckleWindowSize_set,0,0}, +{"speckleRange",0,_wrap_CvStereoBMState_speckleRange_get,_wrap_CvStereoBMState_speckleRange_set,0,0}, +{"trySmallerWindows",0,_wrap_CvStereoBMState_trySmallerWindows_get,_wrap_CvStereoBMState_trySmallerWindows_set,0,0}, +{"preFilteredImg0",0,_wrap_CvStereoBMState_preFilteredImg0_get,_wrap_CvStereoBMState_preFilteredImg0_set,0,0}, +{"preFilteredImg1",0,_wrap_CvStereoBMState_preFilteredImg1_get,_wrap_CvStereoBMState_preFilteredImg1_set,0,0}, +{"slidingSumBuf",0,_wrap_CvStereoBMState_slidingSumBuf_get,_wrap_CvStereoBMState_slidingSumBuf_set,0,0}, +{"dbmin",0,_wrap_CvStereoBMState_dbmin_get,_wrap_CvStereoBMState_dbmin_set,0,0}, +{"dbmax",0,_wrap_CvStereoBMState_dbmax_get,_wrap_CvStereoBMState_dbmax_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvStereoBMState_base_names[] = {0}; +static const swig_type_info *swig_CvStereoBMState_base[] = {0}; +static swig_octave_class _wrap_class_CvStereoBMState = {"CvStereoBMState", &SWIGTYPE_p_CvStereoBMState,0,_wrap_new_CvStereoBMState,0,_wrap_delete_CvStereoBMState,swig_CvStereoBMState_members,swig_CvStereoBMState_base_names,swig_CvStereoBMState_base }; + +static octave_value_list _wrap_cvCreateStereoBMState (const octave_value_list& args, int nargout) { + int arg1 = (int) 0 ; + int arg2 = (int) 0 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvStereoBMState *result = 0 ; + + if (!SWIG_check_num_args("cvCreateStereoBMState",args.length(),2,0,0)) { + SWIG_fail; + } + if (0Ithreshold = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_Ithreshold_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_Ithreshold_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_Ithreshold_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (int) ((arg1)->Ithreshold); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_interactionRadius_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_interactionRadius_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_interactionRadius_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_interactionRadius_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->interactionRadius = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_interactionRadius_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_interactionRadius_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_interactionRadius_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (int) ((arg1)->interactionRadius); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_K_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_K_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_K_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_K_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->K = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_K_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_K_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_K_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (float) ((arg1)->K); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_lambda_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_lambda_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_lambda_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_lambda_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->lambda = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_lambda_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_lambda_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_lambda_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (float) ((arg1)->lambda); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_lambda1_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_lambda1_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_lambda1_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_lambda1_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->lambda1 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_lambda1_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_lambda1_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_lambda1_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (float) ((arg1)->lambda1); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_lambda2_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_lambda2_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_lambda2_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + ecode2 = SWIG_AsVal_float(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_lambda2_set" "', argument " "2"" of type '" "float""'"); + } + arg2 = (float)(val2); + if (arg1) (arg1)->lambda2 = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_lambda2_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_lambda2_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_lambda2_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (float) ((arg1)->lambda2); + _outv = SWIG_From_float((float)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_occlusionCost_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_occlusionCost_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_occlusionCost_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_occlusionCost_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->occlusionCost = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_occlusionCost_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_occlusionCost_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_occlusionCost_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (int) ((arg1)->occlusionCost); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_minDisparity_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_minDisparity_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_minDisparity_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_minDisparity_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->minDisparity = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_minDisparity_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_minDisparity_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_minDisparity_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (int) ((arg1)->minDisparity); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_numberOfDisparities_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_numberOfDisparities_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_numberOfDisparities_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_numberOfDisparities_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->numberOfDisparities = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_numberOfDisparities_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_numberOfDisparities_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_numberOfDisparities_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (int) ((arg1)->numberOfDisparities); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_maxIters_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_maxIters_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_maxIters_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvStereoGCState_maxIters_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (arg1) (arg1)->maxIters = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_maxIters_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_maxIters_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_maxIters_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (int) ((arg1)->maxIters); + _outv = SWIG_From_int((int)(result)); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_left_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_left_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_left_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(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 '" "CvStereoGCState_left_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(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_CvStereoGCState_left_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_left_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_left_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (CvMat *) ((arg1)->left); + _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_CvStereoGCState_right_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_right_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_right_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(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 '" "CvStereoGCState_right_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(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_CvStereoGCState_right_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_right_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_right_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (CvMat *) ((arg1)->right); + _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_CvStereoGCState_dispLeft_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_dispLeft_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_dispLeft_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(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 '" "CvStereoGCState_dispLeft_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->dispLeft = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_dispLeft_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_dispLeft_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_dispLeft_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (CvMat *) ((arg1)->dispLeft); + _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_CvStereoGCState_dispRight_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_dispRight_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_dispRight_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(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 '" "CvStereoGCState_dispRight_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->dispRight = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_dispRight_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_dispRight_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_dispRight_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (CvMat *) ((arg1)->dispRight); + _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_CvStereoGCState_ptrLeft_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_ptrLeft_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_ptrLeft_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(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 '" "CvStereoGCState_ptrLeft_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->ptrLeft = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_ptrLeft_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_ptrLeft_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_ptrLeft_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (CvMat *) ((arg1)->ptrLeft); + _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_CvStereoGCState_ptrRight_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_ptrRight_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_ptrRight_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(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 '" "CvStereoGCState_ptrRight_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->ptrRight = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_ptrRight_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_ptrRight_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_ptrRight_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (CvMat *) ((arg1)->ptrRight); + _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_CvStereoGCState_vtxBuf_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_vtxBuf_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_vtxBuf_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(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 '" "CvStereoGCState_vtxBuf_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->vtxBuf = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_vtxBuf_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_vtxBuf_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_vtxBuf_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (CvMat *) ((arg1)->vtxBuf); + _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_CvStereoGCState_edgeBuf_set (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_edgeBuf_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_edgeBuf_set" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(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 '" "CvStereoGCState_edgeBuf_set" "', argument " "2"" of type '" "CvMat *""'"); + } + arg2 = (CvMat *)(argp2); + if (arg1) (arg1)->edgeBuf = arg2; + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvStereoGCState_edgeBuf_get (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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("CvStereoGCState_edgeBuf_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvStereoGCState_edgeBuf_get" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(argp1); + result = (CvMat *) ((arg1)->edgeBuf); + _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_CvStereoGCState (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvStereoGCState *result = 0 ; + + if (!SWIG_check_num_args("new_CvStereoGCState",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvStereoGCState *)new CvStereoGCState(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStereoGCState, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvStereoGCState (const octave_value_list& args, int nargout) { + CvStereoGCState *arg1 = (CvStereoGCState *) 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_CvStereoGCState",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvStereoGCState, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvStereoGCState" "', argument " "1"" of type '" "CvStereoGCState *""'"); + } + arg1 = (CvStereoGCState *)(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_CvStereoGCState_members[] = { +{"Ithreshold",0,_wrap_CvStereoGCState_Ithreshold_get,_wrap_CvStereoGCState_Ithreshold_set,0,0}, +{"interactionRadius",0,_wrap_CvStereoGCState_interactionRadius_get,_wrap_CvStereoGCState_interactionRadius_set,0,0}, +{"K",0,_wrap_CvStereoGCState_K_get,_wrap_CvStereoGCState_K_set,0,0}, +{"lambda",0,_wrap_CvStereoGCState_lambda_get,_wrap_CvStereoGCState_lambda_set,0,0}, +{"lambda1",0,_wrap_CvStereoGCState_lambda1_get,_wrap_CvStereoGCState_lambda1_set,0,0}, +{"lambda2",0,_wrap_CvStereoGCState_lambda2_get,_wrap_CvStereoGCState_lambda2_set,0,0}, +{"occlusionCost",0,_wrap_CvStereoGCState_occlusionCost_get,_wrap_CvStereoGCState_occlusionCost_set,0,0}, +{"minDisparity",0,_wrap_CvStereoGCState_minDisparity_get,_wrap_CvStereoGCState_minDisparity_set,0,0}, +{"numberOfDisparities",0,_wrap_CvStereoGCState_numberOfDisparities_get,_wrap_CvStereoGCState_numberOfDisparities_set,0,0}, +{"maxIters",0,_wrap_CvStereoGCState_maxIters_get,_wrap_CvStereoGCState_maxIters_set,0,0}, +{"left",0,_wrap_CvStereoGCState_left_get,_wrap_CvStereoGCState_left_set,0,0}, +{"right",0,_wrap_CvStereoGCState_right_get,_wrap_CvStereoGCState_right_set,0,0}, +{"dispLeft",0,_wrap_CvStereoGCState_dispLeft_get,_wrap_CvStereoGCState_dispLeft_set,0,0}, +{"dispRight",0,_wrap_CvStereoGCState_dispRight_get,_wrap_CvStereoGCState_dispRight_set,0,0}, +{"ptrLeft",0,_wrap_CvStereoGCState_ptrLeft_get,_wrap_CvStereoGCState_ptrLeft_set,0,0}, +{"ptrRight",0,_wrap_CvStereoGCState_ptrRight_get,_wrap_CvStereoGCState_ptrRight_set,0,0}, +{"vtxBuf",0,_wrap_CvStereoGCState_vtxBuf_get,_wrap_CvStereoGCState_vtxBuf_set,0,0}, +{"edgeBuf",0,_wrap_CvStereoGCState_edgeBuf_get,_wrap_CvStereoGCState_edgeBuf_set,0,0}, +{0,0,0,0} +}; +static const char *swig_CvStereoGCState_base_names[] = {0}; +static const swig_type_info *swig_CvStereoGCState_base[] = {0}; +static swig_octave_class _wrap_class_CvStereoGCState = {"CvStereoGCState", &SWIGTYPE_p_CvStereoGCState,0,_wrap_new_CvStereoGCState,0,_wrap_delete_CvStereoGCState,swig_CvStereoGCState_members,swig_CvStereoGCState_base_names,swig_CvStereoGCState_base }; + +static octave_value_list _wrap_cvCreateStereoGCState (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; + CvStereoGCState *result = 0 ; + + if (!SWIG_check_num_args("cvCreateStereoGCState",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 '" "cvCreateStereoGCState" "', 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 '" "cvCreateStereoGCState" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvStereoGCState *)cvCreateStereoGCState(arg1,arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_cvReleaseStereoGCState (const octave_value_list& args, int nargout) { + CvStereoGCState **arg1 = (CvStereoGCState **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("cvReleaseStereoGCState",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cvReleaseStereoGCState" "', argument " "1"" of type '" "CvStereoGCState **""'"); + } + arg1 = (CvStereoGCState **)(argp1); + { + try { + cvReleaseStereoGCState(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_cvFindStereoCorrespondenceGC (const octave_value_list& args, int nargout) { + CvArr *arg1 = (CvArr *) 0 ; + CvArr *arg2 = (CvArr *) 0 ; + CvArr *arg3 = (CvArr *) 0 ; + CvArr *arg4 = (CvArr *) 0 ; + CvStereoGCState *arg5 = (CvStereoGCState *) 0 ; + int arg6 = (int) 0 ; + bool freearg1 = false ; + bool freearg2 = false ; + bool freearg3 = false ; + bool freearg4 = false ; + 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("cvFindStereoCorrespondenceGC",args.length(),6,5,0)) { + SWIG_fail; + } + { + arg1 = OctObject_to_CvArr(args(0), &freearg1); + } + { + arg2 = OctObject_to_CvArr(args(1), &freearg2); + } + { + arg3 = OctObject_to_CvArr(args(2), &freearg3); + } + { + arg4 = OctObject_to_CvArr(args(3), &freearg4); + } + res5 = SWIG_ConvertPtr(args(4), &argp5,SWIGTYPE_p_CvStereoGCState, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cvFindStereoCorrespondenceGC" "', argument " "5"" of type '" "CvStereoGCState *""'"); + } + arg5 = (CvStereoGCState *)(argp5); + if (5 *arg1 = (CvTuple< CvPoint,2 > *) 0 ; + CvPoint *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("CvTuple_CvPoint_2_val_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_CvPoint_2_val_set" "', argument " "1"" of type '" "CvTuple< CvPoint,2 > *""'"); + } + arg1 = (CvTuple< CvPoint,2 > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTuple_CvPoint_2_val_set" "', argument " "2"" of type '" "CvPoint [2]""'"); + } + arg2 = (CvPoint *)(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)2; ++ii) arg1->val[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' of type '""CvPoint [2]""'"); + } + } + _outv = octave_value(); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTuple_CvPoint_2_val_get (const octave_value_list& args, int nargout) { + CvTuple< CvPoint,2 > *arg1 = (CvTuple< CvPoint,2 > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvTuple_CvPoint_2_val_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_CvPoint_2_val_get" "', argument " "1"" of type '" "CvTuple< CvPoint,2 > *""'"); + } + arg1 = (CvTuple< CvPoint,2 > *)(argp1); + result = (CvPoint *)(CvPoint *) ((arg1)->val); + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTuple_CvPoint_2___paren (const octave_value_list& args, int nargout) { + CvTuple< CvPoint,2 > *arg1 = (CvTuple< CvPoint,2 > *) 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; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvTuple_CvPoint_2___paren",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_CvPoint_2___paren" "', argument " "1"" of type '" "CvTuple< CvPoint,2 > *""'"); + } + arg1 = (CvTuple< CvPoint,2 > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_CvPoint_2___paren" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvPoint *) &(arg1)->__paren(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTuple_CvPoint_2___paren_asgn (const octave_value_list& args, int nargout) { + CvTuple< CvPoint,2 > *arg1 = (CvTuple< CvPoint,2 > *) 0 ; + int arg2 ; + CvPoint *arg3 = (CvPoint *) 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; + + if (!SWIG_check_num_args("CvTuple_CvPoint_2___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_CvPoint_2___paren_asgn" "', argument " "1"" of type '" "CvTuple< CvPoint,2 > *""'"); + } + arg1 = (CvTuple< CvPoint,2 > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_CvPoint_2___paren_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvTuple_CvPoint_2___paren_asgn" "', argument " "3"" of type '" "CvPoint *""'"); + } + arg3 = (CvPoint *)(argp3); + { + try { + (arg1)->__paren_asgn(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_CvTuple_CvPoint_2___brace (const octave_value_list& args, int nargout) { + CvTuple< CvPoint,2 > *arg1 = (CvTuple< CvPoint,2 > *) 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; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvTuple_CvPoint_2___brace",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_CvPoint_2___brace" "', argument " "1"" of type '" "CvTuple< CvPoint,2 > *""'"); + } + arg1 = (CvTuple< CvPoint,2 > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_CvPoint_2___brace" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvPoint *) &(arg1)->__brace(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvTuple_CvPoint_2___brace_asgn (const octave_value_list& args, int nargout) { + CvTuple< CvPoint,2 > *arg1 = (CvTuple< CvPoint,2 > *) 0 ; + int arg2 ; + CvPoint *arg3 = (CvPoint *) 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; + + if (!SWIG_check_num_args("CvTuple_CvPoint_2___brace_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_CvPoint_2___brace_asgn" "', argument " "1"" of type '" "CvTuple< CvPoint,2 > *""'"); + } + arg1 = (CvTuple< CvPoint,2 > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_CvPoint_2___brace_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvTuple_CvPoint_2___brace_asgn" "', argument " "3"" of type '" "CvPoint *""'"); + } + arg3 = (CvPoint *)(argp3); + { + try { + (arg1)->__brace_asgn(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_CvTuple_CvPoint_2 (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTuple< CvPoint,2 > *result = 0 ; + + if (!SWIG_check_num_args("new_CvTuple_CvPoint_2",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTuple< CvPoint,2 > *)new CvTuple< CvPoint,2 >(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_CvPoint_2_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvTuple_CvPoint_2 (const octave_value_list& args, int nargout) { + CvTuple< CvPoint,2 > *arg1 = (CvTuple< CvPoint,2 > *) 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_CvTuple_CvPoint_2",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_CvPoint_2_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTuple_CvPoint_2" "', argument " "1"" of type '" "CvTuple< CvPoint,2 > *""'"); + } + arg1 = (CvTuple< CvPoint,2 > *)(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_CvTuple_CvPoint_2_members[] = { +{"val",0,_wrap_CvTuple_CvPoint_2_val_get,_wrap_CvTuple_CvPoint_2_val_set,0,0}, +{"__paren",_wrap_CvTuple_CvPoint_2___paren,0,0,0,0}, +{"__paren_asgn",_wrap_CvTuple_CvPoint_2___paren_asgn,0,0,0,0}, +{"__brace",_wrap_CvTuple_CvPoint_2___brace,0,0,0,0}, +{"__brace_asgn",_wrap_CvTuple_CvPoint_2___brace_asgn,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvTuple_CvPoint_2_base_names[] = {0}; +static const swig_type_info *swig_CvTuple_CvPoint_2_base[] = {0}; +static swig_octave_class _wrap_class_CvTuple_CvPoint_2 = {"CvTuple_CvPoint_2", &SWIGTYPE_p_CvTupleT_CvPoint_2_t,0,_wrap_new_CvTuple_CvPoint_2,0,_wrap_delete_CvTuple_CvPoint_2,swig_CvTuple_CvPoint_2_members,swig_CvTuple_CvPoint_2_base_names,swig_CvTuple_CvPoint_2_base }; + +static octave_value_list _wrap_CvTuple_float_2_val_set (const octave_value_list& args, int nargout) { + CvTuple< float,2 > *arg1 = (CvTuple< float,2 > *) 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("CvTuple_float_2_val_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_2_val_set" "', argument " "1"" of type '" "CvTuple< float,2 > *""'"); + } + arg1 = (CvTuple< float,2 > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_float, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTuple_float_2_val_set" "', argument " "2"" of type '" "float [2]""'"); + } + arg2 = (float *)(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)2; ++ii) arg1->val[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' 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_CvTuple_float_2_val_get (const octave_value_list& args, int nargout) { + CvTuple< float,2 > *arg1 = (CvTuple< float,2 > *) 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("CvTuple_float_2_val_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_2_val_get" "', argument " "1"" of type '" "CvTuple< float,2 > *""'"); + } + arg1 = (CvTuple< float,2 > *)(argp1); + result = (float *)(float *) ((arg1)->val); + _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_CvTuple_float_2___paren (const octave_value_list& args, int nargout) { + CvTuple< float,2 > *arg1 = (CvTuple< float,2 > *) 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("CvTuple_float_2___paren",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_2___paren" "', argument " "1"" of type '" "CvTuple< float,2 > *""'"); + } + arg1 = (CvTuple< float,2 > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_float_2___paren" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (float *) &(arg1)->__paren(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_CvTuple_float_2___paren_asgn (const octave_value_list& args, int nargout) { + CvTuple< float,2 > *arg1 = (CvTuple< float,2 > *) 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; + + if (!SWIG_check_num_args("CvTuple_float_2___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_2___paren_asgn" "', argument " "1"" of type '" "CvTuple< float,2 > *""'"); + } + arg1 = (CvTuple< float,2 > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_float_2___paren_asgn" "', 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 '" "CvTuple_float_2___paren_asgn" "', argument " "3"" of type '" "float *""'"); + } + arg3 = (float *)(argp3); + { + try { + (arg1)->__paren_asgn(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_CvTuple_float_2___brace (const octave_value_list& args, int nargout) { + CvTuple< float,2 > *arg1 = (CvTuple< float,2 > *) 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("CvTuple_float_2___brace",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_2___brace" "', argument " "1"" of type '" "CvTuple< float,2 > *""'"); + } + arg1 = (CvTuple< float,2 > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_float_2___brace" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (float *) &(arg1)->__brace(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_CvTuple_float_2___brace_asgn (const octave_value_list& args, int nargout) { + CvTuple< float,2 > *arg1 = (CvTuple< float,2 > *) 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; + + if (!SWIG_check_num_args("CvTuple_float_2___brace_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_2___brace_asgn" "', argument " "1"" of type '" "CvTuple< float,2 > *""'"); + } + arg1 = (CvTuple< float,2 > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_float_2___brace_asgn" "', 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 '" "CvTuple_float_2___brace_asgn" "', argument " "3"" of type '" "float *""'"); + } + arg3 = (float *)(argp3); + { + try { + (arg1)->__brace_asgn(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_CvTuple_float_2 (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTuple< float,2 > *result = 0 ; + + if (!SWIG_check_num_args("new_CvTuple_float_2",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTuple< float,2 > *)new CvTuple< float,2 >(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_2_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvTuple_float_2 (const octave_value_list& args, int nargout) { + CvTuple< float,2 > *arg1 = (CvTuple< float,2 > *) 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_CvTuple_float_2",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_2_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTuple_float_2" "', argument " "1"" of type '" "CvTuple< float,2 > *""'"); + } + arg1 = (CvTuple< float,2 > *)(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_CvTuple_float_2_members[] = { +{"val",0,_wrap_CvTuple_float_2_val_get,_wrap_CvTuple_float_2_val_set,0,0}, +{"__paren",_wrap_CvTuple_float_2___paren,0,0,0,0}, +{"__paren_asgn",_wrap_CvTuple_float_2___paren_asgn,0,0,0,0}, +{"__brace",_wrap_CvTuple_float_2___brace,0,0,0,0}, +{"__brace_asgn",_wrap_CvTuple_float_2___brace_asgn,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvTuple_float_2_base_names[] = {0}; +static const swig_type_info *swig_CvTuple_float_2_base[] = {0}; +static swig_octave_class _wrap_class_CvTuple_float_2 = {"CvTuple_float_2", &SWIGTYPE_p_CvTupleT_float_2_t,0,_wrap_new_CvTuple_float_2,0,_wrap_delete_CvTuple_float_2,swig_CvTuple_float_2_members,swig_CvTuple_float_2_base_names,swig_CvTuple_float_2_base }; + +static octave_value_list _wrap_CvTuple_float_3_val_set (const octave_value_list& args, int nargout) { + CvTuple< float,3 > *arg1 = (CvTuple< float,3 > *) 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("CvTuple_float_3_val_set",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_3_val_set" "', argument " "1"" of type '" "CvTuple< float,3 > *""'"); + } + arg1 = (CvTuple< float,3 > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_float, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvTuple_float_3_val_set" "', argument " "2"" of type '" "float [2]""'"); + } + arg2 = (float *)(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)2; ++ii) arg1->val[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""val""' 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_CvTuple_float_3_val_get (const octave_value_list& args, int nargout) { + CvTuple< float,3 > *arg1 = (CvTuple< float,3 > *) 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("CvTuple_float_3_val_get",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_3_val_get" "', argument " "1"" of type '" "CvTuple< float,3 > *""'"); + } + arg1 = (CvTuple< float,3 > *)(argp1); + result = (float *)(float *) ((arg1)->val); + _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_CvTuple_float_3___paren (const octave_value_list& args, int nargout) { + CvTuple< float,3 > *arg1 = (CvTuple< float,3 > *) 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("CvTuple_float_3___paren",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_3___paren" "', argument " "1"" of type '" "CvTuple< float,3 > *""'"); + } + arg1 = (CvTuple< float,3 > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_float_3___paren" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (float *) &(arg1)->__paren(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_CvTuple_float_3___paren_asgn (const octave_value_list& args, int nargout) { + CvTuple< float,3 > *arg1 = (CvTuple< float,3 > *) 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; + + if (!SWIG_check_num_args("CvTuple_float_3___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_3___paren_asgn" "', argument " "1"" of type '" "CvTuple< float,3 > *""'"); + } + arg1 = (CvTuple< float,3 > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_float_3___paren_asgn" "', 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 '" "CvTuple_float_3___paren_asgn" "', argument " "3"" of type '" "float *""'"); + } + arg3 = (float *)(argp3); + { + try { + (arg1)->__paren_asgn(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_CvTuple_float_3___brace (const octave_value_list& args, int nargout) { + CvTuple< float,3 > *arg1 = (CvTuple< float,3 > *) 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("CvTuple_float_3___brace",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_3___brace" "', argument " "1"" of type '" "CvTuple< float,3 > *""'"); + } + arg1 = (CvTuple< float,3 > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_float_3___brace" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (float *) &(arg1)->__brace(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_CvTuple_float_3___brace_asgn (const octave_value_list& args, int nargout) { + CvTuple< float,3 > *arg1 = (CvTuple< float,3 > *) 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; + + if (!SWIG_check_num_args("CvTuple_float_3___brace_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvTuple_float_3___brace_asgn" "', argument " "1"" of type '" "CvTuple< float,3 > *""'"); + } + arg1 = (CvTuple< float,3 > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvTuple_float_3___brace_asgn" "', 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 '" "CvTuple_float_3___brace_asgn" "', argument " "3"" of type '" "float *""'"); + } + arg3 = (float *)(argp3); + { + try { + (arg1)->__brace_asgn(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_CvTuple_float_3 (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTuple< float,3 > *result = 0 ; + + if (!SWIG_check_num_args("new_CvTuple_float_3",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTuple< float,3 > *)new CvTuple< float,3 >(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_3_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvTuple_float_3 (const octave_value_list& args, int nargout) { + CvTuple< float,3 > *arg1 = (CvTuple< float,3 > *) 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_CvTuple_float_3",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTupleT_float_3_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvTuple_float_3" "', argument " "1"" of type '" "CvTuple< float,3 > *""'"); + } + arg1 = (CvTuple< float,3 > *)(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_CvTuple_float_3_members[] = { +{"val",0,_wrap_CvTuple_float_3_val_get,_wrap_CvTuple_float_3_val_set,0,0}, +{"__paren",_wrap_CvTuple_float_3___paren,0,0,0,0}, +{"__paren_asgn",_wrap_CvTuple_float_3___paren_asgn,0,0,0,0}, +{"__brace",_wrap_CvTuple_float_3___brace,0,0,0,0}, +{"__brace_asgn",_wrap_CvTuple_float_3___brace_asgn,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvTuple_float_3_base_names[] = {0}; +static const swig_type_info *swig_CvTuple_float_3_base[] = {0}; +static swig_octave_class _wrap_class_CvTuple_float_3 = {"CvTuple_float_3", &SWIGTYPE_p_CvTupleT_float_3_t,0,_wrap_new_CvTuple_float_3,0,_wrap_delete_CvTuple_float_3,swig_CvTuple_float_3_members,swig_CvTuple_float_3_base_names,swig_CvTuple_float_3_base }; + +static octave_value_list _wrap_CvSeq_CvPoint_cast (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvPoint > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvPoint_cast",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + try { + result = (CvTypedSeq< CvPoint > *)CvTypedSeq< CvPoint >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvPoint___paren (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint > *arg1 = (CvTypedSeq< CvPoint > *) 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; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvPoint___paren",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint___paren" "', argument " "1"" of type '" "CvTypedSeq< CvPoint > *""'"); + } + arg1 = (CvTypedSeq< CvPoint > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint___paren" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvPoint *)(arg1)->__paren(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvPoint___paren_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint > *arg1 = (CvTypedSeq< CvPoint > *) 0 ; + int arg2 ; + CvPoint *arg3 = (CvPoint *) 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; + + if (!SWIG_check_num_args("CvSeq_CvPoint___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint___paren_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvPoint > *""'"); + } + arg1 = (CvTypedSeq< CvPoint > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint___paren_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvPoint___paren_asgn" "', argument " "3"" of type '" "CvPoint *""'"); + } + arg3 = (CvPoint *)(argp3); + { + try { + (arg1)->__paren_asgn(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_CvSeq_CvPoint___brace (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint > *arg1 = (CvTypedSeq< CvPoint > *) 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; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvPoint___brace",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint___brace" "', argument " "1"" of type '" "CvTypedSeq< CvPoint > *""'"); + } + arg1 = (CvTypedSeq< CvPoint > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint___brace" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvPoint *)(arg1)->__brace(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvPoint___brace_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint > *arg1 = (CvTypedSeq< CvPoint > *) 0 ; + int arg2 ; + CvPoint *arg3 = (CvPoint *) 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; + + if (!SWIG_check_num_args("CvSeq_CvPoint___brace_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint___brace_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvPoint > *""'"); + } + arg1 = (CvTypedSeq< CvPoint > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint___brace_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvPoint___brace_asgn" "', argument " "3"" of type '" "CvPoint *""'"); + } + arg3 = (CvPoint *)(argp3); + { + try { + (arg1)->__brace_asgn(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_CvSeq_CvPoint_append (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint > *arg1 = (CvTypedSeq< CvPoint > *) 0 ; + CvPoint *arg2 = (CvPoint *) 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("CvSeq_CvPoint_append",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_append" "', argument " "1"" of type '" "CvTypedSeq< CvPoint > *""'"); + } + arg1 = (CvTypedSeq< CvPoint > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_CvPoint_append" "', argument " "2"" of type '" "CvPoint *""'"); + } + arg2 = (CvPoint *)(argp2); + { + try { + (arg1)->append(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_CvSeq_CvPoint_pop (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint > *arg1 = (CvTypedSeq< CvPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvPoint_pop",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_pop" "', argument " "1"" of type '" "CvTypedSeq< CvPoint > *""'"); + } + arg1 = (CvTypedSeq< CvPoint > *)(argp1); + { + try { + result = (CvPoint *)(arg1)->pop(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSeq_CvPoint (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvPoint > *result = 0 ; + + if (!SWIG_check_num_args("new_CvSeq_CvPoint",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTypedSeq< CvPoint > *)new CvTypedSeq< CvPoint >(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvPoint_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSeq_CvPoint (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint > *arg1 = (CvTypedSeq< CvPoint > *) 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_CvSeq_CvPoint",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvPoint" "', argument " "1"" of type '" "CvTypedSeq< CvPoint > *""'"); + } + arg1 = (CvTypedSeq< CvPoint > *)(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_CvSeq_CvPoint_members[] = { +{"cast",_wrap_CvSeq_CvPoint_cast,0,0,1,0}, +{"__paren",_wrap_CvSeq_CvPoint___paren,0,0,0,0}, +{"__paren_asgn",_wrap_CvSeq_CvPoint___paren_asgn,0,0,0,0}, +{"__brace",_wrap_CvSeq_CvPoint___brace,0,0,0,0}, +{"__brace_asgn",_wrap_CvSeq_CvPoint___brace_asgn,0,0,0,0}, +{"append",_wrap_CvSeq_CvPoint_append,0,0,0,0}, +{"pop",_wrap_CvSeq_CvPoint_pop,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSeq_CvPoint_base_names[] = {"_p_CvSeq",0}; +static const swig_type_info *swig_CvSeq_CvPoint_base[] = {0,0}; +static swig_octave_class _wrap_class_CvSeq_CvPoint = {"CvSeq_CvPoint", &SWIGTYPE_p_CvTypedSeqT_CvPoint_t,0,_wrap_new_CvSeq_CvPoint,0,_wrap_delete_CvSeq_CvPoint,swig_CvSeq_CvPoint_members,swig_CvSeq_CvPoint_base_names,swig_CvSeq_CvPoint_base }; + +static octave_value_list _wrap_CvSeq_CvPoint2D32f_cast (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvPoint2D32f > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvPoint2D32f_cast",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + try { + result = (CvTypedSeq< CvPoint2D32f > *)CvTypedSeq< CvPoint2D32f >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvPoint2D32f___paren (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint2D32f > *arg1 = (CvTypedSeq< CvPoint2D32f > *) 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; + CvPoint2D32f *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvPoint2D32f___paren",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint2D32f___paren" "', argument " "1"" of type '" "CvTypedSeq< CvPoint2D32f > *""'"); + } + arg1 = (CvTypedSeq< CvPoint2D32f > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint2D32f___paren" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvPoint2D32f *)(arg1)->__paren(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvPoint2D32f___paren_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint2D32f > *arg1 = (CvTypedSeq< CvPoint2D32f > *) 0 ; + int arg2 ; + CvPoint2D32f *arg3 = (CvPoint2D32f *) 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; + + if (!SWIG_check_num_args("CvSeq_CvPoint2D32f___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint2D32f___paren_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvPoint2D32f > *""'"); + } + arg1 = (CvTypedSeq< CvPoint2D32f > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint2D32f___paren_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvPoint2D32f___paren_asgn" "', argument " "3"" of type '" "CvPoint2D32f *""'"); + } + arg3 = (CvPoint2D32f *)(argp3); + { + try { + (arg1)->__paren_asgn(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_CvSeq_CvPoint2D32f___brace (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint2D32f > *arg1 = (CvTypedSeq< CvPoint2D32f > *) 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; + CvPoint2D32f *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvPoint2D32f___brace",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint2D32f___brace" "', argument " "1"" of type '" "CvTypedSeq< CvPoint2D32f > *""'"); + } + arg1 = (CvTypedSeq< CvPoint2D32f > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint2D32f___brace" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvPoint2D32f *)(arg1)->__brace(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvPoint2D32f___brace_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint2D32f > *arg1 = (CvTypedSeq< CvPoint2D32f > *) 0 ; + int arg2 ; + CvPoint2D32f *arg3 = (CvPoint2D32f *) 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; + + if (!SWIG_check_num_args("CvSeq_CvPoint2D32f___brace_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint2D32f___brace_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvPoint2D32f > *""'"); + } + arg1 = (CvTypedSeq< CvPoint2D32f > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint2D32f___brace_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvPoint2D32f___brace_asgn" "', argument " "3"" of type '" "CvPoint2D32f *""'"); + } + arg3 = (CvPoint2D32f *)(argp3); + { + try { + (arg1)->__brace_asgn(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_CvSeq_CvPoint2D32f_append (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint2D32f > *arg1 = (CvTypedSeq< CvPoint2D32f > *) 0 ; + CvPoint2D32f *arg2 = (CvPoint2D32f *) 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("CvSeq_CvPoint2D32f_append",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint2D32f_append" "', argument " "1"" of type '" "CvTypedSeq< CvPoint2D32f > *""'"); + } + arg1 = (CvTypedSeq< CvPoint2D32f > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_CvPoint2D32f_append" "', argument " "2"" of type '" "CvPoint2D32f *""'"); + } + arg2 = (CvPoint2D32f *)(argp2); + { + try { + (arg1)->append(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_CvSeq_CvPoint2D32f_pop (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint2D32f > *arg1 = (CvTypedSeq< CvPoint2D32f > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvPoint2D32f *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvPoint2D32f_pop",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint2D32f_pop" "', argument " "1"" of type '" "CvTypedSeq< CvPoint2D32f > *""'"); + } + arg1 = (CvTypedSeq< CvPoint2D32f > *)(argp1); + { + try { + result = (CvPoint2D32f *)(arg1)->pop(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvPoint2D32f, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSeq_CvPoint2D32f (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvPoint2D32f > *result = 0 ; + + if (!SWIG_check_num_args("new_CvSeq_CvPoint2D32f",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTypedSeq< CvPoint2D32f > *)new CvTypedSeq< CvPoint2D32f >(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSeq_CvPoint2D32f (const octave_value_list& args, int nargout) { + CvTypedSeq< CvPoint2D32f > *arg1 = (CvTypedSeq< CvPoint2D32f > *) 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_CvSeq_CvPoint2D32f",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvPoint2D32f" "', argument " "1"" of type '" "CvTypedSeq< CvPoint2D32f > *""'"); + } + arg1 = (CvTypedSeq< CvPoint2D32f > *)(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_CvSeq_CvPoint2D32f_members[] = { +{"cast",_wrap_CvSeq_CvPoint2D32f_cast,0,0,1,0}, +{"__paren",_wrap_CvSeq_CvPoint2D32f___paren,0,0,0,0}, +{"__paren_asgn",_wrap_CvSeq_CvPoint2D32f___paren_asgn,0,0,0,0}, +{"__brace",_wrap_CvSeq_CvPoint2D32f___brace,0,0,0,0}, +{"__brace_asgn",_wrap_CvSeq_CvPoint2D32f___brace_asgn,0,0,0,0}, +{"append",_wrap_CvSeq_CvPoint2D32f_append,0,0,0,0}, +{"pop",_wrap_CvSeq_CvPoint2D32f_pop,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSeq_CvPoint2D32f_base_names[] = {"_p_CvSeq",0}; +static const swig_type_info *swig_CvSeq_CvPoint2D32f_base[] = {0,0}; +static swig_octave_class _wrap_class_CvSeq_CvPoint2D32f = {"CvSeq_CvPoint2D32f", &SWIGTYPE_p_CvTypedSeqT_CvPoint2D32f_t,0,_wrap_new_CvSeq_CvPoint2D32f,0,_wrap_delete_CvSeq_CvPoint2D32f,swig_CvSeq_CvPoint2D32f_members,swig_CvSeq_CvPoint2D32f_base_names,swig_CvSeq_CvPoint2D32f_base }; + +static octave_value_list _wrap_CvSeq_CvRect_cast (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvRect > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvRect_cast",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + try { + result = (CvTypedSeq< CvRect > *)CvTypedSeq< CvRect >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvRect___paren (const octave_value_list& args, int nargout) { + CvTypedSeq< CvRect > *arg1 = (CvTypedSeq< CvRect > *) 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; + CvRect *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvRect___paren",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvRect___paren" "', argument " "1"" of type '" "CvTypedSeq< CvRect > *""'"); + } + arg1 = (CvTypedSeq< CvRect > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvRect___paren" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvRect *)(arg1)->__paren(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvRect___paren_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvRect > *arg1 = (CvTypedSeq< CvRect > *) 0 ; + int arg2 ; + CvRect *arg3 = (CvRect *) 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; + + if (!SWIG_check_num_args("CvSeq_CvRect___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvRect___paren_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvRect > *""'"); + } + arg1 = (CvTypedSeq< CvRect > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvRect___paren_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvRect___paren_asgn" "', argument " "3"" of type '" "CvRect *""'"); + } + arg3 = (CvRect *)(argp3); + { + try { + (arg1)->__paren_asgn(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_CvSeq_CvRect___brace (const octave_value_list& args, int nargout) { + CvTypedSeq< CvRect > *arg1 = (CvTypedSeq< CvRect > *) 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; + CvRect *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvRect___brace",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvRect___brace" "', argument " "1"" of type '" "CvTypedSeq< CvRect > *""'"); + } + arg1 = (CvTypedSeq< CvRect > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvRect___brace" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvRect *)(arg1)->__brace(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvRect___brace_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvRect > *arg1 = (CvTypedSeq< CvRect > *) 0 ; + int arg2 ; + CvRect *arg3 = (CvRect *) 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; + + if (!SWIG_check_num_args("CvSeq_CvRect___brace_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvRect___brace_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvRect > *""'"); + } + arg1 = (CvTypedSeq< CvRect > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvRect___brace_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvRect___brace_asgn" "', argument " "3"" of type '" "CvRect *""'"); + } + arg3 = (CvRect *)(argp3); + { + try { + (arg1)->__brace_asgn(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_CvSeq_CvRect_append (const octave_value_list& args, int nargout) { + CvTypedSeq< CvRect > *arg1 = (CvTypedSeq< CvRect > *) 0 ; + CvRect *arg2 = (CvRect *) 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("CvSeq_CvRect_append",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvRect_append" "', argument " "1"" of type '" "CvTypedSeq< CvRect > *""'"); + } + arg1 = (CvTypedSeq< CvRect > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvRect, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_CvRect_append" "', argument " "2"" of type '" "CvRect *""'"); + } + arg2 = (CvRect *)(argp2); + { + try { + (arg1)->append(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_CvSeq_CvRect_pop (const octave_value_list& args, int nargout) { + CvTypedSeq< CvRect > *arg1 = (CvTypedSeq< CvRect > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvRect *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvRect_pop",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvRect_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvRect_pop" "', argument " "1"" of type '" "CvTypedSeq< CvRect > *""'"); + } + arg1 = (CvTypedSeq< CvRect > *)(argp1); + { + try { + result = (CvRect *)(arg1)->pop(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvRect, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSeq_CvRect (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvRect > *result = 0 ; + + if (!SWIG_check_num_args("new_CvSeq_CvRect",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTypedSeq< CvRect > *)new CvTypedSeq< CvRect >(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvRect_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSeq_CvRect (const octave_value_list& args, int nargout) { + CvTypedSeq< CvRect > *arg1 = (CvTypedSeq< CvRect > *) 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_CvSeq_CvRect",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvRect_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvRect" "', argument " "1"" of type '" "CvTypedSeq< CvRect > *""'"); + } + arg1 = (CvTypedSeq< CvRect > *)(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_CvSeq_CvRect_members[] = { +{"cast",_wrap_CvSeq_CvRect_cast,0,0,1,0}, +{"__paren",_wrap_CvSeq_CvRect___paren,0,0,0,0}, +{"__paren_asgn",_wrap_CvSeq_CvRect___paren_asgn,0,0,0,0}, +{"__brace",_wrap_CvSeq_CvRect___brace,0,0,0,0}, +{"__brace_asgn",_wrap_CvSeq_CvRect___brace_asgn,0,0,0,0}, +{"append",_wrap_CvSeq_CvRect_append,0,0,0,0}, +{"pop",_wrap_CvSeq_CvRect_pop,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSeq_CvRect_base_names[] = {"_p_CvSeq",0}; +static const swig_type_info *swig_CvSeq_CvRect_base[] = {0,0}; +static swig_octave_class _wrap_class_CvSeq_CvRect = {"CvSeq_CvRect", &SWIGTYPE_p_CvTypedSeqT_CvRect_t,0,_wrap_new_CvSeq_CvRect,0,_wrap_delete_CvSeq_CvRect,swig_CvSeq_CvRect_members,swig_CvSeq_CvRect_base_names,swig_CvSeq_CvRect_base }; + +static octave_value_list _wrap_CvSeq_CvSeq_cast (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvSeq * > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvSeq_cast",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + try { + result = (CvTypedSeq< CvSeq * > *)CvTypedSeq< CvSeq * >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvSeq___paren (const octave_value_list& args, int nargout) { + CvTypedSeq< CvSeq * > *arg1 = (CvTypedSeq< CvSeq * > *) 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; + CvSeq **result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvSeq___paren",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvSeq___paren" "', argument " "1"" of type '" "CvTypedSeq< CvSeq * > *""'"); + } + arg1 = (CvTypedSeq< CvSeq * > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvSeq___paren" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvSeq **)(arg1)->__paren(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvSeq, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvSeq___paren_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvSeq * > *arg1 = (CvTypedSeq< CvSeq * > *) 0 ; + int arg2 ; + CvSeq **arg3 = (CvSeq **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *vptr3 ; + CvSeq *buffer3 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_CvSeq___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvSeq___paren_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvSeq * > *""'"); + } + arg1 = (CvTypedSeq< CvSeq * > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvSeq___paren_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + if ((SWIG_ConvertPtr(args(2), &vptr3, SWIGTYPE_p_CvSeq, 1)) == -1){ + SWIG_fail; + } + buffer3 = (CvSeq *) vptr3; + arg3=&buffer3; + } + { + try { + (arg1)->__paren_asgn(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_CvSeq_CvSeq___brace (const octave_value_list& args, int nargout) { + CvTypedSeq< CvSeq * > *arg1 = (CvTypedSeq< CvSeq * > *) 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; + CvSeq **result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvSeq___brace",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvSeq___brace" "', argument " "1"" of type '" "CvTypedSeq< CvSeq * > *""'"); + } + arg1 = (CvTypedSeq< CvSeq * > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvSeq___brace" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvSeq **)(arg1)->__brace(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvSeq, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvSeq___brace_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvSeq * > *arg1 = (CvTypedSeq< CvSeq * > *) 0 ; + int arg2 ; + CvSeq **arg3 = (CvSeq **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *vptr3 ; + CvSeq *buffer3 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_CvSeq___brace_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvSeq___brace_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvSeq * > *""'"); + } + arg1 = (CvTypedSeq< CvSeq * > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvSeq___brace_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + if ((SWIG_ConvertPtr(args(2), &vptr3, SWIGTYPE_p_CvSeq, 1)) == -1){ + SWIG_fail; + } + buffer3 = (CvSeq *) vptr3; + arg3=&buffer3; + } + { + try { + (arg1)->__brace_asgn(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_CvSeq_CvSeq_append (const octave_value_list& args, int nargout) { + CvTypedSeq< CvSeq * > *arg1 = (CvTypedSeq< CvSeq * > *) 0 ; + CvSeq **arg2 = (CvSeq **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *vptr2 ; + CvSeq *buffer2 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + + if (!SWIG_check_num_args("CvSeq_CvSeq_append",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvSeq_append" "', argument " "1"" of type '" "CvTypedSeq< CvSeq * > *""'"); + } + arg1 = (CvTypedSeq< CvSeq * > *)(argp1); + { + if ((SWIG_ConvertPtr(args(1), &vptr2, SWIGTYPE_p_CvSeq, 1)) == -1){ + SWIG_fail; + } + buffer2 = (CvSeq *) vptr2; + arg2=&buffer2; + } + { + try { + (arg1)->append(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_CvSeq_CvSeq_pop (const octave_value_list& args, int nargout) { + CvTypedSeq< CvSeq * > *arg1 = (CvTypedSeq< CvSeq * > *) 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("CvSeq_CvSeq_pop",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvSeq_pop" "', argument " "1"" of type '" "CvTypedSeq< CvSeq * > *""'"); + } + arg1 = (CvTypedSeq< CvSeq * > *)(argp1); + { + try { + result = (CvSeq **)(arg1)->pop(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_CvSeq, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSeq_CvSeq (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvSeq * > *result = 0 ; + + if (!SWIG_check_num_args("new_CvSeq_CvSeq",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTypedSeq< CvSeq * > *)new CvTypedSeq< CvSeq * >(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSeq_CvSeq (const octave_value_list& args, int nargout) { + CvTypedSeq< CvSeq * > *arg1 = (CvTypedSeq< CvSeq * > *) 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_CvSeq_CvSeq",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvSeq" "', argument " "1"" of type '" "CvTypedSeq< CvSeq * > *""'"); + } + arg1 = (CvTypedSeq< CvSeq * > *)(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_CvSeq_CvSeq_members[] = { +{"cast",_wrap_CvSeq_CvSeq_cast,0,0,1,0}, +{"__paren",_wrap_CvSeq_CvSeq___paren,0,0,0,0}, +{"__paren_asgn",_wrap_CvSeq_CvSeq___paren_asgn,0,0,0,0}, +{"__brace",_wrap_CvSeq_CvSeq___brace,0,0,0,0}, +{"__brace_asgn",_wrap_CvSeq_CvSeq___brace_asgn,0,0,0,0}, +{"append",_wrap_CvSeq_CvSeq_append,0,0,0,0}, +{"pop",_wrap_CvSeq_CvSeq_pop,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSeq_CvSeq_base_names[] = {"_p_CvSeq",0}; +static const swig_type_info *swig_CvSeq_CvSeq_base[] = {0,0}; +static swig_octave_class _wrap_class_CvSeq_CvSeq = {"CvSeq_CvSeq", &SWIGTYPE_p_CvTypedSeqT_CvSeq_p_t,0,_wrap_new_CvSeq_CvSeq,0,_wrap_delete_CvSeq_CvSeq,swig_CvSeq_CvSeq_members,swig_CvSeq_CvSeq_base_names,swig_CvSeq_CvSeq_base }; + +static octave_value_list _wrap_CvSeq_CvQuadEdge2D_cast (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvQuadEdge2D > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvQuadEdge2D_cast",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + try { + result = (CvTypedSeq< CvQuadEdge2D > *)CvTypedSeq< CvQuadEdge2D >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvQuadEdge2D___paren (const octave_value_list& args, int nargout) { + CvTypedSeq< CvQuadEdge2D > *arg1 = (CvTypedSeq< CvQuadEdge2D > *) 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; + CvQuadEdge2D *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvQuadEdge2D___paren",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvQuadEdge2D___paren" "', argument " "1"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'"); + } + arg1 = (CvTypedSeq< CvQuadEdge2D > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvQuadEdge2D___paren" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvQuadEdge2D *)(arg1)->__paren(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvQuadEdge2D, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvQuadEdge2D___paren_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvQuadEdge2D > *arg1 = (CvTypedSeq< CvQuadEdge2D > *) 0 ; + int arg2 ; + CvQuadEdge2D *arg3 = (CvQuadEdge2D *) 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; + + if (!SWIG_check_num_args("CvSeq_CvQuadEdge2D___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvQuadEdge2D___paren_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'"); + } + arg1 = (CvTypedSeq< CvQuadEdge2D > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvQuadEdge2D___paren_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvQuadEdge2D___paren_asgn" "', argument " "3"" of type '" "CvQuadEdge2D *""'"); + } + arg3 = (CvQuadEdge2D *)(argp3); + { + try { + (arg1)->__paren_asgn(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_CvSeq_CvQuadEdge2D___brace (const octave_value_list& args, int nargout) { + CvTypedSeq< CvQuadEdge2D > *arg1 = (CvTypedSeq< CvQuadEdge2D > *) 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; + CvQuadEdge2D *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvQuadEdge2D___brace",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvQuadEdge2D___brace" "', argument " "1"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'"); + } + arg1 = (CvTypedSeq< CvQuadEdge2D > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvQuadEdge2D___brace" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvQuadEdge2D *)(arg1)->__brace(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvQuadEdge2D, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvQuadEdge2D___brace_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvQuadEdge2D > *arg1 = (CvTypedSeq< CvQuadEdge2D > *) 0 ; + int arg2 ; + CvQuadEdge2D *arg3 = (CvQuadEdge2D *) 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; + + if (!SWIG_check_num_args("CvSeq_CvQuadEdge2D___brace_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvQuadEdge2D___brace_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'"); + } + arg1 = (CvTypedSeq< CvQuadEdge2D > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvQuadEdge2D___brace_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvQuadEdge2D___brace_asgn" "', argument " "3"" of type '" "CvQuadEdge2D *""'"); + } + arg3 = (CvQuadEdge2D *)(argp3); + { + try { + (arg1)->__brace_asgn(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_CvSeq_CvQuadEdge2D_append (const octave_value_list& args, int nargout) { + CvTypedSeq< CvQuadEdge2D > *arg1 = (CvTypedSeq< CvQuadEdge2D > *) 0 ; + CvQuadEdge2D *arg2 = (CvQuadEdge2D *) 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("CvSeq_CvQuadEdge2D_append",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvQuadEdge2D_append" "', argument " "1"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'"); + } + arg1 = (CvTypedSeq< CvQuadEdge2D > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvQuadEdge2D, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_CvQuadEdge2D_append" "', argument " "2"" of type '" "CvQuadEdge2D *""'"); + } + arg2 = (CvQuadEdge2D *)(argp2); + { + try { + (arg1)->append(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_CvSeq_CvQuadEdge2D_pop (const octave_value_list& args, int nargout) { + CvTypedSeq< CvQuadEdge2D > *arg1 = (CvTypedSeq< CvQuadEdge2D > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvQuadEdge2D *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvQuadEdge2D_pop",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvQuadEdge2D_pop" "', argument " "1"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'"); + } + arg1 = (CvTypedSeq< CvQuadEdge2D > *)(argp1); + { + try { + result = (CvQuadEdge2D *)(arg1)->pop(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvQuadEdge2D, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSeq_CvQuadEdge2D (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvQuadEdge2D > *result = 0 ; + + if (!SWIG_check_num_args("new_CvSeq_CvQuadEdge2D",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTypedSeq< CvQuadEdge2D > *)new CvTypedSeq< CvQuadEdge2D >(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSeq_CvQuadEdge2D (const octave_value_list& args, int nargout) { + CvTypedSeq< CvQuadEdge2D > *arg1 = (CvTypedSeq< CvQuadEdge2D > *) 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_CvSeq_CvQuadEdge2D",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvQuadEdge2D" "', argument " "1"" of type '" "CvTypedSeq< CvQuadEdge2D > *""'"); + } + arg1 = (CvTypedSeq< CvQuadEdge2D > *)(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_CvSeq_CvQuadEdge2D_members[] = { +{"cast",_wrap_CvSeq_CvQuadEdge2D_cast,0,0,1,0}, +{"__paren",_wrap_CvSeq_CvQuadEdge2D___paren,0,0,0,0}, +{"__paren_asgn",_wrap_CvSeq_CvQuadEdge2D___paren_asgn,0,0,0,0}, +{"__brace",_wrap_CvSeq_CvQuadEdge2D___brace,0,0,0,0}, +{"__brace_asgn",_wrap_CvSeq_CvQuadEdge2D___brace_asgn,0,0,0,0}, +{"append",_wrap_CvSeq_CvQuadEdge2D_append,0,0,0,0}, +{"pop",_wrap_CvSeq_CvQuadEdge2D_pop,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSeq_CvQuadEdge2D_base_names[] = {"_p_CvSeq",0}; +static const swig_type_info *swig_CvSeq_CvQuadEdge2D_base[] = {0,0}; +static swig_octave_class _wrap_class_CvSeq_CvQuadEdge2D = {"CvSeq_CvQuadEdge2D", &SWIGTYPE_p_CvTypedSeqT_CvQuadEdge2D_t,0,_wrap_new_CvSeq_CvQuadEdge2D,0,_wrap_delete_CvSeq_CvQuadEdge2D,swig_CvSeq_CvQuadEdge2D_members,swig_CvSeq_CvQuadEdge2D_base_names,swig_CvSeq_CvQuadEdge2D_base }; + +static octave_value_list _wrap_CvSeq_CvConnectedComp_cast (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvConnectedComp > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvConnectedComp_cast",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + try { + result = (CvTypedSeq< CvConnectedComp > *)CvTypedSeq< CvConnectedComp >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvConnectedComp___paren (const octave_value_list& args, int nargout) { + CvTypedSeq< CvConnectedComp > *arg1 = (CvTypedSeq< CvConnectedComp > *) 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; + CvConnectedComp *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvConnectedComp___paren",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvConnectedComp___paren" "', argument " "1"" of type '" "CvTypedSeq< CvConnectedComp > *""'"); + } + arg1 = (CvTypedSeq< CvConnectedComp > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvConnectedComp___paren" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvConnectedComp *)(arg1)->__paren(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvConnectedComp___paren_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvConnectedComp > *arg1 = (CvTypedSeq< CvConnectedComp > *) 0 ; + int arg2 ; + CvConnectedComp *arg3 = (CvConnectedComp *) 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; + + if (!SWIG_check_num_args("CvSeq_CvConnectedComp___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvConnectedComp___paren_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvConnectedComp > *""'"); + } + arg1 = (CvTypedSeq< CvConnectedComp > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvConnectedComp___paren_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvConnectedComp___paren_asgn" "', argument " "3"" of type '" "CvConnectedComp *""'"); + } + arg3 = (CvConnectedComp *)(argp3); + { + try { + (arg1)->__paren_asgn(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_CvSeq_CvConnectedComp___brace (const octave_value_list& args, int nargout) { + CvTypedSeq< CvConnectedComp > *arg1 = (CvTypedSeq< CvConnectedComp > *) 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; + CvConnectedComp *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvConnectedComp___brace",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvConnectedComp___brace" "', argument " "1"" of type '" "CvTypedSeq< CvConnectedComp > *""'"); + } + arg1 = (CvTypedSeq< CvConnectedComp > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvConnectedComp___brace" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvConnectedComp *)(arg1)->__brace(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvConnectedComp___brace_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvConnectedComp > *arg1 = (CvTypedSeq< CvConnectedComp > *) 0 ; + int arg2 ; + CvConnectedComp *arg3 = (CvConnectedComp *) 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; + + if (!SWIG_check_num_args("CvSeq_CvConnectedComp___brace_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvConnectedComp___brace_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvConnectedComp > *""'"); + } + arg1 = (CvTypedSeq< CvConnectedComp > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvConnectedComp___brace_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvConnectedComp___brace_asgn" "', argument " "3"" of type '" "CvConnectedComp *""'"); + } + arg3 = (CvConnectedComp *)(argp3); + { + try { + (arg1)->__brace_asgn(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_CvSeq_CvConnectedComp_append (const octave_value_list& args, int nargout) { + CvTypedSeq< CvConnectedComp > *arg1 = (CvTypedSeq< CvConnectedComp > *) 0 ; + CvConnectedComp *arg2 = (CvConnectedComp *) 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("CvSeq_CvConnectedComp_append",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvConnectedComp_append" "', argument " "1"" of type '" "CvTypedSeq< CvConnectedComp > *""'"); + } + arg1 = (CvTypedSeq< CvConnectedComp > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_CvConnectedComp_append" "', argument " "2"" of type '" "CvConnectedComp *""'"); + } + arg2 = (CvConnectedComp *)(argp2); + { + try { + (arg1)->append(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_CvSeq_CvConnectedComp_pop (const octave_value_list& args, int nargout) { + CvTypedSeq< CvConnectedComp > *arg1 = (CvTypedSeq< CvConnectedComp > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvConnectedComp *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvConnectedComp_pop",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvConnectedComp_pop" "', argument " "1"" of type '" "CvTypedSeq< CvConnectedComp > *""'"); + } + arg1 = (CvTypedSeq< CvConnectedComp > *)(argp1); + { + try { + result = (CvConnectedComp *)(arg1)->pop(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvConnectedComp, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSeq_CvConnectedComp (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvConnectedComp > *result = 0 ; + + if (!SWIG_check_num_args("new_CvSeq_CvConnectedComp",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTypedSeq< CvConnectedComp > *)new CvTypedSeq< CvConnectedComp >(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSeq_CvConnectedComp (const octave_value_list& args, int nargout) { + CvTypedSeq< CvConnectedComp > *arg1 = (CvTypedSeq< CvConnectedComp > *) 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_CvSeq_CvConnectedComp",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvConnectedComp" "', argument " "1"" of type '" "CvTypedSeq< CvConnectedComp > *""'"); + } + arg1 = (CvTypedSeq< CvConnectedComp > *)(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_CvSeq_CvConnectedComp_members[] = { +{"cast",_wrap_CvSeq_CvConnectedComp_cast,0,0,1,0}, +{"__paren",_wrap_CvSeq_CvConnectedComp___paren,0,0,0,0}, +{"__paren_asgn",_wrap_CvSeq_CvConnectedComp___paren_asgn,0,0,0,0}, +{"__brace",_wrap_CvSeq_CvConnectedComp___brace,0,0,0,0}, +{"__brace_asgn",_wrap_CvSeq_CvConnectedComp___brace_asgn,0,0,0,0}, +{"append",_wrap_CvSeq_CvConnectedComp_append,0,0,0,0}, +{"pop",_wrap_CvSeq_CvConnectedComp_pop,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSeq_CvConnectedComp_base_names[] = {"_p_CvSeq",0}; +static const swig_type_info *swig_CvSeq_CvConnectedComp_base[] = {0,0}; +static swig_octave_class _wrap_class_CvSeq_CvConnectedComp = {"CvSeq_CvConnectedComp", &SWIGTYPE_p_CvTypedSeqT_CvConnectedComp_t,0,_wrap_new_CvSeq_CvConnectedComp,0,_wrap_delete_CvSeq_CvConnectedComp,swig_CvSeq_CvConnectedComp_members,swig_CvSeq_CvConnectedComp_base_names,swig_CvSeq_CvConnectedComp_base }; + +static octave_value_list _wrap_CvSeq_CvPoint_2_cast (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvTuple< CvPoint,2 > > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvPoint_2_cast",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + try { + result = (CvTypedSeq< CvTuple< CvPoint,2 > > *)CvTypedSeq< CvTuple< CvPoint,2 > >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvPoint_2___paren (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< CvPoint,2 > > *arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *) 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; + CvTuple< CvPoint,2 > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvPoint_2___paren",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_2___paren" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< CvPoint,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint_2___paren" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvTuple< CvPoint,2 > *)(arg1)->__paren(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvPoint_2___paren_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< CvPoint,2 > > *arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *) 0 ; + int arg2 ; + CvTuple< CvPoint,2 > *arg3 = (CvTuple< CvPoint,2 > *) 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; + + if (!SWIG_check_num_args("CvSeq_CvPoint_2___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_2___paren_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< CvPoint,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint_2___paren_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvPoint_2___paren_asgn" "', argument " "3"" of type '" "CvTuple< CvPoint,2 > *""'"); + } + arg3 = (CvTuple< CvPoint,2 > *)(argp3); + { + try { + (arg1)->__paren_asgn(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_CvSeq_CvPoint_2___brace (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< CvPoint,2 > > *arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *) 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; + CvTuple< CvPoint,2 > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvPoint_2___brace",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_2___brace" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< CvPoint,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint_2___brace" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvTuple< CvPoint,2 > *)(arg1)->__brace(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_CvPoint_2___brace_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< CvPoint,2 > > *arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *) 0 ; + int arg2 ; + CvTuple< CvPoint,2 > *arg3 = (CvTuple< CvPoint,2 > *) 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; + + if (!SWIG_check_num_args("CvSeq_CvPoint_2___brace_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_2___brace_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< CvPoint,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_CvPoint_2___brace_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_CvPoint_2___brace_asgn" "', argument " "3"" of type '" "CvTuple< CvPoint,2 > *""'"); + } + arg3 = (CvTuple< CvPoint,2 > *)(argp3); + { + try { + (arg1)->__brace_asgn(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_CvSeq_CvPoint_2_append (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< CvPoint,2 > > *arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *) 0 ; + CvTuple< CvPoint,2 > *arg2 = (CvTuple< CvPoint,2 > *) 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("CvSeq_CvPoint_2_append",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_2_append" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< CvPoint,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_CvPoint_2_append" "', argument " "2"" of type '" "CvTuple< CvPoint,2 > *""'"); + } + arg2 = (CvTuple< CvPoint,2 > *)(argp2); + { + try { + (arg1)->append(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_CvSeq_CvPoint_2_pop (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< CvPoint,2 > > *arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTuple< CvPoint,2 > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_CvPoint_2_pop",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_CvPoint_2_pop" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< CvPoint,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *)(argp1); + { + try { + result = (CvTuple< CvPoint,2 > *)(arg1)->pop(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_CvPoint_2_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSeq_CvPoint_2 (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvTuple< CvPoint,2 > > *result = 0 ; + + if (!SWIG_check_num_args("new_CvSeq_CvPoint_2",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTypedSeq< CvTuple< CvPoint,2 > > *)new CvTypedSeq< CvTuple< CvPoint,2 > >(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSeq_CvPoint_2 (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< CvPoint,2 > > *arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *) 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_CvSeq_CvPoint_2",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_CvPoint_2" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< CvPoint,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< CvPoint,2 > > *)(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_CvSeq_CvPoint_2_members[] = { +{"cast",_wrap_CvSeq_CvPoint_2_cast,0,0,1,0}, +{"__paren",_wrap_CvSeq_CvPoint_2___paren,0,0,0,0}, +{"__paren_asgn",_wrap_CvSeq_CvPoint_2___paren_asgn,0,0,0,0}, +{"__brace",_wrap_CvSeq_CvPoint_2___brace,0,0,0,0}, +{"__brace_asgn",_wrap_CvSeq_CvPoint_2___brace_asgn,0,0,0,0}, +{"append",_wrap_CvSeq_CvPoint_2_append,0,0,0,0}, +{"pop",_wrap_CvSeq_CvPoint_2_pop,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSeq_CvPoint_2_base_names[] = {"_p_CvSeq",0}; +static const swig_type_info *swig_CvSeq_CvPoint_2_base[] = {0,0}; +static swig_octave_class _wrap_class_CvSeq_CvPoint_2 = {"CvSeq_CvPoint_2", &SWIGTYPE_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t,0,_wrap_new_CvSeq_CvPoint_2,0,_wrap_delete_CvSeq_CvPoint_2,swig_CvSeq_CvPoint_2_members,swig_CvSeq_CvPoint_2_base_names,swig_CvSeq_CvPoint_2_base }; + +static octave_value_list _wrap_CvSeq_float_2_cast (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvTuple< float,2 > > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_float_2_cast",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + try { + result = (CvTypedSeq< CvTuple< float,2 > > *)CvTypedSeq< CvTuple< float,2 > >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_float_2___paren (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,2 > > *arg1 = (CvTypedSeq< CvTuple< float,2 > > *) 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; + CvTuple< float,2 > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_float_2___paren",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_2___paren" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,2 > > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_float_2___paren" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvTuple< float,2 > *)(arg1)->__paren(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_float_2___paren_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,2 > > *arg1 = (CvTypedSeq< CvTuple< float,2 > > *) 0 ; + int arg2 ; + CvTuple< float,2 > *arg3 = (CvTuple< float,2 > *) 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; + + if (!SWIG_check_num_args("CvSeq_float_2___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_2___paren_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,2 > > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_float_2___paren_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_float_2___paren_asgn" "', argument " "3"" of type '" "CvTuple< float,2 > *""'"); + } + arg3 = (CvTuple< float,2 > *)(argp3); + { + try { + (arg1)->__paren_asgn(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_CvSeq_float_2___brace (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,2 > > *arg1 = (CvTypedSeq< CvTuple< float,2 > > *) 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; + CvTuple< float,2 > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_float_2___brace",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_2___brace" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,2 > > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_float_2___brace" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvTuple< float,2 > *)(arg1)->__brace(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_float_2___brace_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,2 > > *arg1 = (CvTypedSeq< CvTuple< float,2 > > *) 0 ; + int arg2 ; + CvTuple< float,2 > *arg3 = (CvTuple< float,2 > *) 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; + + if (!SWIG_check_num_args("CvSeq_float_2___brace_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_2___brace_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,2 > > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_float_2___brace_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_float_2___brace_asgn" "', argument " "3"" of type '" "CvTuple< float,2 > *""'"); + } + arg3 = (CvTuple< float,2 > *)(argp3); + { + try { + (arg1)->__brace_asgn(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_CvSeq_float_2_append (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,2 > > *arg1 = (CvTypedSeq< CvTuple< float,2 > > *) 0 ; + CvTuple< float,2 > *arg2 = (CvTuple< float,2 > *) 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("CvSeq_float_2_append",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_2_append" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,2 > > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_float_2_append" "', argument " "2"" of type '" "CvTuple< float,2 > *""'"); + } + arg2 = (CvTuple< float,2 > *)(argp2); + { + try { + (arg1)->append(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_CvSeq_float_2_pop (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,2 > > *arg1 = (CvTypedSeq< CvTuple< float,2 > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTuple< float,2 > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_float_2_pop",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_2_pop" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,2 > > *)(argp1); + { + try { + result = (CvTuple< float,2 > *)(arg1)->pop(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_2_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSeq_float_2 (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvTuple< float,2 > > *result = 0 ; + + if (!SWIG_check_num_args("new_CvSeq_float_2",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTypedSeq< CvTuple< float,2 > > *)new CvTypedSeq< CvTuple< float,2 > >(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSeq_float_2 (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,2 > > *arg1 = (CvTypedSeq< CvTuple< float,2 > > *) 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_CvSeq_float_2",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_float_2" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,2 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,2 > > *)(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_CvSeq_float_2_members[] = { +{"cast",_wrap_CvSeq_float_2_cast,0,0,1,0}, +{"__paren",_wrap_CvSeq_float_2___paren,0,0,0,0}, +{"__paren_asgn",_wrap_CvSeq_float_2___paren_asgn,0,0,0,0}, +{"__brace",_wrap_CvSeq_float_2___brace,0,0,0,0}, +{"__brace_asgn",_wrap_CvSeq_float_2___brace_asgn,0,0,0,0}, +{"append",_wrap_CvSeq_float_2_append,0,0,0,0}, +{"pop",_wrap_CvSeq_float_2_pop,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSeq_float_2_base_names[] = {"_p_CvSeq",0}; +static const swig_type_info *swig_CvSeq_float_2_base[] = {0,0}; +static swig_octave_class _wrap_class_CvSeq_float_2 = {"CvSeq_float_2", &SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_2_t_t,0,_wrap_new_CvSeq_float_2,0,_wrap_delete_CvSeq_float_2,swig_CvSeq_float_2_members,swig_CvSeq_float_2_base_names,swig_CvSeq_float_2_base }; + +static octave_value_list _wrap_CvSeq_float_3_cast (const octave_value_list& args, int nargout) { + CvSeq *arg1 = (CvSeq *) 0 ; + void *ptr1 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvTuple< float,3 > > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_float_3_cast",args.length(),1,1,0)) { + SWIG_fail; + } + { + if( SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSeq, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSet, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvGraph, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvSubdiv2D, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvChain, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContour, 0) == -1 && + SWIG_ConvertPtr(args(0), &ptr1, SWIGTYPE_p_CvContourTree, 0) == -1 ) + { + SWIG_exception (SWIG_TypeError, "could not convert to CvSeq"); + SWIG_fail; + } + arg1 = (CvSeq *) ptr1; + } + { + try { + result = (CvTypedSeq< CvTuple< float,3 > > *)CvTypedSeq< CvTuple< float,3 > >::SWIGTEMPLATEDISAMBIGUATOR cast(arg1); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_float_3___paren (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,3 > > *arg1 = (CvTypedSeq< CvTuple< float,3 > > *) 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; + CvTuple< float,3 > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_float_3___paren",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_3___paren" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,3 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,3 > > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_float_3___paren" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvTuple< float,3 > *)(arg1)->__paren(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_float_3___paren_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,3 > > *arg1 = (CvTypedSeq< CvTuple< float,3 > > *) 0 ; + int arg2 ; + CvTuple< float,3 > *arg3 = (CvTuple< float,3 > *) 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; + + if (!SWIG_check_num_args("CvSeq_float_3___paren_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_3___paren_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,3 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,3 > > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_float_3___paren_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_float_3___paren_asgn" "', argument " "3"" of type '" "CvTuple< float,3 > *""'"); + } + arg3 = (CvTuple< float,3 > *)(argp3); + { + try { + (arg1)->__paren_asgn(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_CvSeq_float_3___brace (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,3 > > *arg1 = (CvTypedSeq< CvTuple< float,3 > > *) 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; + CvTuple< float,3 > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_float_3___brace",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_3___brace" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,3 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,3 > > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_float_3___brace" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + { + try { + result = (CvTuple< float,3 > *)(arg1)->__brace(arg2); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_CvSeq_float_3___brace_asgn (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,3 > > *arg1 = (CvTypedSeq< CvTuple< float,3 > > *) 0 ; + int arg2 ; + CvTuple< float,3 > *arg3 = (CvTuple< float,3 > *) 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; + + if (!SWIG_check_num_args("CvSeq_float_3___brace_asgn",args.length(),3,3,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_3___brace_asgn" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,3 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,3 > > *)(argp1); + ecode2 = SWIG_AsVal_int(args(1), &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CvSeq_float_3___brace_asgn" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + res3 = SWIG_ConvertPtr(args(2), &argp3,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CvSeq_float_3___brace_asgn" "', argument " "3"" of type '" "CvTuple< float,3 > *""'"); + } + arg3 = (CvTuple< float,3 > *)(argp3); + { + try { + (arg1)->__brace_asgn(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_CvSeq_float_3_append (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,3 > > *arg1 = (CvTypedSeq< CvTuple< float,3 > > *) 0 ; + CvTuple< float,3 > *arg2 = (CvTuple< float,3 > *) 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("CvSeq_float_3_append",args.length(),2,2,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_3_append" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,3 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,3 > > *)(argp1); + res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CvSeq_float_3_append" "', argument " "2"" of type '" "CvTuple< float,3 > *""'"); + } + arg2 = (CvTuple< float,3 > *)(argp2); + { + try { + (arg1)->append(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_CvSeq_float_3_pop (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,3 > > *arg1 = (CvTypedSeq< CvTuple< float,3 > > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTuple< float,3 > *result = 0 ; + + if (!SWIG_check_num_args("CvSeq_float_3_pop",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CvSeq_float_3_pop" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,3 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,3 > > *)(argp1); + { + try { + result = (CvTuple< float,3 > *)(arg1)->pop(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTupleT_float_3_t, 0 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_new_CvSeq_float_3 (const octave_value_list& args, int nargout) { + octave_value_list _out; + octave_value_list *_outp=&_out; + octave_value _outv; + CvTypedSeq< CvTuple< float,3 > > *result = 0 ; + + if (!SWIG_check_num_args("new_CvSeq_float_3",args.length(),0,0,0)) { + SWIG_fail; + } + { + try { + result = (CvTypedSeq< CvTuple< float,3 > > *)new CvTypedSeq< CvTuple< float,3 > >(); + } + catch (...) + { + SWIG_fail; + } + } + _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, 1 | 0 ); + if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv); +fail: + return _out; +} + + +static octave_value_list _wrap_delete_CvSeq_float_3 (const octave_value_list& args, int nargout) { + CvTypedSeq< CvTuple< float,3 > > *arg1 = (CvTypedSeq< CvTuple< float,3 > > *) 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_CvSeq_float_3",args.length(),1,1,0)) { + SWIG_fail; + } + res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CvSeq_float_3" "', argument " "1"" of type '" "CvTypedSeq< CvTuple< float,3 > > *""'"); + } + arg1 = (CvTypedSeq< CvTuple< float,3 > > *)(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_CvSeq_float_3_members[] = { +{"cast",_wrap_CvSeq_float_3_cast,0,0,1,0}, +{"__paren",_wrap_CvSeq_float_3___paren,0,0,0,0}, +{"__paren_asgn",_wrap_CvSeq_float_3___paren_asgn,0,0,0,0}, +{"__brace",_wrap_CvSeq_float_3___brace,0,0,0,0}, +{"__brace_asgn",_wrap_CvSeq_float_3___brace_asgn,0,0,0,0}, +{"append",_wrap_CvSeq_float_3_append,0,0,0,0}, +{"pop",_wrap_CvSeq_float_3_pop,0,0,0,0}, +{0,0,0,0} +}; +static const char *swig_CvSeq_float_3_base_names[] = {"_p_CvSeq",0}; +static const swig_type_info *swig_CvSeq_float_3_base[] = {0,0}; +static swig_octave_class _wrap_class_CvSeq_float_3 = {"CvSeq_float_3", &SWIGTYPE_p_CvTypedSeqT_CvTupleT_float_3_t_t,0,_wrap_new_CvSeq_float_3,0,_wrap_delete_CvSeq_float_3,swig_CvSeq_float_3_members,swig_CvSeq_float_3_base_names,swig_CvSeq_float_3_base }; + + +static const struct swig_octave_member swig_globals[] = { +{"new_CvRNG_Wrapper",_wrap_new_CvRNG_Wrapper,0,0,2,_wrap_new_CvRNG_Wrapper_texinfo}, +{"CvRNG_Wrapper_ptr",_wrap_CvRNG_Wrapper_ptr,0,0,2,_wrap_CvRNG_Wrapper_ptr_texinfo}, +{"CvRNG_Wrapper_ref",_wrap_CvRNG_Wrapper_ref,0,0,2,_wrap_CvRNG_Wrapper_ref_texinfo}, +{"CvRNG_Wrapper___eq__",_wrap_CvRNG_Wrapper___eq__,0,0,2,_wrap_CvRNG_Wrapper___eq___texinfo}, +{"CvRNG_Wrapper___ne__",_wrap_CvRNG_Wrapper___ne__,0,0,2,_wrap_CvRNG_Wrapper___ne___texinfo}, +{"delete_CvRNG_Wrapper",_wrap_delete_CvRNG_Wrapper,0,0,2,_wrap_delete_CvRNG_Wrapper_texinfo}, +{"new_CvSubdiv2DEdge_Wrapper",_wrap_new_CvSubdiv2DEdge_Wrapper,0,0,2,_wrap_new_CvSubdiv2DEdge_Wrapper_texinfo}, +{"CvSubdiv2DEdge_Wrapper_ptr",_wrap_CvSubdiv2DEdge_Wrapper_ptr,0,0,2,_wrap_CvSubdiv2DEdge_Wrapper_ptr_texinfo}, +{"CvSubdiv2DEdge_Wrapper_ref",_wrap_CvSubdiv2DEdge_Wrapper_ref,0,0,2,_wrap_CvSubdiv2DEdge_Wrapper_ref_texinfo}, +{"CvSubdiv2DEdge_Wrapper___eq__",_wrap_CvSubdiv2DEdge_Wrapper___eq__,0,0,2,_wrap_CvSubdiv2DEdge_Wrapper___eq___texinfo}, +{"CvSubdiv2DEdge_Wrapper___ne__",_wrap_CvSubdiv2DEdge_Wrapper___ne__,0,0,2,_wrap_CvSubdiv2DEdge_Wrapper___ne___texinfo}, +{"delete_CvSubdiv2DEdge_Wrapper",_wrap_delete_CvSubdiv2DEdge_Wrapper,0,0,2,_wrap_delete_CvSubdiv2DEdge_Wrapper_texinfo}, +{"delete_OctSwigIterator",_wrap_delete_OctSwigIterator,0,0,2,_wrap_delete_OctSwigIterator_texinfo}, +{"OctSwigIterator_value",_wrap_OctSwigIterator_value,0,0,2,_wrap_OctSwigIterator_value_texinfo}, +{"OctSwigIterator_incr",_wrap_OctSwigIterator_incr,0,0,2,_wrap_OctSwigIterator_incr_texinfo}, +{"OctSwigIterator_decr",_wrap_OctSwigIterator_decr,0,0,2,_wrap_OctSwigIterator_decr_texinfo}, +{"OctSwigIterator_distance",_wrap_OctSwigIterator_distance,0,0,2,_wrap_OctSwigIterator_distance_texinfo}, +{"OctSwigIterator_equal",_wrap_OctSwigIterator_equal,0,0,2,_wrap_OctSwigIterator_equal_texinfo}, +{"OctSwigIterator_copy",_wrap_OctSwigIterator_copy,0,0,2,_wrap_OctSwigIterator_copy_texinfo}, +{"OctSwigIterator_next",_wrap_OctSwigIterator_next,0,0,2,_wrap_OctSwigIterator_next_texinfo}, +{"OctSwigIterator_previous",_wrap_OctSwigIterator_previous,0,0,2,_wrap_OctSwigIterator_previous_texinfo}, +{"OctSwigIterator_advance",_wrap_OctSwigIterator_advance,0,0,2,_wrap_OctSwigIterator_advance_texinfo}, +{"OctSwigIterator___eq__",_wrap_OctSwigIterator___eq__,0,0,2,_wrap_OctSwigIterator___eq___texinfo}, +{"OctSwigIterator___ne__",_wrap_OctSwigIterator___ne__,0,0,2,_wrap_OctSwigIterator___ne___texinfo}, +{"OctSwigIterator___incr__",_wrap_OctSwigIterator___incr__,0,0,2,_wrap_OctSwigIterator___incr___texinfo}, +{"OctSwigIterator___decr__",_wrap_OctSwigIterator___decr__,0,0,2,_wrap_OctSwigIterator___decr___texinfo}, +{"OctSwigIterator___add__",_wrap_OctSwigIterator___add__,0,0,2,_wrap_OctSwigIterator___add___texinfo}, +{"OctSwigIterator___sub__",_wrap_OctSwigIterator___sub__,0,0,2,_wrap_OctSwigIterator___sub___texinfo}, +{"FloatVector_pop",_wrap_FloatVector_pop,0,0,2,_wrap_FloatVector_pop_texinfo}, +{"FloatVector___paren__",_wrap_FloatVector___paren__,0,0,2,_wrap_FloatVector___paren___texinfo}, +{"FloatVector___paren_asgn__",_wrap_FloatVector___paren_asgn__,0,0,2,_wrap_FloatVector___paren_asgn___texinfo}, +{"FloatVector_append",_wrap_FloatVector_append,0,0,2,_wrap_FloatVector_append_texinfo}, +{"FloatVector_empty",_wrap_FloatVector_empty,0,0,2,_wrap_FloatVector_empty_texinfo}, +{"FloatVector_size",_wrap_FloatVector_size,0,0,2,_wrap_FloatVector_size_texinfo}, +{"FloatVector_clear",_wrap_FloatVector_clear,0,0,2,_wrap_FloatVector_clear_texinfo}, +{"FloatVector_swap",_wrap_FloatVector_swap,0,0,2,_wrap_FloatVector_swap_texinfo}, +{"FloatVector_get_allocator",_wrap_FloatVector_get_allocator,0,0,2,_wrap_FloatVector_get_allocator_texinfo}, +{"FloatVector_begin",_wrap_FloatVector_begin,0,0,2,_wrap_FloatVector_begin_texinfo}, +{"FloatVector_end",_wrap_FloatVector_end,0,0,2,_wrap_FloatVector_end_texinfo}, +{"FloatVector_rbegin",_wrap_FloatVector_rbegin,0,0,2,_wrap_FloatVector_rbegin_texinfo}, +{"FloatVector_rend",_wrap_FloatVector_rend,0,0,2,_wrap_FloatVector_rend_texinfo}, +{"FloatVector_pop_back",_wrap_FloatVector_pop_back,0,0,2,_wrap_FloatVector_pop_back_texinfo}, +{"FloatVector_erase",_wrap_FloatVector_erase,0,0,2,_wrap_FloatVector_erase_texinfo}, +{"new_FloatVector",_wrap_new_FloatVector,0,0,2,_wrap_new_FloatVector_texinfo}, +{"FloatVector_push_back",_wrap_FloatVector_push_back,0,0,2,_wrap_FloatVector_push_back_texinfo}, +{"FloatVector_front",_wrap_FloatVector_front,0,0,2,_wrap_FloatVector_front_texinfo}, +{"FloatVector_back",_wrap_FloatVector_back,0,0,2,_wrap_FloatVector_back_texinfo}, +{"FloatVector_assign",_wrap_FloatVector_assign,0,0,2,_wrap_FloatVector_assign_texinfo}, +{"FloatVector_resize",_wrap_FloatVector_resize,0,0,2,_wrap_FloatVector_resize_texinfo}, +{"FloatVector_insert",_wrap_FloatVector_insert,0,0,2,_wrap_FloatVector_insert_texinfo}, +{"FloatVector_reserve",_wrap_FloatVector_reserve,0,0,2,_wrap_FloatVector_reserve_texinfo}, +{"FloatVector_capacity",_wrap_FloatVector_capacity,0,0,2,_wrap_FloatVector_capacity_texinfo}, +{"delete_FloatVector",_wrap_delete_FloatVector,0,0,2,_wrap_delete_FloatVector_texinfo}, +{"CvPointVector_pop",_wrap_CvPointVector_pop,0,0,2,_wrap_CvPointVector_pop_texinfo}, +{"CvPointVector___paren__",_wrap_CvPointVector___paren__,0,0,2,_wrap_CvPointVector___paren___texinfo}, +{"CvPointVector___paren_asgn__",_wrap_CvPointVector___paren_asgn__,0,0,2,_wrap_CvPointVector___paren_asgn___texinfo}, +{"CvPointVector_append",_wrap_CvPointVector_append,0,0,2,_wrap_CvPointVector_append_texinfo}, +{"CvPointVector_empty",_wrap_CvPointVector_empty,0,0,2,_wrap_CvPointVector_empty_texinfo}, +{"CvPointVector_size",_wrap_CvPointVector_size,0,0,2,_wrap_CvPointVector_size_texinfo}, +{"CvPointVector_clear",_wrap_CvPointVector_clear,0,0,2,_wrap_CvPointVector_clear_texinfo}, +{"CvPointVector_swap",_wrap_CvPointVector_swap,0,0,2,_wrap_CvPointVector_swap_texinfo}, +{"CvPointVector_get_allocator",_wrap_CvPointVector_get_allocator,0,0,2,_wrap_CvPointVector_get_allocator_texinfo}, +{"CvPointVector_begin",_wrap_CvPointVector_begin,0,0,2,_wrap_CvPointVector_begin_texinfo}, +{"CvPointVector_end",_wrap_CvPointVector_end,0,0,2,_wrap_CvPointVector_end_texinfo}, +{"CvPointVector_rbegin",_wrap_CvPointVector_rbegin,0,0,2,_wrap_CvPointVector_rbegin_texinfo}, +{"CvPointVector_rend",_wrap_CvPointVector_rend,0,0,2,_wrap_CvPointVector_rend_texinfo}, +{"CvPointVector_pop_back",_wrap_CvPointVector_pop_back,0,0,2,_wrap_CvPointVector_pop_back_texinfo}, +{"CvPointVector_erase",_wrap_CvPointVector_erase,0,0,2,_wrap_CvPointVector_erase_texinfo}, +{"new_CvPointVector",_wrap_new_CvPointVector,0,0,2,_wrap_new_CvPointVector_texinfo}, +{"CvPointVector_push_back",_wrap_CvPointVector_push_back,0,0,2,_wrap_CvPointVector_push_back_texinfo}, +{"CvPointVector_front",_wrap_CvPointVector_front,0,0,2,_wrap_CvPointVector_front_texinfo}, +{"CvPointVector_back",_wrap_CvPointVector_back,0,0,2,_wrap_CvPointVector_back_texinfo}, +{"CvPointVector_assign",_wrap_CvPointVector_assign,0,0,2,_wrap_CvPointVector_assign_texinfo}, +{"CvPointVector_resize",_wrap_CvPointVector_resize,0,0,2,_wrap_CvPointVector_resize_texinfo}, +{"CvPointVector_insert",_wrap_CvPointVector_insert,0,0,2,_wrap_CvPointVector_insert_texinfo}, +{"CvPointVector_reserve",_wrap_CvPointVector_reserve,0,0,2,_wrap_CvPointVector_reserve_texinfo}, +{"CvPointVector_capacity",_wrap_CvPointVector_capacity,0,0,2,_wrap_CvPointVector_capacity_texinfo}, +{"delete_CvPointVector",_wrap_delete_CvPointVector,0,0,2,_wrap_delete_CvPointVector_texinfo}, +{"cvCvtSeqToArray",_wrap_cvCvtSeqToArray,0,0,2,_wrap_cvCvtSeqToArray_texinfo}, +{"cvArcLength",_wrap_cvArcLength,0,0,2,_wrap_cvArcLength_texinfo}, +{"cvContourPerimeter",_wrap_cvContourPerimeter,0,0,2,_wrap_cvContourPerimeter_texinfo}, +{"cvHaarDetectObjects",_wrap_cvHaarDetectObjects,0,0,2,_wrap_cvHaarDetectObjects_texinfo}, +{"cvSegmentMotion",_wrap_cvSegmentMotion,0,0,2,_wrap_cvSegmentMotion_texinfo}, +{"cvApproxPoly",_wrap_cvApproxPoly,0,0,2,_wrap_cvApproxPoly_texinfo}, +{"cvConvexHull2",_wrap_cvConvexHull2,0,0,2,_wrap_cvConvexHull2_texinfo}, +{"cvSnakeImage",_wrap_cvSnakeImage,0,0,2,_wrap_cvSnakeImage_texinfo}, +{"cvFree",_wrap_cvFree,0,0,2,_wrap_cvFree_texinfo}, +{"CV_READ_CHAIN_POINT",_wrap_CV_READ_CHAIN_POINT,0,0,2,_wrap_CV_READ_CHAIN_POINT_texinfo}, +{"CV_MAT_ELEM_PTR",_wrap_CV_MAT_ELEM_PTR,0,0,2,_wrap_CV_MAT_ELEM_PTR_texinfo}, +{"CV_MAT_ELEM_PTR_FAST",_wrap_CV_MAT_ELEM_PTR_FAST,0,0,2,_wrap_CV_MAT_ELEM_PTR_FAST_texinfo}, +{"CV_NODE_VAL",_wrap_CV_NODE_VAL,0,0,2,_wrap_CV_NODE_VAL_texinfo}, +{"CV_NODE_IDX",_wrap_CV_NODE_IDX,0,0,2,_wrap_CV_NODE_IDX_texinfo}, +{"CV_SUBDIV2D_NEXT_EDGE",_wrap_CV_SUBDIV2D_NEXT_EDGE,0,0,2,_wrap_CV_SUBDIV2D_NEXT_EDGE_texinfo}, +{"CV_SWAP",_wrap_CV_SWAP,0,0,2,_wrap_CV_SWAP_texinfo}, +{"CV_IMIN",_wrap_CV_IMIN,0,0,2,_wrap_CV_IMIN_texinfo}, +{"CV_IMAX",_wrap_CV_IMAX,0,0,2,_wrap_CV_IMAX_texinfo}, +{"CV_IABS",_wrap_CV_IABS,0,0,2,_wrap_CV_IABS_texinfo}, +{"CV_CMP",_wrap_CV_CMP,0,0,2,_wrap_CV_CMP_texinfo}, +{"CV_SIGN",_wrap_CV_SIGN,0,0,2,_wrap_CV_SIGN_texinfo}, +{"cvInvSqrt",_wrap_cvInvSqrt,0,0,2,_wrap_cvInvSqrt_texinfo}, +{"cvSqrt",_wrap_cvSqrt,0,0,2,_wrap_cvSqrt_texinfo}, +{"CV_IS_IMAGE_HDR",_wrap_CV_IS_IMAGE_HDR,0,0,2,_wrap_CV_IS_IMAGE_HDR_texinfo}, +{"CV_IS_IMAGE",_wrap_CV_IS_IMAGE,0,0,2,_wrap_CV_IS_IMAGE_texinfo}, +{"CV_MAT_DEPTH",_wrap_CV_MAT_DEPTH,0,0,2,_wrap_CV_MAT_DEPTH_texinfo}, +{"CV_MAKETYPE",_wrap_CV_MAKETYPE,0,0,2,_wrap_CV_MAKETYPE_texinfo}, +{"CV_8UC",_wrap_CV_8UC,0,0,2,_wrap_CV_8UC_texinfo}, +{"CV_8SC",_wrap_CV_8SC,0,0,2,_wrap_CV_8SC_texinfo}, +{"CV_16UC",_wrap_CV_16UC,0,0,2,_wrap_CV_16UC_texinfo}, +{"CV_16SC",_wrap_CV_16SC,0,0,2,_wrap_CV_16SC_texinfo}, +{"CV_32SC",_wrap_CV_32SC,0,0,2,_wrap_CV_32SC_texinfo}, +{"CV_32FC",_wrap_CV_32FC,0,0,2,_wrap_CV_32FC_texinfo}, +{"CV_64FC",_wrap_CV_64FC,0,0,2,_wrap_CV_64FC_texinfo}, +{"CV_MAT_CN",_wrap_CV_MAT_CN,0,0,2,_wrap_CV_MAT_CN_texinfo}, +{"CV_MAT_TYPE",_wrap_CV_MAT_TYPE,0,0,2,_wrap_CV_MAT_TYPE_texinfo}, +{"CV_IS_MAT_CONT",_wrap_CV_IS_MAT_CONT,0,0,2,_wrap_CV_IS_MAT_CONT_texinfo}, +{"CV_IS_TEMP_MAT",_wrap_CV_IS_TEMP_MAT,0,0,2,_wrap_CV_IS_TEMP_MAT_texinfo}, +{"CV_IS_MAT_HDR",_wrap_CV_IS_MAT_HDR,0,0,2,_wrap_CV_IS_MAT_HDR_texinfo}, +{"CV_IS_MAT",_wrap_CV_IS_MAT,0,0,2,_wrap_CV_IS_MAT_texinfo}, +{"CV_IS_MASK_ARR",_wrap_CV_IS_MASK_ARR,0,0,2,_wrap_CV_IS_MASK_ARR_texinfo}, +{"CV_ARE_TYPES_EQ",_wrap_CV_ARE_TYPES_EQ,0,0,2,_wrap_CV_ARE_TYPES_EQ_texinfo}, +{"CV_ARE_CNS_EQ",_wrap_CV_ARE_CNS_EQ,0,0,2,_wrap_CV_ARE_CNS_EQ_texinfo}, +{"CV_ARE_DEPTHS_EQ",_wrap_CV_ARE_DEPTHS_EQ,0,0,2,_wrap_CV_ARE_DEPTHS_EQ_texinfo}, +{"CV_ARE_SIZES_EQ",_wrap_CV_ARE_SIZES_EQ,0,0,2,_wrap_CV_ARE_SIZES_EQ_texinfo}, +{"CV_IS_MAT_CONST",_wrap_CV_IS_MAT_CONST,0,0,2,_wrap_CV_IS_MAT_CONST_texinfo}, +{"CV_ELEM_SIZE1",_wrap_CV_ELEM_SIZE1,0,0,2,_wrap_CV_ELEM_SIZE1_texinfo}, +{"CV_ELEM_SIZE",_wrap_CV_ELEM_SIZE,0,0,2,_wrap_CV_ELEM_SIZE_texinfo}, +{"CV_IS_MATND_HDR",_wrap_CV_IS_MATND_HDR,0,0,2,_wrap_CV_IS_MATND_HDR_texinfo}, +{"CV_IS_MATND",_wrap_CV_IS_MATND,0,0,2,_wrap_CV_IS_MATND_texinfo}, +{"CV_IS_SPARSE_MAT_HDR",_wrap_CV_IS_SPARSE_MAT_HDR,0,0,2,_wrap_CV_IS_SPARSE_MAT_HDR_texinfo}, +{"CV_IS_SPARSE_MAT",_wrap_CV_IS_SPARSE_MAT,0,0,2,_wrap_CV_IS_SPARSE_MAT_texinfo}, +{"CV_IS_HIST",_wrap_CV_IS_HIST,0,0,2,_wrap_CV_IS_HIST_texinfo}, +{"CV_IS_UNIFORM_HIST",_wrap_CV_IS_UNIFORM_HIST,0,0,2,_wrap_CV_IS_UNIFORM_HIST_texinfo}, +{"CV_IS_SPARSE_HIST",_wrap_CV_IS_SPARSE_HIST,0,0,2,_wrap_CV_IS_SPARSE_HIST_texinfo}, +{"CV_HIST_HAS_RANGES",_wrap_CV_HIST_HAS_RANGES,0,0,2,_wrap_CV_HIST_HAS_RANGES_texinfo}, +{"CV_IS_STORAGE",_wrap_CV_IS_STORAGE,0,0,2,_wrap_CV_IS_STORAGE_texinfo}, +{"CV_IS_SET_ELEM",_wrap_CV_IS_SET_ELEM,0,0,2,_wrap_CV_IS_SET_ELEM_texinfo}, +{"CV_IS_SEQ",_wrap_CV_IS_SEQ,0,0,2,_wrap_CV_IS_SEQ_texinfo}, +{"CV_IS_SET",_wrap_CV_IS_SET,0,0,2,_wrap_CV_IS_SET_texinfo}, +{"CV_SEQ_ELTYPE",_wrap_CV_SEQ_ELTYPE,0,0,2,_wrap_CV_SEQ_ELTYPE_texinfo}, +{"CV_SEQ_KIND",_wrap_CV_SEQ_KIND,0,0,2,_wrap_CV_SEQ_KIND_texinfo}, +{"CV_IS_SEQ_INDEX",_wrap_CV_IS_SEQ_INDEX,0,0,2,_wrap_CV_IS_SEQ_INDEX_texinfo}, +{"CV_IS_SEQ_CURVE",_wrap_CV_IS_SEQ_CURVE,0,0,2,_wrap_CV_IS_SEQ_CURVE_texinfo}, +{"CV_IS_SEQ_CLOSED",_wrap_CV_IS_SEQ_CLOSED,0,0,2,_wrap_CV_IS_SEQ_CLOSED_texinfo}, +{"CV_IS_SEQ_CONVEX",_wrap_CV_IS_SEQ_CONVEX,0,0,2,_wrap_CV_IS_SEQ_CONVEX_texinfo}, +{"CV_IS_SEQ_HOLE",_wrap_CV_IS_SEQ_HOLE,0,0,2,_wrap_CV_IS_SEQ_HOLE_texinfo}, +{"CV_IS_SEQ_SIMPLE",_wrap_CV_IS_SEQ_SIMPLE,0,0,2,_wrap_CV_IS_SEQ_SIMPLE_texinfo}, +{"CV_IS_SEQ_POINT_SET",_wrap_CV_IS_SEQ_POINT_SET,0,0,2,_wrap_CV_IS_SEQ_POINT_SET_texinfo}, +{"CV_IS_SEQ_POINT_SUBSET",_wrap_CV_IS_SEQ_POINT_SUBSET,0,0,2,_wrap_CV_IS_SEQ_POINT_SUBSET_texinfo}, +{"CV_IS_SEQ_POLYLINE",_wrap_CV_IS_SEQ_POLYLINE,0,0,2,_wrap_CV_IS_SEQ_POLYLINE_texinfo}, +{"CV_IS_SEQ_POLYGON",_wrap_CV_IS_SEQ_POLYGON,0,0,2,_wrap_CV_IS_SEQ_POLYGON_texinfo}, +{"CV_IS_SEQ_CHAIN",_wrap_CV_IS_SEQ_CHAIN,0,0,2,_wrap_CV_IS_SEQ_CHAIN_texinfo}, +{"CV_IS_SEQ_CONTOUR",_wrap_CV_IS_SEQ_CONTOUR,0,0,2,_wrap_CV_IS_SEQ_CONTOUR_texinfo}, +{"CV_IS_SEQ_CHAIN_CONTOUR",_wrap_CV_IS_SEQ_CHAIN_CONTOUR,0,0,2,_wrap_CV_IS_SEQ_CHAIN_CONTOUR_texinfo}, +{"CV_IS_SEQ_POLYGON_TREE",_wrap_CV_IS_SEQ_POLYGON_TREE,0,0,2,_wrap_CV_IS_SEQ_POLYGON_TREE_texinfo}, +{"CV_IS_GRAPH",_wrap_CV_IS_GRAPH,0,0,2,_wrap_CV_IS_GRAPH_texinfo}, +{"CV_IS_GRAPH_ORIENTED",_wrap_CV_IS_GRAPH_ORIENTED,0,0,2,_wrap_CV_IS_GRAPH_ORIENTED_texinfo}, +{"CV_IS_SUBDIV2D",_wrap_CV_IS_SUBDIV2D,0,0,2,_wrap_CV_IS_SUBDIV2D_texinfo}, +{"CV_WRITE_SEQ_ELEM_VAR",_wrap_CV_WRITE_SEQ_ELEM_VAR,0,0,2,_wrap_CV_WRITE_SEQ_ELEM_VAR_texinfo}, +{"CV_WRITE_SEQ_ELEM",_wrap_CV_WRITE_SEQ_ELEM,0,0,2,_wrap_CV_WRITE_SEQ_ELEM_texinfo}, +{"CV_NEXT_SEQ_ELEM",_wrap_CV_NEXT_SEQ_ELEM,0,0,2,_wrap_CV_NEXT_SEQ_ELEM_texinfo}, +{"CV_PREV_SEQ_ELEM",_wrap_CV_PREV_SEQ_ELEM,0,0,2,_wrap_CV_PREV_SEQ_ELEM_texinfo}, +{"CV_READ_SEQ_ELEM",_wrap_CV_READ_SEQ_ELEM,0,0,2,_wrap_CV_READ_SEQ_ELEM_texinfo}, +{"CV_REV_READ_SEQ_ELEM",_wrap_CV_REV_READ_SEQ_ELEM,0,0,2,_wrap_CV_REV_READ_SEQ_ELEM_texinfo}, +{"CV_CURRENT_POINT",_wrap_CV_CURRENT_POINT,0,0,2,_wrap_CV_CURRENT_POINT_texinfo}, +{"CV_PREV_POINT",_wrap_CV_PREV_POINT,0,0,2,_wrap_CV_PREV_POINT_texinfo}, +{"CV_READ_EDGE",_wrap_CV_READ_EDGE,0,0,2,_wrap_CV_READ_EDGE_texinfo}, +{"CV_NEXT_GRAPH_EDGE",_wrap_CV_NEXT_GRAPH_EDGE,0,0,2,_wrap_CV_NEXT_GRAPH_EDGE_texinfo}, +{"CV_NODE_TYPE",_wrap_CV_NODE_TYPE,0,0,2,_wrap_CV_NODE_TYPE_texinfo}, +{"CV_NODE_IS_INT",_wrap_CV_NODE_IS_INT,0,0,2,_wrap_CV_NODE_IS_INT_texinfo}, +{"CV_NODE_IS_REAL",_wrap_CV_NODE_IS_REAL,0,0,2,_wrap_CV_NODE_IS_REAL_texinfo}, +{"CV_NODE_IS_STRING",_wrap_CV_NODE_IS_STRING,0,0,2,_wrap_CV_NODE_IS_STRING_texinfo}, +{"CV_NODE_IS_SEQ",_wrap_CV_NODE_IS_SEQ,0,0,2,_wrap_CV_NODE_IS_SEQ_texinfo}, +{"CV_NODE_IS_MAP",_wrap_CV_NODE_IS_MAP,0,0,2,_wrap_CV_NODE_IS_MAP_texinfo}, +{"CV_NODE_IS_COLLECTION",_wrap_CV_NODE_IS_COLLECTION,0,0,2,_wrap_CV_NODE_IS_COLLECTION_texinfo}, +{"CV_NODE_IS_FLOW",_wrap_CV_NODE_IS_FLOW,0,0,2,_wrap_CV_NODE_IS_FLOW_texinfo}, +{"CV_NODE_IS_EMPTY",_wrap_CV_NODE_IS_EMPTY,0,0,2,_wrap_CV_NODE_IS_EMPTY_texinfo}, +{"CV_NODE_IS_USER",_wrap_CV_NODE_IS_USER,0,0,2,_wrap_CV_NODE_IS_USER_texinfo}, +{"CV_NODE_HAS_NAME",_wrap_CV_NODE_HAS_NAME,0,0,2,_wrap_CV_NODE_HAS_NAME_texinfo}, +{"CV_NODE_SEQ_IS_SIMPLE",_wrap_CV_NODE_SEQ_IS_SIMPLE,0,0,2,_wrap_CV_NODE_SEQ_IS_SIMPLE_texinfo}, +{"cvReshapeND",_wrap_cvReshapeND,0,0,2,_wrap_cvReshapeND_texinfo}, +{"cvConvert",_wrap_cvConvert,0,0,2,_wrap_cvConvert_texinfo}, +{"cvAXPY",_wrap_cvAXPY,0,0,2,_wrap_cvAXPY_texinfo}, +{"cvAbs",_wrap_cvAbs,0,0,2,_wrap_cvAbs_texinfo}, +{"cvMatMulAdd",_wrap_cvMatMulAdd,0,0,2,_wrap_cvMatMulAdd_texinfo}, +{"cvMatMul",_wrap_cvMatMul,0,0,2,_wrap_cvMatMul_texinfo}, +{"cvGetGraphVtx",_wrap_cvGetGraphVtx,0,0,2,_wrap_cvGetGraphVtx_texinfo}, +{"cvGraphVtxIdx",_wrap_cvGraphVtxIdx,0,0,2,_wrap_cvGraphVtxIdx_texinfo}, +{"cvGraphEdgeIdx",_wrap_cvGraphEdgeIdx,0,0,2,_wrap_cvGraphEdgeIdx_texinfo}, +{"cvGraphGetVtxCount",_wrap_cvGraphGetVtxCount,0,0,2,_wrap_cvGraphGetVtxCount_texinfo}, +{"cvGraphGetEdgeCount",_wrap_cvGraphGetEdgeCount,0,0,2,_wrap_cvGraphGetEdgeCount_texinfo}, +{"CV_IS_GRAPH_VERTEX_VISITED",_wrap_CV_IS_GRAPH_VERTEX_VISITED,0,0,2,_wrap_CV_IS_GRAPH_VERTEX_VISITED_texinfo}, +{"CV_IS_GRAPH_EDGE_VISITED",_wrap_CV_IS_GRAPH_EDGE_VISITED,0,0,2,_wrap_CV_IS_GRAPH_EDGE_VISITED_texinfo}, +{"CV_RGB",_wrap_CV_RGB,0,0,2,_wrap_CV_RGB_texinfo}, +{"CV_NEXT_LINE_POINT",_wrap_CV_NEXT_LINE_POINT,0,0,2,_wrap_CV_NEXT_LINE_POINT_texinfo}, +{"CV_INIT_3X3_DELTAS",_wrap_CV_INIT_3X3_DELTAS,0,0,2,_wrap_CV_INIT_3X3_DELTAS_texinfo}, +{"CV_IS_HAAR_CLASSIFIER",_wrap_CV_IS_HAAR_CLASSIFIER,0,0,2,_wrap_CV_IS_HAAR_CLASSIFIER_texinfo}, +{"cvCalcBackProject",_wrap_cvCalcBackProject,0,0,2,_wrap_cvCalcBackProject_texinfo}, +{"cvCalcBackProjectPatch",_wrap_cvCalcBackProjectPatch,0,0,2,_wrap_cvCalcBackProjectPatch_texinfo}, +{"cvCreateImage",_wrap_cvCreateImage,0,0,2,_wrap_cvCreateImage_texinfo}, +{"cvCloneImage",_wrap_cvCloneImage,0,0,2,_wrap_cvCloneImage_texinfo}, +{"Cv32suf_i_set",_wrap_Cv32suf_i_set,0,0,2,0}, +{"Cv32suf_i_get",_wrap_Cv32suf_i_get,0,0,2,0}, +{"Cv32suf_u_set",_wrap_Cv32suf_u_set,0,0,2,0}, +{"Cv32suf_u_get",_wrap_Cv32suf_u_get,0,0,2,0}, +{"Cv32suf_f_set",_wrap_Cv32suf_f_set,0,0,2,0}, +{"Cv32suf_f_get",_wrap_Cv32suf_f_get,0,0,2,0}, +{"new_Cv32suf",_wrap_new_Cv32suf,0,0,2,_wrap_new_Cv32suf_texinfo}, +{"delete_Cv32suf",_wrap_delete_Cv32suf,0,0,2,_wrap_delete_Cv32suf_texinfo}, +{"Cv64suf_i_set",_wrap_Cv64suf_i_set,0,0,2,0}, +{"Cv64suf_i_get",_wrap_Cv64suf_i_get,0,0,2,0}, +{"Cv64suf_u_set",_wrap_Cv64suf_u_set,0,0,2,0}, +{"Cv64suf_u_get",_wrap_Cv64suf_u_get,0,0,2,0}, +{"Cv64suf_f_set",_wrap_Cv64suf_f_set,0,0,2,0}, +{"Cv64suf_f_get",_wrap_Cv64suf_f_get,0,0,2,0}, +{"new_Cv64suf",_wrap_new_Cv64suf,0,0,2,_wrap_new_Cv64suf_texinfo}, +{"delete_Cv64suf",_wrap_delete_Cv64suf,0,0,2,_wrap_delete_Cv64suf_texinfo}, +{"cvRound",_wrap_cvRound,0,0,2,_wrap_cvRound_texinfo}, +{"cvFloor",_wrap_cvFloor,0,0,2,_wrap_cvFloor_texinfo}, +{"cvCeil",_wrap_cvCeil,0,0,2,_wrap_cvCeil_texinfo}, +{"cvIsNaN",_wrap_cvIsNaN,0,0,2,_wrap_cvIsNaN_texinfo}, +{"cvIsInf",_wrap_cvIsInf,0,0,2,_wrap_cvIsInf_texinfo}, +{"cvRNG",_wrap_cvRNG,0,0,2,_wrap_cvRNG_texinfo}, +{"cvRandInt",_wrap_cvRandInt,0,0,2,_wrap_cvRandInt_texinfo}, +{"cvRandReal",_wrap_cvRandReal,0,0,2,_wrap_cvRandReal_texinfo}, +{"IplImage_ID_set",_wrap_IplImage_ID_set,0,0,2,0}, +{"IplImage_ID_get",_wrap_IplImage_ID_get,0,0,2,0}, +{"IplImage_nChannels_set",_wrap_IplImage_nChannels_set,0,0,2,0}, +{"IplImage_nChannels_get",_wrap_IplImage_nChannels_get,0,0,2,0}, +{"IplImage_depth_set",_wrap_IplImage_depth_set,0,0,2,0}, +{"IplImage_depth_get",_wrap_IplImage_depth_get,0,0,2,0}, +{"IplImage_dataOrder_set",_wrap_IplImage_dataOrder_set,0,0,2,0}, +{"IplImage_dataOrder_get",_wrap_IplImage_dataOrder_get,0,0,2,0}, +{"IplImage_origin_set",_wrap_IplImage_origin_set,0,0,2,0}, +{"IplImage_origin_get",_wrap_IplImage_origin_get,0,0,2,0}, +{"IplImage_align_set",_wrap_IplImage_align_set,0,0,2,0}, +{"IplImage_align_get",_wrap_IplImage_align_get,0,0,2,0}, +{"IplImage_width_set",_wrap_IplImage_width_set,0,0,2,0}, +{"IplImage_width_get",_wrap_IplImage_width_get,0,0,2,0}, +{"IplImage_height_set",_wrap_IplImage_height_set,0,0,2,0}, +{"IplImage_height_get",_wrap_IplImage_height_get,0,0,2,0}, +{"IplImage_roi_set",_wrap_IplImage_roi_set,0,0,2,0}, +{"IplImage_roi_get",_wrap_IplImage_roi_get,0,0,2,0}, +{"IplImage_imageSize_set",_wrap_IplImage_imageSize_set,0,0,2,0}, +{"IplImage_imageSize_get",_wrap_IplImage_imageSize_get,0,0,2,0}, +{"IplImage_widthStep_set",_wrap_IplImage_widthStep_set,0,0,2,0}, +{"IplImage_widthStep_get",_wrap_IplImage_widthStep_get,0,0,2,0}, +{"delete_IplImage",_wrap_delete_IplImage,0,0,2,_wrap_delete_IplImage_texinfo}, +{"IplImage___add__",_wrap_IplImage___add__,0,0,2,_wrap_IplImage___add___texinfo}, +{"IplImage___xor__",_wrap_IplImage___xor__,0,0,2,_wrap_IplImage___xor___texinfo}, +{"IplImage___sub__",_wrap_IplImage___sub__,0,0,2,_wrap_IplImage___sub___texinfo}, +{"IplImage___ge__",_wrap_IplImage___ge__,0,0,2,_wrap_IplImage___ge___texinfo}, +{"IplImage___eq__",_wrap_IplImage___eq__,0,0,2,_wrap_IplImage___eq___texinfo}, +{"IplImage___le__",_wrap_IplImage___le__,0,0,2,_wrap_IplImage___le___texinfo}, +{"IplImage___ne__",_wrap_IplImage___ne__,0,0,2,_wrap_IplImage___ne___texinfo}, +{"IplImage___lt__",_wrap_IplImage___lt__,0,0,2,_wrap_IplImage___lt___texinfo}, +{"IplImage___gt__",_wrap_IplImage___gt__,0,0,2,_wrap_IplImage___gt___texinfo}, +{"IplImage___mul__",_wrap_IplImage___mul__,0,0,2,_wrap_IplImage___mul___texinfo}, +{"IplImage___div__",_wrap_IplImage___div__,0,0,2,_wrap_IplImage___div___texinfo}, +{"IplImage___radd__",_wrap_IplImage___radd__,0,0,2,_wrap_IplImage___radd___texinfo}, +{"IplImage___rsub__",_wrap_IplImage___rsub__,0,0,2,_wrap_IplImage___rsub___texinfo}, +{"IplImage___rmul__",_wrap_IplImage___rmul__,0,0,2,_wrap_IplImage___rmul___texinfo}, +{"IplImage___rdiv__",_wrap_IplImage___rdiv__,0,0,2,_wrap_IplImage___rdiv___texinfo}, +{"IplImage___ror__",_wrap_IplImage___ror__,0,0,2,_wrap_IplImage___ror___texinfo}, +{"IplImage___rand__",_wrap_IplImage___rand__,0,0,2,_wrap_IplImage___rand___texinfo}, +{"IplImage___rxor__",_wrap_IplImage___rxor__,0,0,2,_wrap_IplImage___rxor___texinfo}, +{"IplImage___req__",_wrap_IplImage___req__,0,0,2,_wrap_IplImage___req___texinfo}, +{"IplImage___rgt__",_wrap_IplImage___rgt__,0,0,2,_wrap_IplImage___rgt___texinfo}, +{"IplImage___rge__",_wrap_IplImage___rge__,0,0,2,_wrap_IplImage___rge___texinfo}, +{"IplImage___rlt__",_wrap_IplImage___rlt__,0,0,2,_wrap_IplImage___rlt___texinfo}, +{"IplImage___rle__",_wrap_IplImage___rle__,0,0,2,_wrap_IplImage___rle___texinfo}, +{"IplImage___rne__",_wrap_IplImage___rne__,0,0,2,_wrap_IplImage___rne___texinfo}, +{"IplImage___pow__",_wrap_IplImage___pow__,0,0,2,_wrap_IplImage___pow___texinfo}, +{"IplImage___str",_wrap_IplImage___str,0,0,2,_wrap_IplImage___str_texinfo}, +{"IplImage___paren_asgn",_wrap_IplImage___paren_asgn,0,0,2,_wrap_IplImage___paren_asgn_texinfo}, +{"IplImage___paren",_wrap_IplImage___paren,0,0,2,_wrap_IplImage___paren_texinfo}, +{"IplROI_coi_set",_wrap_IplROI_coi_set,0,0,2,0}, +{"IplROI_coi_get",_wrap_IplROI_coi_get,0,0,2,0}, +{"IplROI_xOffset_set",_wrap_IplROI_xOffset_set,0,0,2,0}, +{"IplROI_xOffset_get",_wrap_IplROI_xOffset_get,0,0,2,0}, +{"IplROI_yOffset_set",_wrap_IplROI_yOffset_set,0,0,2,0}, +{"IplROI_yOffset_get",_wrap_IplROI_yOffset_get,0,0,2,0}, +{"IplROI_width_set",_wrap_IplROI_width_set,0,0,2,0}, +{"IplROI_width_get",_wrap_IplROI_width_get,0,0,2,0}, +{"IplROI_height_set",_wrap_IplROI_height_set,0,0,2,0}, +{"IplROI_height_get",_wrap_IplROI_height_get,0,0,2,0}, +{"new_IplROI",_wrap_new_IplROI,0,0,2,_wrap_new_IplROI_texinfo}, +{"delete_IplROI",_wrap_delete_IplROI,0,0,2,_wrap_delete_IplROI_texinfo}, +{"IplConvKernel_nCols_set",_wrap_IplConvKernel_nCols_set,0,0,2,0}, +{"IplConvKernel_nCols_get",_wrap_IplConvKernel_nCols_get,0,0,2,0}, +{"IplConvKernel_nRows_set",_wrap_IplConvKernel_nRows_set,0,0,2,0}, +{"IplConvKernel_nRows_get",_wrap_IplConvKernel_nRows_get,0,0,2,0}, +{"IplConvKernel_anchorX_set",_wrap_IplConvKernel_anchorX_set,0,0,2,0}, +{"IplConvKernel_anchorX_get",_wrap_IplConvKernel_anchorX_get,0,0,2,0}, +{"IplConvKernel_anchorY_set",_wrap_IplConvKernel_anchorY_set,0,0,2,0}, +{"IplConvKernel_anchorY_get",_wrap_IplConvKernel_anchorY_get,0,0,2,0}, +{"IplConvKernel_values_set",_wrap_IplConvKernel_values_set,0,0,2,0}, +{"IplConvKernel_values_get",_wrap_IplConvKernel_values_get,0,0,2,0}, +{"IplConvKernel_nShiftR_set",_wrap_IplConvKernel_nShiftR_set,0,0,2,0}, +{"IplConvKernel_nShiftR_get",_wrap_IplConvKernel_nShiftR_get,0,0,2,0}, +{"delete_IplConvKernel",_wrap_delete_IplConvKernel,0,0,2,_wrap_delete_IplConvKernel_texinfo}, +{"IplConvKernelFP_nCols_set",_wrap_IplConvKernelFP_nCols_set,0,0,2,0}, +{"IplConvKernelFP_nCols_get",_wrap_IplConvKernelFP_nCols_get,0,0,2,0}, +{"IplConvKernelFP_nRows_set",_wrap_IplConvKernelFP_nRows_set,0,0,2,0}, +{"IplConvKernelFP_nRows_get",_wrap_IplConvKernelFP_nRows_get,0,0,2,0}, +{"IplConvKernelFP_anchorX_set",_wrap_IplConvKernelFP_anchorX_set,0,0,2,0}, +{"IplConvKernelFP_anchorX_get",_wrap_IplConvKernelFP_anchorX_get,0,0,2,0}, +{"IplConvKernelFP_anchorY_set",_wrap_IplConvKernelFP_anchorY_set,0,0,2,0}, +{"IplConvKernelFP_anchorY_get",_wrap_IplConvKernelFP_anchorY_get,0,0,2,0}, +{"IplConvKernelFP_values_set",_wrap_IplConvKernelFP_values_set,0,0,2,0}, +{"IplConvKernelFP_values_get",_wrap_IplConvKernelFP_values_get,0,0,2,0}, +{"new_IplConvKernelFP",_wrap_new_IplConvKernelFP,0,0,2,_wrap_new_IplConvKernelFP_texinfo}, +{"delete_IplConvKernelFP",_wrap_delete_IplConvKernelFP,0,0,2,_wrap_delete_IplConvKernelFP_texinfo}, +{"CvMat_type_set",_wrap_CvMat_type_set,0,0,2,0}, +{"CvMat_type_get",_wrap_CvMat_type_get,0,0,2,0}, +{"CvMat_step_set",_wrap_CvMat_step_set,0,0,2,0}, +{"CvMat_step_get",_wrap_CvMat_step_get,0,0,2,0}, +{"CvMat_refcount_set",_wrap_CvMat_refcount_set,0,0,2,0}, +{"CvMat_refcount_get",_wrap_CvMat_refcount_get,0,0,2,0}, +{"CvMat_hdr_refcount_set",_wrap_CvMat_hdr_refcount_set,0,0,2,0}, +{"CvMat_hdr_refcount_get",_wrap_CvMat_hdr_refcount_get,0,0,2,0}, +{"CvMat_data_get",_wrap_CvMat_data_get,0,0,2,0}, +{"delete_CvMat",_wrap_delete_CvMat,0,0,2,_wrap_delete_CvMat_texinfo}, +{"CvMat_depth_set",_wrap_CvMat_depth_set,0,0,2,0}, +{"CvMat_depth_get",_wrap_CvMat_depth_get,0,0,2,0}, +{"CvMat_nChannels_set",_wrap_CvMat_nChannels_set,0,0,2,0}, +{"CvMat_nChannels_get",_wrap_CvMat_nChannels_get,0,0,2,0}, +{"CvMat_dataOrder_set",_wrap_CvMat_dataOrder_set,0,0,2,0}, +{"CvMat_dataOrder_get",_wrap_CvMat_dataOrder_get,0,0,2,0}, +{"CvMat_origin_set",_wrap_CvMat_origin_set,0,0,2,0}, +{"CvMat_origin_get",_wrap_CvMat_origin_get,0,0,2,0}, +{"CvMat_width_set",_wrap_CvMat_width_set,0,0,2,0}, +{"CvMat_width_get",_wrap_CvMat_width_get,0,0,2,0}, +{"CvMat_height_set",_wrap_CvMat_height_set,0,0,2,0}, +{"CvMat_height_get",_wrap_CvMat_height_get,0,0,2,0}, +{"CvMat_imageSize_set",_wrap_CvMat_imageSize_set,0,0,2,0}, +{"CvMat_imageSize_get",_wrap_CvMat_imageSize_get,0,0,2,0}, +{"CvMat_widthStep_set",_wrap_CvMat_widthStep_set,0,0,2,0}, +{"CvMat_widthStep_get",_wrap_CvMat_widthStep_get,0,0,2,0}, +{"CvMat_rows_set",_wrap_CvMat_rows_set,0,0,2,0}, +{"CvMat_rows_get",_wrap_CvMat_rows_get,0,0,2,0}, +{"CvMat_cols_set",_wrap_CvMat_cols_set,0,0,2,0}, +{"CvMat_cols_get",_wrap_CvMat_cols_get,0,0,2,0}, +{"CvMat___add__",_wrap_CvMat___add__,0,0,2,_wrap_CvMat___add___texinfo}, +{"CvMat___xor__",_wrap_CvMat___xor__,0,0,2,_wrap_CvMat___xor___texinfo}, +{"CvMat___sub__",_wrap_CvMat___sub__,0,0,2,_wrap_CvMat___sub___texinfo}, +{"CvMat___ge__",_wrap_CvMat___ge__,0,0,2,_wrap_CvMat___ge___texinfo}, +{"CvMat___eq__",_wrap_CvMat___eq__,0,0,2,_wrap_CvMat___eq___texinfo}, +{"CvMat___le__",_wrap_CvMat___le__,0,0,2,_wrap_CvMat___le___texinfo}, +{"CvMat___ne__",_wrap_CvMat___ne__,0,0,2,_wrap_CvMat___ne___texinfo}, +{"CvMat___lt__",_wrap_CvMat___lt__,0,0,2,_wrap_CvMat___lt___texinfo}, +{"CvMat___gt__",_wrap_CvMat___gt__,0,0,2,_wrap_CvMat___gt___texinfo}, +{"CvMat___mul__",_wrap_CvMat___mul__,0,0,2,_wrap_CvMat___mul___texinfo}, +{"CvMat___div__",_wrap_CvMat___div__,0,0,2,_wrap_CvMat___div___texinfo}, +{"CvMat___radd__",_wrap_CvMat___radd__,0,0,2,_wrap_CvMat___radd___texinfo}, +{"CvMat___rsub__",_wrap_CvMat___rsub__,0,0,2,_wrap_CvMat___rsub___texinfo}, +{"CvMat___rmul__",_wrap_CvMat___rmul__,0,0,2,_wrap_CvMat___rmul___texinfo}, +{"CvMat___rdiv__",_wrap_CvMat___rdiv__,0,0,2,_wrap_CvMat___rdiv___texinfo}, +{"CvMat___ror__",_wrap_CvMat___ror__,0,0,2,_wrap_CvMat___ror___texinfo}, +{"CvMat___rand__",_wrap_CvMat___rand__,0,0,2,_wrap_CvMat___rand___texinfo}, +{"CvMat___rxor__",_wrap_CvMat___rxor__,0,0,2,_wrap_CvMat___rxor___texinfo}, +{"CvMat___req__",_wrap_CvMat___req__,0,0,2,_wrap_CvMat___req___texinfo}, +{"CvMat___rgt__",_wrap_CvMat___rgt__,0,0,2,_wrap_CvMat___rgt___texinfo}, +{"CvMat___rge__",_wrap_CvMat___rge__,0,0,2,_wrap_CvMat___rge___texinfo}, +{"CvMat___rlt__",_wrap_CvMat___rlt__,0,0,2,_wrap_CvMat___rlt___texinfo}, +{"CvMat___rle__",_wrap_CvMat___rle__,0,0,2,_wrap_CvMat___rle___texinfo}, +{"CvMat___rne__",_wrap_CvMat___rne__,0,0,2,_wrap_CvMat___rne___texinfo}, +{"CvMat___pow__",_wrap_CvMat___pow__,0,0,2,_wrap_CvMat___pow___texinfo}, +{"CvMat___str",_wrap_CvMat___str,0,0,2,_wrap_CvMat___str_texinfo}, +{"CvMat___paren_asgn",_wrap_CvMat___paren_asgn,0,0,2,_wrap_CvMat___paren_asgn_texinfo}, +{"CvMat___paren",_wrap_CvMat___paren,0,0,2,_wrap_CvMat___paren_texinfo}, +{"CvMat_imageData_set",_wrap_CvMat_imageData_set,0,0,2,0}, +{"CvMat_imageData_get",_wrap_CvMat_imageData_get,0,0,2,0}, +{"CvMat_data_ptr_set",_wrap_CvMat_data_ptr_set,0,0,2,0}, +{"CvMat_data_ptr_get",_wrap_CvMat_data_ptr_get,0,0,2,0}, +{"CvMat_data_s_set",_wrap_CvMat_data_s_set,0,0,2,0}, +{"CvMat_data_s_get",_wrap_CvMat_data_s_get,0,0,2,0}, +{"CvMat_data_i_set",_wrap_CvMat_data_i_set,0,0,2,0}, +{"CvMat_data_i_get",_wrap_CvMat_data_i_get,0,0,2,0}, +{"CvMat_data_fl_set",_wrap_CvMat_data_fl_set,0,0,2,0}, +{"CvMat_data_fl_get",_wrap_CvMat_data_fl_get,0,0,2,0}, +{"CvMat_data_db_set",_wrap_CvMat_data_db_set,0,0,2,0}, +{"CvMat_data_db_get",_wrap_CvMat_data_db_get,0,0,2,0}, +{"new_CvMat_data",_wrap_new_CvMat_data,0,0,2,_wrap_new_CvMat_data_texinfo}, +{"delete_CvMat_data",_wrap_delete_CvMat_data,0,0,2,_wrap_delete_CvMat_data_texinfo}, +{"cvMat",_wrap_cvMat,0,0,2,_wrap_cvMat_texinfo}, +{"cvmGet",_wrap_cvmGet,0,0,2,_wrap_cvmGet_texinfo}, +{"cvmSet",_wrap_cvmSet,0,0,2,_wrap_cvmSet_texinfo}, +{"cvIplDepth",_wrap_cvIplDepth,0,0,2,_wrap_cvIplDepth_texinfo}, +{"CvMatND_type_set",_wrap_CvMatND_type_set,0,0,2,0}, +{"CvMatND_type_get",_wrap_CvMatND_type_get,0,0,2,0}, +{"CvMatND_dims_set",_wrap_CvMatND_dims_set,0,0,2,0}, +{"CvMatND_dims_get",_wrap_CvMatND_dims_get,0,0,2,0}, +{"CvMatND_refcount_set",_wrap_CvMatND_refcount_set,0,0,2,0}, +{"CvMatND_refcount_get",_wrap_CvMatND_refcount_get,0,0,2,0}, +{"CvMatND_hdr_refcount_set",_wrap_CvMatND_hdr_refcount_set,0,0,2,0}, +{"CvMatND_hdr_refcount_get",_wrap_CvMatND_hdr_refcount_get,0,0,2,0}, +{"CvMatND_dim_get",_wrap_CvMatND_dim_get,0,0,2,0}, +{"CvMatND_data_get",_wrap_CvMatND_data_get,0,0,2,0}, +{"delete_CvMatND",_wrap_delete_CvMatND,0,0,2,_wrap_delete_CvMatND_texinfo}, +{"CvMatND_dim_size_set",_wrap_CvMatND_dim_size_set,0,0,2,0}, +{"CvMatND_dim_size_get",_wrap_CvMatND_dim_size_get,0,0,2,0}, +{"CvMatND_dim_step_set",_wrap_CvMatND_dim_step_set,0,0,2,0}, +{"CvMatND_dim_step_get",_wrap_CvMatND_dim_step_get,0,0,2,0}, +{"new_CvMatND_dim",_wrap_new_CvMatND_dim,0,0,2,_wrap_new_CvMatND_dim_texinfo}, +{"delete_CvMatND_dim",_wrap_delete_CvMatND_dim,0,0,2,_wrap_delete_CvMatND_dim_texinfo}, +{"CvMatND_data_ptr_set",_wrap_CvMatND_data_ptr_set,0,0,2,0}, +{"CvMatND_data_ptr_get",_wrap_CvMatND_data_ptr_get,0,0,2,0}, +{"CvMatND_data_fl_set",_wrap_CvMatND_data_fl_set,0,0,2,0}, +{"CvMatND_data_fl_get",_wrap_CvMatND_data_fl_get,0,0,2,0}, +{"CvMatND_data_db_set",_wrap_CvMatND_data_db_set,0,0,2,0}, +{"CvMatND_data_db_get",_wrap_CvMatND_data_db_get,0,0,2,0}, +{"CvMatND_data_i_set",_wrap_CvMatND_data_i_set,0,0,2,0}, +{"CvMatND_data_i_get",_wrap_CvMatND_data_i_get,0,0,2,0}, +{"CvMatND_data_s_set",_wrap_CvMatND_data_s_set,0,0,2,0}, +{"CvMatND_data_s_get",_wrap_CvMatND_data_s_get,0,0,2,0}, +{"new_CvMatND_data",_wrap_new_CvMatND_data,0,0,2,_wrap_new_CvMatND_data_texinfo}, +{"delete_CvMatND_data",_wrap_delete_CvMatND_data,0,0,2,_wrap_delete_CvMatND_data_texinfo}, +{"CvSparseMat_type_set",_wrap_CvSparseMat_type_set,0,0,2,0}, +{"CvSparseMat_type_get",_wrap_CvSparseMat_type_get,0,0,2,0}, +{"CvSparseMat_dims_set",_wrap_CvSparseMat_dims_set,0,0,2,0}, +{"CvSparseMat_dims_get",_wrap_CvSparseMat_dims_get,0,0,2,0}, +{"CvSparseMat_refcount_set",_wrap_CvSparseMat_refcount_set,0,0,2,0}, +{"CvSparseMat_refcount_get",_wrap_CvSparseMat_refcount_get,0,0,2,0}, +{"CvSparseMat_hdr_refcount_set",_wrap_CvSparseMat_hdr_refcount_set,0,0,2,0}, +{"CvSparseMat_hdr_refcount_get",_wrap_CvSparseMat_hdr_refcount_get,0,0,2,0}, +{"CvSparseMat_heap_set",_wrap_CvSparseMat_heap_set,0,0,2,0}, +{"CvSparseMat_heap_get",_wrap_CvSparseMat_heap_get,0,0,2,0}, +{"CvSparseMat_hashtable_set",_wrap_CvSparseMat_hashtable_set,0,0,2,0}, +{"CvSparseMat_hashtable_get",_wrap_CvSparseMat_hashtable_get,0,0,2,0}, +{"CvSparseMat_hashsize_set",_wrap_CvSparseMat_hashsize_set,0,0,2,0}, +{"CvSparseMat_hashsize_get",_wrap_CvSparseMat_hashsize_get,0,0,2,0}, +{"CvSparseMat_valoffset_set",_wrap_CvSparseMat_valoffset_set,0,0,2,0}, +{"CvSparseMat_valoffset_get",_wrap_CvSparseMat_valoffset_get,0,0,2,0}, +{"CvSparseMat_idxoffset_set",_wrap_CvSparseMat_idxoffset_set,0,0,2,0}, +{"CvSparseMat_idxoffset_get",_wrap_CvSparseMat_idxoffset_get,0,0,2,0}, +{"CvSparseMat_size_set",_wrap_CvSparseMat_size_set,0,0,2,0}, +{"CvSparseMat_size_get",_wrap_CvSparseMat_size_get,0,0,2,0}, +{"delete_CvSparseMat",_wrap_delete_CvSparseMat,0,0,2,_wrap_delete_CvSparseMat_texinfo}, +{"CvSparseNode_hashval_set",_wrap_CvSparseNode_hashval_set,0,0,2,0}, +{"CvSparseNode_hashval_get",_wrap_CvSparseNode_hashval_get,0,0,2,0}, +{"CvSparseNode_next_set",_wrap_CvSparseNode_next_set,0,0,2,0}, +{"CvSparseNode_next_get",_wrap_CvSparseNode_next_get,0,0,2,0}, +{"new_CvSparseNode",_wrap_new_CvSparseNode,0,0,2,_wrap_new_CvSparseNode_texinfo}, +{"delete_CvSparseNode",_wrap_delete_CvSparseNode,0,0,2,_wrap_delete_CvSparseNode_texinfo}, +{"CvSparseMatIterator_mat_set",_wrap_CvSparseMatIterator_mat_set,0,0,2,0}, +{"CvSparseMatIterator_mat_get",_wrap_CvSparseMatIterator_mat_get,0,0,2,0}, +{"CvSparseMatIterator_node_set",_wrap_CvSparseMatIterator_node_set,0,0,2,0}, +{"CvSparseMatIterator_node_get",_wrap_CvSparseMatIterator_node_get,0,0,2,0}, +{"CvSparseMatIterator_curidx_set",_wrap_CvSparseMatIterator_curidx_set,0,0,2,0}, +{"CvSparseMatIterator_curidx_get",_wrap_CvSparseMatIterator_curidx_get,0,0,2,0}, +{"new_CvSparseMatIterator",_wrap_new_CvSparseMatIterator,0,0,2,_wrap_new_CvSparseMatIterator_texinfo}, +{"delete_CvSparseMatIterator",_wrap_delete_CvSparseMatIterator,0,0,2,_wrap_delete_CvSparseMatIterator_texinfo}, +{"CvHistogram_type_set",_wrap_CvHistogram_type_set,0,0,2,0}, +{"CvHistogram_type_get",_wrap_CvHistogram_type_get,0,0,2,0}, +{"CvHistogram_bins_set",_wrap_CvHistogram_bins_set,0,0,2,0}, +{"CvHistogram_bins_get",_wrap_CvHistogram_bins_get,0,0,2,0}, +{"CvHistogram_thresh_set",_wrap_CvHistogram_thresh_set,0,0,2,0}, +{"CvHistogram_thresh_get",_wrap_CvHistogram_thresh_get,0,0,2,0}, +{"CvHistogram_thresh2_set",_wrap_CvHistogram_thresh2_set,0,0,2,0}, +{"CvHistogram_thresh2_get",_wrap_CvHistogram_thresh2_get,0,0,2,0}, +{"CvHistogram_mat_set",_wrap_CvHistogram_mat_set,0,0,2,0}, +{"CvHistogram_mat_get",_wrap_CvHistogram_mat_get,0,0,2,0}, +{"delete_CvHistogram",_wrap_delete_CvHistogram,0,0,2,_wrap_delete_CvHistogram_texinfo}, +{"CvRect_x_set",_wrap_CvRect_x_set,0,0,2,0}, +{"CvRect_x_get",_wrap_CvRect_x_get,0,0,2,0}, +{"CvRect_y_set",_wrap_CvRect_y_set,0,0,2,0}, +{"CvRect_y_get",_wrap_CvRect_y_get,0,0,2,0}, +{"CvRect_width_set",_wrap_CvRect_width_set,0,0,2,0}, +{"CvRect_width_get",_wrap_CvRect_width_get,0,0,2,0}, +{"CvRect_height_set",_wrap_CvRect_height_set,0,0,2,0}, +{"CvRect_height_get",_wrap_CvRect_height_get,0,0,2,0}, +{"new_CvRect",_wrap_new_CvRect,0,0,2,_wrap_new_CvRect_texinfo}, +{"delete_CvRect",_wrap_delete_CvRect,0,0,2,_wrap_delete_CvRect_texinfo}, +{"cvRect",_wrap_cvRect,0,0,2,_wrap_cvRect_texinfo}, +{"cvRectToROI",_wrap_cvRectToROI,0,0,2,_wrap_cvRectToROI_texinfo}, +{"cvROIToRect",_wrap_cvROIToRect,0,0,2,_wrap_cvROIToRect_texinfo}, +{"CvTermCriteria_type_set",_wrap_CvTermCriteria_type_set,0,0,2,0}, +{"CvTermCriteria_type_get",_wrap_CvTermCriteria_type_get,0,0,2,0}, +{"CvTermCriteria_max_iter_set",_wrap_CvTermCriteria_max_iter_set,0,0,2,0}, +{"CvTermCriteria_max_iter_get",_wrap_CvTermCriteria_max_iter_get,0,0,2,0}, +{"CvTermCriteria_epsilon_set",_wrap_CvTermCriteria_epsilon_set,0,0,2,0}, +{"CvTermCriteria_epsilon_get",_wrap_CvTermCriteria_epsilon_get,0,0,2,0}, +{"new_CvTermCriteria",_wrap_new_CvTermCriteria,0,0,2,_wrap_new_CvTermCriteria_texinfo}, +{"delete_CvTermCriteria",_wrap_delete_CvTermCriteria,0,0,2,_wrap_delete_CvTermCriteria_texinfo}, +{"cvTermCriteria",_wrap_cvTermCriteria,0,0,2,_wrap_cvTermCriteria_texinfo}, +{"CvPoint_x_set",_wrap_CvPoint_x_set,0,0,2,0}, +{"CvPoint_x_get",_wrap_CvPoint_x_get,0,0,2,0}, +{"CvPoint_y_set",_wrap_CvPoint_y_set,0,0,2,0}, +{"CvPoint_y_get",_wrap_CvPoint_y_get,0,0,2,0}, +{"CvPoint___str__",_wrap_CvPoint___str__,0,0,2,_wrap_CvPoint___str___texinfo}, +{"CvPoint___repr__",_wrap_CvPoint___repr__,0,0,2,_wrap_CvPoint___repr___texinfo}, +{"new_CvPoint",_wrap_new_CvPoint,0,0,2,_wrap_new_CvPoint_texinfo}, +{"delete_CvPoint",_wrap_delete_CvPoint,0,0,2,_wrap_delete_CvPoint_texinfo}, +{"cvPoint",_wrap_cvPoint,0,0,2,_wrap_cvPoint_texinfo}, +{"CvPoint2D32f_x_set",_wrap_CvPoint2D32f_x_set,0,0,2,0}, +{"CvPoint2D32f_x_get",_wrap_CvPoint2D32f_x_get,0,0,2,0}, +{"CvPoint2D32f_y_set",_wrap_CvPoint2D32f_y_set,0,0,2,0}, +{"CvPoint2D32f_y_get",_wrap_CvPoint2D32f_y_get,0,0,2,0}, +{"CvPoint2D32f___str__",_wrap_CvPoint2D32f___str__,0,0,2,_wrap_CvPoint2D32f___str___texinfo}, +{"CvPoint2D32f___repr__",_wrap_CvPoint2D32f___repr__,0,0,2,_wrap_CvPoint2D32f___repr___texinfo}, +{"new_CvPoint2D32f",_wrap_new_CvPoint2D32f,0,0,2,_wrap_new_CvPoint2D32f_texinfo}, +{"delete_CvPoint2D32f",_wrap_delete_CvPoint2D32f,0,0,2,_wrap_delete_CvPoint2D32f_texinfo}, +{"cvPoint2D32f",_wrap_cvPoint2D32f,0,0,2,_wrap_cvPoint2D32f_texinfo}, +{"cvPointTo32f",_wrap_cvPointTo32f,0,0,2,_wrap_cvPointTo32f_texinfo}, +{"cvPointFrom32f",_wrap_cvPointFrom32f,0,0,2,_wrap_cvPointFrom32f_texinfo}, +{"CvPoint3D32f_x_set",_wrap_CvPoint3D32f_x_set,0,0,2,0}, +{"CvPoint3D32f_x_get",_wrap_CvPoint3D32f_x_get,0,0,2,0}, +{"CvPoint3D32f_y_set",_wrap_CvPoint3D32f_y_set,0,0,2,0}, +{"CvPoint3D32f_y_get",_wrap_CvPoint3D32f_y_get,0,0,2,0}, +{"CvPoint3D32f_z_set",_wrap_CvPoint3D32f_z_set,0,0,2,0}, +{"CvPoint3D32f_z_get",_wrap_CvPoint3D32f_z_get,0,0,2,0}, +{"new_CvPoint3D32f",_wrap_new_CvPoint3D32f,0,0,2,_wrap_new_CvPoint3D32f_texinfo}, +{"delete_CvPoint3D32f",_wrap_delete_CvPoint3D32f,0,0,2,_wrap_delete_CvPoint3D32f_texinfo}, +{"cvPoint3D32f",_wrap_cvPoint3D32f,0,0,2,_wrap_cvPoint3D32f_texinfo}, +{"CvPoint2D64f_x_set",_wrap_CvPoint2D64f_x_set,0,0,2,0}, +{"CvPoint2D64f_x_get",_wrap_CvPoint2D64f_x_get,0,0,2,0}, +{"CvPoint2D64f_y_set",_wrap_CvPoint2D64f_y_set,0,0,2,0}, +{"CvPoint2D64f_y_get",_wrap_CvPoint2D64f_y_get,0,0,2,0}, +{"new_CvPoint2D64f",_wrap_new_CvPoint2D64f,0,0,2,_wrap_new_CvPoint2D64f_texinfo}, +{"delete_CvPoint2D64f",_wrap_delete_CvPoint2D64f,0,0,2,_wrap_delete_CvPoint2D64f_texinfo}, +{"cvPoint2D64f",_wrap_cvPoint2D64f,0,0,2,_wrap_cvPoint2D64f_texinfo}, +{"CvPoint3D64f_x_set",_wrap_CvPoint3D64f_x_set,0,0,2,0}, +{"CvPoint3D64f_x_get",_wrap_CvPoint3D64f_x_get,0,0,2,0}, +{"CvPoint3D64f_y_set",_wrap_CvPoint3D64f_y_set,0,0,2,0}, +{"CvPoint3D64f_y_get",_wrap_CvPoint3D64f_y_get,0,0,2,0}, +{"CvPoint3D64f_z_set",_wrap_CvPoint3D64f_z_set,0,0,2,0}, +{"CvPoint3D64f_z_get",_wrap_CvPoint3D64f_z_get,0,0,2,0}, +{"new_CvPoint3D64f",_wrap_new_CvPoint3D64f,0,0,2,_wrap_new_CvPoint3D64f_texinfo}, +{"delete_CvPoint3D64f",_wrap_delete_CvPoint3D64f,0,0,2,_wrap_delete_CvPoint3D64f_texinfo}, +{"cvPoint3D64f",_wrap_cvPoint3D64f,0,0,2,_wrap_cvPoint3D64f_texinfo}, +{"CvSize_width_set",_wrap_CvSize_width_set,0,0,2,0}, +{"CvSize_width_get",_wrap_CvSize_width_get,0,0,2,0}, +{"CvSize_height_set",_wrap_CvSize_height_set,0,0,2,0}, +{"CvSize_height_get",_wrap_CvSize_height_get,0,0,2,0}, +{"new_CvSize",_wrap_new_CvSize,0,0,2,_wrap_new_CvSize_texinfo}, +{"delete_CvSize",_wrap_delete_CvSize,0,0,2,_wrap_delete_CvSize_texinfo}, +{"cvSize",_wrap_cvSize,0,0,2,_wrap_cvSize_texinfo}, +{"CvSize2D32f_width_set",_wrap_CvSize2D32f_width_set,0,0,2,0}, +{"CvSize2D32f_width_get",_wrap_CvSize2D32f_width_get,0,0,2,0}, +{"CvSize2D32f_height_set",_wrap_CvSize2D32f_height_set,0,0,2,0}, +{"CvSize2D32f_height_get",_wrap_CvSize2D32f_height_get,0,0,2,0}, +{"new_CvSize2D32f",_wrap_new_CvSize2D32f,0,0,2,_wrap_new_CvSize2D32f_texinfo}, +{"delete_CvSize2D32f",_wrap_delete_CvSize2D32f,0,0,2,_wrap_delete_CvSize2D32f_texinfo}, +{"cvSize2D32f",_wrap_cvSize2D32f,0,0,2,_wrap_cvSize2D32f_texinfo}, +{"CvBox2D_center_set",_wrap_CvBox2D_center_set,0,0,2,0}, +{"CvBox2D_center_get",_wrap_CvBox2D_center_get,0,0,2,0}, +{"CvBox2D_size_set",_wrap_CvBox2D_size_set,0,0,2,0}, +{"CvBox2D_size_get",_wrap_CvBox2D_size_get,0,0,2,0}, +{"CvBox2D_angle_set",_wrap_CvBox2D_angle_set,0,0,2,0}, +{"CvBox2D_angle_get",_wrap_CvBox2D_angle_get,0,0,2,0}, +{"new_CvBox2D",_wrap_new_CvBox2D,0,0,2,_wrap_new_CvBox2D_texinfo}, +{"delete_CvBox2D",_wrap_delete_CvBox2D,0,0,2,_wrap_delete_CvBox2D_texinfo}, +{"CvLineIterator_ptr_set",_wrap_CvLineIterator_ptr_set,0,0,2,0}, +{"CvLineIterator_ptr_get",_wrap_CvLineIterator_ptr_get,0,0,2,0}, +{"CvLineIterator_err_set",_wrap_CvLineIterator_err_set,0,0,2,0}, +{"CvLineIterator_err_get",_wrap_CvLineIterator_err_get,0,0,2,0}, +{"CvLineIterator_plus_delta_set",_wrap_CvLineIterator_plus_delta_set,0,0,2,0}, +{"CvLineIterator_plus_delta_get",_wrap_CvLineIterator_plus_delta_get,0,0,2,0}, +{"CvLineIterator_minus_delta_set",_wrap_CvLineIterator_minus_delta_set,0,0,2,0}, +{"CvLineIterator_minus_delta_get",_wrap_CvLineIterator_minus_delta_get,0,0,2,0}, +{"CvLineIterator_plus_step_set",_wrap_CvLineIterator_plus_step_set,0,0,2,0}, +{"CvLineIterator_plus_step_get",_wrap_CvLineIterator_plus_step_get,0,0,2,0}, +{"CvLineIterator_minus_step_set",_wrap_CvLineIterator_minus_step_set,0,0,2,0}, +{"CvLineIterator_minus_step_get",_wrap_CvLineIterator_minus_step_get,0,0,2,0}, +{"new_CvLineIterator",_wrap_new_CvLineIterator,0,0,2,_wrap_new_CvLineIterator_texinfo}, +{"delete_CvLineIterator",_wrap_delete_CvLineIterator,0,0,2,_wrap_delete_CvLineIterator_texinfo}, +{"CvSlice_start_index_set",_wrap_CvSlice_start_index_set,0,0,2,0}, +{"CvSlice_start_index_get",_wrap_CvSlice_start_index_get,0,0,2,0}, +{"CvSlice_end_index_set",_wrap_CvSlice_end_index_set,0,0,2,0}, +{"CvSlice_end_index_get",_wrap_CvSlice_end_index_get,0,0,2,0}, +{"new_CvSlice",_wrap_new_CvSlice,0,0,2,_wrap_new_CvSlice_texinfo}, +{"delete_CvSlice",_wrap_delete_CvSlice,0,0,2,_wrap_delete_CvSlice_texinfo}, +{"cvSlice",_wrap_cvSlice,0,0,2,_wrap_cvSlice_texinfo}, +{"CvScalar_val_set",_wrap_CvScalar_val_set,0,0,2,0}, +{"CvScalar_val_get",_wrap_CvScalar_val_get,0,0,2,0}, +{"CvScalar___str__",_wrap_CvScalar___str__,0,0,2,_wrap_CvScalar___str___texinfo}, +{"CvScalar___repr__",_wrap_CvScalar___repr__,0,0,2,_wrap_CvScalar___repr___texinfo}, +{"CvScalar___getitem__",_wrap_CvScalar___getitem__,0,0,2,_wrap_CvScalar___getitem___texinfo}, +{"CvScalar___setitem__",_wrap_CvScalar___setitem__,0,0,2,_wrap_CvScalar___setitem___texinfo}, +{"new_CvScalar",_wrap_new_CvScalar,0,0,2,_wrap_new_CvScalar_texinfo}, +{"delete_CvScalar",_wrap_delete_CvScalar,0,0,2,_wrap_delete_CvScalar_texinfo}, +{"cvScalar",_wrap_cvScalar,0,0,2,_wrap_cvScalar_texinfo}, +{"cvRealScalar",_wrap_cvRealScalar,0,0,2,_wrap_cvRealScalar_texinfo}, +{"cvScalarAll",_wrap_cvScalarAll,0,0,2,_wrap_cvScalarAll_texinfo}, +{"CvMemBlock_prev_set",_wrap_CvMemBlock_prev_set,0,0,2,0}, +{"CvMemBlock_prev_get",_wrap_CvMemBlock_prev_get,0,0,2,0}, +{"CvMemBlock_next_set",_wrap_CvMemBlock_next_set,0,0,2,0}, +{"CvMemBlock_next_get",_wrap_CvMemBlock_next_get,0,0,2,0}, +{"new_CvMemBlock",_wrap_new_CvMemBlock,0,0,2,_wrap_new_CvMemBlock_texinfo}, +{"delete_CvMemBlock",_wrap_delete_CvMemBlock,0,0,2,_wrap_delete_CvMemBlock_texinfo}, +{"CvMemStorage_signature_set",_wrap_CvMemStorage_signature_set,0,0,2,0}, +{"CvMemStorage_signature_get",_wrap_CvMemStorage_signature_get,0,0,2,0}, +{"CvMemStorage_bottom_set",_wrap_CvMemStorage_bottom_set,0,0,2,0}, +{"CvMemStorage_bottom_get",_wrap_CvMemStorage_bottom_get,0,0,2,0}, +{"CvMemStorage_top_set",_wrap_CvMemStorage_top_set,0,0,2,0}, +{"CvMemStorage_top_get",_wrap_CvMemStorage_top_get,0,0,2,0}, +{"CvMemStorage_parent_set",_wrap_CvMemStorage_parent_set,0,0,2,0}, +{"CvMemStorage_parent_get",_wrap_CvMemStorage_parent_get,0,0,2,0}, +{"CvMemStorage_block_size_set",_wrap_CvMemStorage_block_size_set,0,0,2,0}, +{"CvMemStorage_block_size_get",_wrap_CvMemStorage_block_size_get,0,0,2,0}, +{"CvMemStorage_free_space_set",_wrap_CvMemStorage_free_space_set,0,0,2,0}, +{"CvMemStorage_free_space_get",_wrap_CvMemStorage_free_space_get,0,0,2,0}, +{"delete_CvMemStorage",_wrap_delete_CvMemStorage,0,0,2,_wrap_delete_CvMemStorage_texinfo}, +{"CvMemStoragePos_top_set",_wrap_CvMemStoragePos_top_set,0,0,2,0}, +{"CvMemStoragePos_top_get",_wrap_CvMemStoragePos_top_get,0,0,2,0}, +{"CvMemStoragePos_free_space_set",_wrap_CvMemStoragePos_free_space_set,0,0,2,0}, +{"CvMemStoragePos_free_space_get",_wrap_CvMemStoragePos_free_space_get,0,0,2,0}, +{"new_CvMemStoragePos",_wrap_new_CvMemStoragePos,0,0,2,_wrap_new_CvMemStoragePos_texinfo}, +{"delete_CvMemStoragePos",_wrap_delete_CvMemStoragePos,0,0,2,_wrap_delete_CvMemStoragePos_texinfo}, +{"CvSeqBlock_prev_set",_wrap_CvSeqBlock_prev_set,0,0,2,0}, +{"CvSeqBlock_prev_get",_wrap_CvSeqBlock_prev_get,0,0,2,0}, +{"CvSeqBlock_next_set",_wrap_CvSeqBlock_next_set,0,0,2,0}, +{"CvSeqBlock_next_get",_wrap_CvSeqBlock_next_get,0,0,2,0}, +{"CvSeqBlock_start_index_set",_wrap_CvSeqBlock_start_index_set,0,0,2,0}, +{"CvSeqBlock_start_index_get",_wrap_CvSeqBlock_start_index_get,0,0,2,0}, +{"CvSeqBlock_count_set",_wrap_CvSeqBlock_count_set,0,0,2,0}, +{"CvSeqBlock_count_get",_wrap_CvSeqBlock_count_get,0,0,2,0}, +{"CvSeqBlock_data_set",_wrap_CvSeqBlock_data_set,0,0,2,0}, +{"CvSeqBlock_data_get",_wrap_CvSeqBlock_data_get,0,0,2,0}, +{"new_CvSeqBlock",_wrap_new_CvSeqBlock,0,0,2,_wrap_new_CvSeqBlock_texinfo}, +{"delete_CvSeqBlock",_wrap_delete_CvSeqBlock,0,0,2,_wrap_delete_CvSeqBlock_texinfo}, +{"CvSeq_flags_set",_wrap_CvSeq_flags_set,0,0,2,0}, +{"CvSeq_flags_get",_wrap_CvSeq_flags_get,0,0,2,0}, +{"CvSeq_header_size_set",_wrap_CvSeq_header_size_set,0,0,2,0}, +{"CvSeq_header_size_get",_wrap_CvSeq_header_size_get,0,0,2,0}, +{"CvSeq_h_prev_set",_wrap_CvSeq_h_prev_set,0,0,2,0}, +{"CvSeq_h_prev_get",_wrap_CvSeq_h_prev_get,0,0,2,0}, +{"CvSeq_h_next_set",_wrap_CvSeq_h_next_set,0,0,2,0}, +{"CvSeq_h_next_get",_wrap_CvSeq_h_next_get,0,0,2,0}, +{"CvSeq_v_prev_set",_wrap_CvSeq_v_prev_set,0,0,2,0}, +{"CvSeq_v_prev_get",_wrap_CvSeq_v_prev_get,0,0,2,0}, +{"CvSeq_v_next_set",_wrap_CvSeq_v_next_set,0,0,2,0}, +{"CvSeq_v_next_get",_wrap_CvSeq_v_next_get,0,0,2,0}, +{"CvSeq_total_set",_wrap_CvSeq_total_set,0,0,2,0}, +{"CvSeq_total_get",_wrap_CvSeq_total_get,0,0,2,0}, +{"CvSeq_elem_size_set",_wrap_CvSeq_elem_size_set,0,0,2,0}, +{"CvSeq_elem_size_get",_wrap_CvSeq_elem_size_get,0,0,2,0}, +{"CvSeq_block_max_set",_wrap_CvSeq_block_max_set,0,0,2,0}, +{"CvSeq_block_max_get",_wrap_CvSeq_block_max_get,0,0,2,0}, +{"CvSeq_ptr_set",_wrap_CvSeq_ptr_set,0,0,2,0}, +{"CvSeq_ptr_get",_wrap_CvSeq_ptr_get,0,0,2,0}, +{"CvSeq_delta_elems_set",_wrap_CvSeq_delta_elems_set,0,0,2,0}, +{"CvSeq_delta_elems_get",_wrap_CvSeq_delta_elems_get,0,0,2,0}, +{"CvSeq_storage_set",_wrap_CvSeq_storage_set,0,0,2,0}, +{"CvSeq_storage_get",_wrap_CvSeq_storage_get,0,0,2,0}, +{"CvSeq_free_blocks_set",_wrap_CvSeq_free_blocks_set,0,0,2,0}, +{"CvSeq_free_blocks_get",_wrap_CvSeq_free_blocks_get,0,0,2,0}, +{"CvSeq_first_set",_wrap_CvSeq_first_set,0,0,2,0}, +{"CvSeq_first_get",_wrap_CvSeq_first_get,0,0,2,0}, +{"new_CvSeq",_wrap_new_CvSeq,0,0,2,_wrap_new_CvSeq_texinfo}, +{"delete_CvSeq",_wrap_delete_CvSeq,0,0,2,_wrap_delete_CvSeq_texinfo}, +{"CvSetElem_flags_set",_wrap_CvSetElem_flags_set,0,0,2,0}, +{"CvSetElem_flags_get",_wrap_CvSetElem_flags_get,0,0,2,0}, +{"CvSetElem_next_free_set",_wrap_CvSetElem_next_free_set,0,0,2,0}, +{"CvSetElem_next_free_get",_wrap_CvSetElem_next_free_get,0,0,2,0}, +{"new_CvSetElem",_wrap_new_CvSetElem,0,0,2,_wrap_new_CvSetElem_texinfo}, +{"delete_CvSetElem",_wrap_delete_CvSetElem,0,0,2,_wrap_delete_CvSetElem_texinfo}, +{"CvSet_flags_set",_wrap_CvSet_flags_set,0,0,2,0}, +{"CvSet_flags_get",_wrap_CvSet_flags_get,0,0,2,0}, +{"CvSet_header_size_set",_wrap_CvSet_header_size_set,0,0,2,0}, +{"CvSet_header_size_get",_wrap_CvSet_header_size_get,0,0,2,0}, +{"CvSet_h_prev_set",_wrap_CvSet_h_prev_set,0,0,2,0}, +{"CvSet_h_prev_get",_wrap_CvSet_h_prev_get,0,0,2,0}, +{"CvSet_h_next_set",_wrap_CvSet_h_next_set,0,0,2,0}, +{"CvSet_h_next_get",_wrap_CvSet_h_next_get,0,0,2,0}, +{"CvSet_v_prev_set",_wrap_CvSet_v_prev_set,0,0,2,0}, +{"CvSet_v_prev_get",_wrap_CvSet_v_prev_get,0,0,2,0}, +{"CvSet_v_next_set",_wrap_CvSet_v_next_set,0,0,2,0}, +{"CvSet_v_next_get",_wrap_CvSet_v_next_get,0,0,2,0}, +{"CvSet_total_set",_wrap_CvSet_total_set,0,0,2,0}, +{"CvSet_total_get",_wrap_CvSet_total_get,0,0,2,0}, +{"CvSet_elem_size_set",_wrap_CvSet_elem_size_set,0,0,2,0}, +{"CvSet_elem_size_get",_wrap_CvSet_elem_size_get,0,0,2,0}, +{"CvSet_block_max_set",_wrap_CvSet_block_max_set,0,0,2,0}, +{"CvSet_block_max_get",_wrap_CvSet_block_max_get,0,0,2,0}, +{"CvSet_ptr_set",_wrap_CvSet_ptr_set,0,0,2,0}, +{"CvSet_ptr_get",_wrap_CvSet_ptr_get,0,0,2,0}, +{"CvSet_delta_elems_set",_wrap_CvSet_delta_elems_set,0,0,2,0}, +{"CvSet_delta_elems_get",_wrap_CvSet_delta_elems_get,0,0,2,0}, +{"CvSet_storage_set",_wrap_CvSet_storage_set,0,0,2,0}, +{"CvSet_storage_get",_wrap_CvSet_storage_get,0,0,2,0}, +{"CvSet_free_blocks_set",_wrap_CvSet_free_blocks_set,0,0,2,0}, +{"CvSet_free_blocks_get",_wrap_CvSet_free_blocks_get,0,0,2,0}, +{"CvSet_first_set",_wrap_CvSet_first_set,0,0,2,0}, +{"CvSet_first_get",_wrap_CvSet_first_get,0,0,2,0}, +{"CvSet_free_elems_set",_wrap_CvSet_free_elems_set,0,0,2,0}, +{"CvSet_free_elems_get",_wrap_CvSet_free_elems_get,0,0,2,0}, +{"CvSet_active_count_set",_wrap_CvSet_active_count_set,0,0,2,0}, +{"CvSet_active_count_get",_wrap_CvSet_active_count_get,0,0,2,0}, +{"new_CvSet",_wrap_new_CvSet,0,0,2,_wrap_new_CvSet_texinfo}, +{"delete_CvSet",_wrap_delete_CvSet,0,0,2,_wrap_delete_CvSet_texinfo}, +{"CvGraphEdge_flags_set",_wrap_CvGraphEdge_flags_set,0,0,2,0}, +{"CvGraphEdge_flags_get",_wrap_CvGraphEdge_flags_get,0,0,2,0}, +{"CvGraphEdge_weight_set",_wrap_CvGraphEdge_weight_set,0,0,2,0}, +{"CvGraphEdge_weight_get",_wrap_CvGraphEdge_weight_get,0,0,2,0}, +{"CvGraphEdge_next_set",_wrap_CvGraphEdge_next_set,0,0,2,0}, +{"CvGraphEdge_next_get",_wrap_CvGraphEdge_next_get,0,0,2,0}, +{"CvGraphEdge_vtx_set",_wrap_CvGraphEdge_vtx_set,0,0,2,0}, +{"CvGraphEdge_vtx_get",_wrap_CvGraphEdge_vtx_get,0,0,2,0}, +{"new_CvGraphEdge",_wrap_new_CvGraphEdge,0,0,2,_wrap_new_CvGraphEdge_texinfo}, +{"delete_CvGraphEdge",_wrap_delete_CvGraphEdge,0,0,2,_wrap_delete_CvGraphEdge_texinfo}, +{"CvGraphVtx_flags_set",_wrap_CvGraphVtx_flags_set,0,0,2,0}, +{"CvGraphVtx_flags_get",_wrap_CvGraphVtx_flags_get,0,0,2,0}, +{"CvGraphVtx_first_set",_wrap_CvGraphVtx_first_set,0,0,2,0}, +{"CvGraphVtx_first_get",_wrap_CvGraphVtx_first_get,0,0,2,0}, +{"new_CvGraphVtx",_wrap_new_CvGraphVtx,0,0,2,_wrap_new_CvGraphVtx_texinfo}, +{"delete_CvGraphVtx",_wrap_delete_CvGraphVtx,0,0,2,_wrap_delete_CvGraphVtx_texinfo}, +{"CvGraphVtx2D_flags_set",_wrap_CvGraphVtx2D_flags_set,0,0,2,0}, +{"CvGraphVtx2D_flags_get",_wrap_CvGraphVtx2D_flags_get,0,0,2,0}, +{"CvGraphVtx2D_first_set",_wrap_CvGraphVtx2D_first_set,0,0,2,0}, +{"CvGraphVtx2D_first_get",_wrap_CvGraphVtx2D_first_get,0,0,2,0}, +{"CvGraphVtx2D_ptr_set",_wrap_CvGraphVtx2D_ptr_set,0,0,2,0}, +{"CvGraphVtx2D_ptr_get",_wrap_CvGraphVtx2D_ptr_get,0,0,2,0}, +{"new_CvGraphVtx2D",_wrap_new_CvGraphVtx2D,0,0,2,_wrap_new_CvGraphVtx2D_texinfo}, +{"delete_CvGraphVtx2D",_wrap_delete_CvGraphVtx2D,0,0,2,_wrap_delete_CvGraphVtx2D_texinfo}, +{"CvGraph_flags_set",_wrap_CvGraph_flags_set,0,0,2,0}, +{"CvGraph_flags_get",_wrap_CvGraph_flags_get,0,0,2,0}, +{"CvGraph_header_size_set",_wrap_CvGraph_header_size_set,0,0,2,0}, +{"CvGraph_header_size_get",_wrap_CvGraph_header_size_get,0,0,2,0}, +{"CvGraph_h_prev_set",_wrap_CvGraph_h_prev_set,0,0,2,0}, +{"CvGraph_h_prev_get",_wrap_CvGraph_h_prev_get,0,0,2,0}, +{"CvGraph_h_next_set",_wrap_CvGraph_h_next_set,0,0,2,0}, +{"CvGraph_h_next_get",_wrap_CvGraph_h_next_get,0,0,2,0}, +{"CvGraph_v_prev_set",_wrap_CvGraph_v_prev_set,0,0,2,0}, +{"CvGraph_v_prev_get",_wrap_CvGraph_v_prev_get,0,0,2,0}, +{"CvGraph_v_next_set",_wrap_CvGraph_v_next_set,0,0,2,0}, +{"CvGraph_v_next_get",_wrap_CvGraph_v_next_get,0,0,2,0}, +{"CvGraph_total_set",_wrap_CvGraph_total_set,0,0,2,0}, +{"CvGraph_total_get",_wrap_CvGraph_total_get,0,0,2,0}, +{"CvGraph_elem_size_set",_wrap_CvGraph_elem_size_set,0,0,2,0}, +{"CvGraph_elem_size_get",_wrap_CvGraph_elem_size_get,0,0,2,0}, +{"CvGraph_block_max_set",_wrap_CvGraph_block_max_set,0,0,2,0}, +{"CvGraph_block_max_get",_wrap_CvGraph_block_max_get,0,0,2,0}, +{"CvGraph_ptr_set",_wrap_CvGraph_ptr_set,0,0,2,0}, +{"CvGraph_ptr_get",_wrap_CvGraph_ptr_get,0,0,2,0}, +{"CvGraph_delta_elems_set",_wrap_CvGraph_delta_elems_set,0,0,2,0}, +{"CvGraph_delta_elems_get",_wrap_CvGraph_delta_elems_get,0,0,2,0}, +{"CvGraph_storage_set",_wrap_CvGraph_storage_set,0,0,2,0}, +{"CvGraph_storage_get",_wrap_CvGraph_storage_get,0,0,2,0}, +{"CvGraph_free_blocks_set",_wrap_CvGraph_free_blocks_set,0,0,2,0}, +{"CvGraph_free_blocks_get",_wrap_CvGraph_free_blocks_get,0,0,2,0}, +{"CvGraph_first_set",_wrap_CvGraph_first_set,0,0,2,0}, +{"CvGraph_first_get",_wrap_CvGraph_first_get,0,0,2,0}, +{"CvGraph_free_elems_set",_wrap_CvGraph_free_elems_set,0,0,2,0}, +{"CvGraph_free_elems_get",_wrap_CvGraph_free_elems_get,0,0,2,0}, +{"CvGraph_active_count_set",_wrap_CvGraph_active_count_set,0,0,2,0}, +{"CvGraph_active_count_get",_wrap_CvGraph_active_count_get,0,0,2,0}, +{"CvGraph_edges_set",_wrap_CvGraph_edges_set,0,0,2,0}, +{"CvGraph_edges_get",_wrap_CvGraph_edges_get,0,0,2,0}, +{"new_CvGraph",_wrap_new_CvGraph,0,0,2,_wrap_new_CvGraph_texinfo}, +{"delete_CvGraph",_wrap_delete_CvGraph,0,0,2,_wrap_delete_CvGraph_texinfo}, +{"CvChain_flags_set",_wrap_CvChain_flags_set,0,0,2,0}, +{"CvChain_flags_get",_wrap_CvChain_flags_get,0,0,2,0}, +{"CvChain_header_size_set",_wrap_CvChain_header_size_set,0,0,2,0}, +{"CvChain_header_size_get",_wrap_CvChain_header_size_get,0,0,2,0}, +{"CvChain_h_prev_set",_wrap_CvChain_h_prev_set,0,0,2,0}, +{"CvChain_h_prev_get",_wrap_CvChain_h_prev_get,0,0,2,0}, +{"CvChain_h_next_set",_wrap_CvChain_h_next_set,0,0,2,0}, +{"CvChain_h_next_get",_wrap_CvChain_h_next_get,0,0,2,0}, +{"CvChain_v_prev_set",_wrap_CvChain_v_prev_set,0,0,2,0}, +{"CvChain_v_prev_get",_wrap_CvChain_v_prev_get,0,0,2,0}, +{"CvChain_v_next_set",_wrap_CvChain_v_next_set,0,0,2,0}, +{"CvChain_v_next_get",_wrap_CvChain_v_next_get,0,0,2,0}, +{"CvChain_total_set",_wrap_CvChain_total_set,0,0,2,0}, +{"CvChain_total_get",_wrap_CvChain_total_get,0,0,2,0}, +{"CvChain_elem_size_set",_wrap_CvChain_elem_size_set,0,0,2,0}, +{"CvChain_elem_size_get",_wrap_CvChain_elem_size_get,0,0,2,0}, +{"CvChain_block_max_set",_wrap_CvChain_block_max_set,0,0,2,0}, +{"CvChain_block_max_get",_wrap_CvChain_block_max_get,0,0,2,0}, +{"CvChain_ptr_set",_wrap_CvChain_ptr_set,0,0,2,0}, +{"CvChain_ptr_get",_wrap_CvChain_ptr_get,0,0,2,0}, +{"CvChain_delta_elems_set",_wrap_CvChain_delta_elems_set,0,0,2,0}, +{"CvChain_delta_elems_get",_wrap_CvChain_delta_elems_get,0,0,2,0}, +{"CvChain_storage_set",_wrap_CvChain_storage_set,0,0,2,0}, +{"CvChain_storage_get",_wrap_CvChain_storage_get,0,0,2,0}, +{"CvChain_free_blocks_set",_wrap_CvChain_free_blocks_set,0,0,2,0}, +{"CvChain_free_blocks_get",_wrap_CvChain_free_blocks_get,0,0,2,0}, +{"CvChain_first_set",_wrap_CvChain_first_set,0,0,2,0}, +{"CvChain_first_get",_wrap_CvChain_first_get,0,0,2,0}, +{"CvChain_origin_set",_wrap_CvChain_origin_set,0,0,2,0}, +{"CvChain_origin_get",_wrap_CvChain_origin_get,0,0,2,0}, +{"new_CvChain",_wrap_new_CvChain,0,0,2,_wrap_new_CvChain_texinfo}, +{"delete_CvChain",_wrap_delete_CvChain,0,0,2,_wrap_delete_CvChain_texinfo}, +{"CvContour_flags_set",_wrap_CvContour_flags_set,0,0,2,0}, +{"CvContour_flags_get",_wrap_CvContour_flags_get,0,0,2,0}, +{"CvContour_header_size_set",_wrap_CvContour_header_size_set,0,0,2,0}, +{"CvContour_header_size_get",_wrap_CvContour_header_size_get,0,0,2,0}, +{"CvContour_h_prev_set",_wrap_CvContour_h_prev_set,0,0,2,0}, +{"CvContour_h_prev_get",_wrap_CvContour_h_prev_get,0,0,2,0}, +{"CvContour_h_next_set",_wrap_CvContour_h_next_set,0,0,2,0}, +{"CvContour_h_next_get",_wrap_CvContour_h_next_get,0,0,2,0}, +{"CvContour_v_prev_set",_wrap_CvContour_v_prev_set,0,0,2,0}, +{"CvContour_v_prev_get",_wrap_CvContour_v_prev_get,0,0,2,0}, +{"CvContour_v_next_set",_wrap_CvContour_v_next_set,0,0,2,0}, +{"CvContour_v_next_get",_wrap_CvContour_v_next_get,0,0,2,0}, +{"CvContour_total_set",_wrap_CvContour_total_set,0,0,2,0}, +{"CvContour_total_get",_wrap_CvContour_total_get,0,0,2,0}, +{"CvContour_elem_size_set",_wrap_CvContour_elem_size_set,0,0,2,0}, +{"CvContour_elem_size_get",_wrap_CvContour_elem_size_get,0,0,2,0}, +{"CvContour_block_max_set",_wrap_CvContour_block_max_set,0,0,2,0}, +{"CvContour_block_max_get",_wrap_CvContour_block_max_get,0,0,2,0}, +{"CvContour_ptr_set",_wrap_CvContour_ptr_set,0,0,2,0}, +{"CvContour_ptr_get",_wrap_CvContour_ptr_get,0,0,2,0}, +{"CvContour_delta_elems_set",_wrap_CvContour_delta_elems_set,0,0,2,0}, +{"CvContour_delta_elems_get",_wrap_CvContour_delta_elems_get,0,0,2,0}, +{"CvContour_storage_set",_wrap_CvContour_storage_set,0,0,2,0}, +{"CvContour_storage_get",_wrap_CvContour_storage_get,0,0,2,0}, +{"CvContour_free_blocks_set",_wrap_CvContour_free_blocks_set,0,0,2,0}, +{"CvContour_free_blocks_get",_wrap_CvContour_free_blocks_get,0,0,2,0}, +{"CvContour_first_set",_wrap_CvContour_first_set,0,0,2,0}, +{"CvContour_first_get",_wrap_CvContour_first_get,0,0,2,0}, +{"CvContour_rect_set",_wrap_CvContour_rect_set,0,0,2,0}, +{"CvContour_rect_get",_wrap_CvContour_rect_get,0,0,2,0}, +{"CvContour_color_set",_wrap_CvContour_color_set,0,0,2,0}, +{"CvContour_color_get",_wrap_CvContour_color_get,0,0,2,0}, +{"CvContour_reserved_set",_wrap_CvContour_reserved_set,0,0,2,0}, +{"CvContour_reserved_get",_wrap_CvContour_reserved_get,0,0,2,0}, +{"new_CvContour",_wrap_new_CvContour,0,0,2,_wrap_new_CvContour_texinfo}, +{"delete_CvContour",_wrap_delete_CvContour,0,0,2,_wrap_delete_CvContour_texinfo}, +{"CvSeqWriter_header_size_set",_wrap_CvSeqWriter_header_size_set,0,0,2,0}, +{"CvSeqWriter_header_size_get",_wrap_CvSeqWriter_header_size_get,0,0,2,0}, +{"CvSeqWriter_seq_set",_wrap_CvSeqWriter_seq_set,0,0,2,0}, +{"CvSeqWriter_seq_get",_wrap_CvSeqWriter_seq_get,0,0,2,0}, +{"CvSeqWriter_block_set",_wrap_CvSeqWriter_block_set,0,0,2,0}, +{"CvSeqWriter_block_get",_wrap_CvSeqWriter_block_get,0,0,2,0}, +{"CvSeqWriter_ptr_set",_wrap_CvSeqWriter_ptr_set,0,0,2,0}, +{"CvSeqWriter_ptr_get",_wrap_CvSeqWriter_ptr_get,0,0,2,0}, +{"CvSeqWriter_block_min_set",_wrap_CvSeqWriter_block_min_set,0,0,2,0}, +{"CvSeqWriter_block_min_get",_wrap_CvSeqWriter_block_min_get,0,0,2,0}, +{"CvSeqWriter_block_max_set",_wrap_CvSeqWriter_block_max_set,0,0,2,0}, +{"CvSeqWriter_block_max_get",_wrap_CvSeqWriter_block_max_get,0,0,2,0}, +{"new_CvSeqWriter",_wrap_new_CvSeqWriter,0,0,2,_wrap_new_CvSeqWriter_texinfo}, +{"delete_CvSeqWriter",_wrap_delete_CvSeqWriter,0,0,2,_wrap_delete_CvSeqWriter_texinfo}, +{"CvSeqReader_header_size_set",_wrap_CvSeqReader_header_size_set,0,0,2,0}, +{"CvSeqReader_header_size_get",_wrap_CvSeqReader_header_size_get,0,0,2,0}, +{"CvSeqReader_seq_set",_wrap_CvSeqReader_seq_set,0,0,2,0}, +{"CvSeqReader_seq_get",_wrap_CvSeqReader_seq_get,0,0,2,0}, +{"CvSeqReader_block_set",_wrap_CvSeqReader_block_set,0,0,2,0}, +{"CvSeqReader_block_get",_wrap_CvSeqReader_block_get,0,0,2,0}, +{"CvSeqReader_ptr_set",_wrap_CvSeqReader_ptr_set,0,0,2,0}, +{"CvSeqReader_ptr_get",_wrap_CvSeqReader_ptr_get,0,0,2,0}, +{"CvSeqReader_block_min_set",_wrap_CvSeqReader_block_min_set,0,0,2,0}, +{"CvSeqReader_block_min_get",_wrap_CvSeqReader_block_min_get,0,0,2,0}, +{"CvSeqReader_block_max_set",_wrap_CvSeqReader_block_max_set,0,0,2,0}, +{"CvSeqReader_block_max_get",_wrap_CvSeqReader_block_max_get,0,0,2,0}, +{"CvSeqReader_delta_index_set",_wrap_CvSeqReader_delta_index_set,0,0,2,0}, +{"CvSeqReader_delta_index_get",_wrap_CvSeqReader_delta_index_get,0,0,2,0}, +{"CvSeqReader_prev_elem_set",_wrap_CvSeqReader_prev_elem_set,0,0,2,0}, +{"CvSeqReader_prev_elem_get",_wrap_CvSeqReader_prev_elem_get,0,0,2,0}, +{"new_CvSeqReader",_wrap_new_CvSeqReader,0,0,2,_wrap_new_CvSeqReader_texinfo}, +{"delete_CvSeqReader",_wrap_delete_CvSeqReader,0,0,2,_wrap_delete_CvSeqReader_texinfo}, +{"CvAttrList_attr_set",_wrap_CvAttrList_attr_set,0,0,2,0}, +{"CvAttrList_attr_get",_wrap_CvAttrList_attr_get,0,0,2,0}, +{"CvAttrList_next_set",_wrap_CvAttrList_next_set,0,0,2,0}, +{"CvAttrList_next_get",_wrap_CvAttrList_next_get,0,0,2,0}, +{"new_CvAttrList",_wrap_new_CvAttrList,0,0,2,_wrap_new_CvAttrList_texinfo}, +{"delete_CvAttrList",_wrap_delete_CvAttrList,0,0,2,_wrap_delete_CvAttrList_texinfo}, +{"cvAttrList",_wrap_cvAttrList,0,0,2,_wrap_cvAttrList_texinfo}, +{"CvString_len_set",_wrap_CvString_len_set,0,0,2,0}, +{"CvString_len_get",_wrap_CvString_len_get,0,0,2,0}, +{"CvString_ptr_set",_wrap_CvString_ptr_set,0,0,2,0}, +{"CvString_ptr_get",_wrap_CvString_ptr_get,0,0,2,0}, +{"new_CvString",_wrap_new_CvString,0,0,2,_wrap_new_CvString_texinfo}, +{"delete_CvString",_wrap_delete_CvString,0,0,2,_wrap_delete_CvString_texinfo}, +{"CvStringHashNode_hashval_set",_wrap_CvStringHashNode_hashval_set,0,0,2,0}, +{"CvStringHashNode_hashval_get",_wrap_CvStringHashNode_hashval_get,0,0,2,0}, +{"CvStringHashNode_str_set",_wrap_CvStringHashNode_str_set,0,0,2,0}, +{"CvStringHashNode_str_get",_wrap_CvStringHashNode_str_get,0,0,2,0}, +{"CvStringHashNode_next_set",_wrap_CvStringHashNode_next_set,0,0,2,0}, +{"CvStringHashNode_next_get",_wrap_CvStringHashNode_next_get,0,0,2,0}, +{"new_CvStringHashNode",_wrap_new_CvStringHashNode,0,0,2,_wrap_new_CvStringHashNode_texinfo}, +{"delete_CvStringHashNode",_wrap_delete_CvStringHashNode,0,0,2,_wrap_delete_CvStringHashNode_texinfo}, +{"CvFileNode_tag_set",_wrap_CvFileNode_tag_set,0,0,2,0}, +{"CvFileNode_tag_get",_wrap_CvFileNode_tag_get,0,0,2,0}, +{"CvFileNode_info_set",_wrap_CvFileNode_info_set,0,0,2,0}, +{"CvFileNode_info_get",_wrap_CvFileNode_info_get,0,0,2,0}, +{"CvFileNode_data_get",_wrap_CvFileNode_data_get,0,0,2,0}, +{"new_CvFileNode",_wrap_new_CvFileNode,0,0,2,_wrap_new_CvFileNode_texinfo}, +{"delete_CvFileNode",_wrap_delete_CvFileNode,0,0,2,_wrap_delete_CvFileNode_texinfo}, +{"CvFileNode_data_f_set",_wrap_CvFileNode_data_f_set,0,0,2,0}, +{"CvFileNode_data_f_get",_wrap_CvFileNode_data_f_get,0,0,2,0}, +{"CvFileNode_data_i_set",_wrap_CvFileNode_data_i_set,0,0,2,0}, +{"CvFileNode_data_i_get",_wrap_CvFileNode_data_i_get,0,0,2,0}, +{"CvFileNode_data_str_set",_wrap_CvFileNode_data_str_set,0,0,2,0}, +{"CvFileNode_data_str_get",_wrap_CvFileNode_data_str_get,0,0,2,0}, +{"CvFileNode_data_seq_set",_wrap_CvFileNode_data_seq_set,0,0,2,0}, +{"CvFileNode_data_seq_get",_wrap_CvFileNode_data_seq_get,0,0,2,0}, +{"CvFileNode_data_map_set",_wrap_CvFileNode_data_map_set,0,0,2,0}, +{"CvFileNode_data_map_get",_wrap_CvFileNode_data_map_get,0,0,2,0}, +{"new_CvFileNode_data",_wrap_new_CvFileNode_data,0,0,2,_wrap_new_CvFileNode_data_texinfo}, +{"delete_CvFileNode_data",_wrap_delete_CvFileNode_data,0,0,2,_wrap_delete_CvFileNode_data_texinfo}, +{"CvTypeInfo_flags_set",_wrap_CvTypeInfo_flags_set,0,0,2,0}, +{"CvTypeInfo_flags_get",_wrap_CvTypeInfo_flags_get,0,0,2,0}, +{"CvTypeInfo_header_size_set",_wrap_CvTypeInfo_header_size_set,0,0,2,0}, +{"CvTypeInfo_header_size_get",_wrap_CvTypeInfo_header_size_get,0,0,2,0}, +{"CvTypeInfo_prev_set",_wrap_CvTypeInfo_prev_set,0,0,2,0}, +{"CvTypeInfo_prev_get",_wrap_CvTypeInfo_prev_get,0,0,2,0}, +{"CvTypeInfo_next_set",_wrap_CvTypeInfo_next_set,0,0,2,0}, +{"CvTypeInfo_next_get",_wrap_CvTypeInfo_next_get,0,0,2,0}, +{"CvTypeInfo_type_name_set",_wrap_CvTypeInfo_type_name_set,0,0,2,0}, +{"CvTypeInfo_type_name_get",_wrap_CvTypeInfo_type_name_get,0,0,2,0}, +{"CvTypeInfo_is_instance_set",_wrap_CvTypeInfo_is_instance_set,0,0,2,0}, +{"CvTypeInfo_is_instance_get",_wrap_CvTypeInfo_is_instance_get,0,0,2,0}, +{"CvTypeInfo_release_set",_wrap_CvTypeInfo_release_set,0,0,2,0}, +{"CvTypeInfo_release_get",_wrap_CvTypeInfo_release_get,0,0,2,0}, +{"CvTypeInfo_read_set",_wrap_CvTypeInfo_read_set,0,0,2,0}, +{"CvTypeInfo_read_get",_wrap_CvTypeInfo_read_get,0,0,2,0}, +{"CvTypeInfo_write_set",_wrap_CvTypeInfo_write_set,0,0,2,0}, +{"CvTypeInfo_write_get",_wrap_CvTypeInfo_write_get,0,0,2,0}, +{"CvTypeInfo_clone_set",_wrap_CvTypeInfo_clone_set,0,0,2,0}, +{"CvTypeInfo_clone_get",_wrap_CvTypeInfo_clone_get,0,0,2,0}, +{"new_CvTypeInfo",_wrap_new_CvTypeInfo,0,0,2,_wrap_new_CvTypeInfo_texinfo}, +{"delete_CvTypeInfo",_wrap_delete_CvTypeInfo,0,0,2,_wrap_delete_CvTypeInfo_texinfo}, +{"CvPluginFuncInfo_func_addr_set",_wrap_CvPluginFuncInfo_func_addr_set,0,0,2,0}, +{"CvPluginFuncInfo_func_addr_get",_wrap_CvPluginFuncInfo_func_addr_get,0,0,2,0}, +{"CvPluginFuncInfo_default_func_addr_set",_wrap_CvPluginFuncInfo_default_func_addr_set,0,0,2,0}, +{"CvPluginFuncInfo_default_func_addr_get",_wrap_CvPluginFuncInfo_default_func_addr_get,0,0,2,0}, +{"CvPluginFuncInfo_func_names_set",_wrap_CvPluginFuncInfo_func_names_set,0,0,2,0}, +{"CvPluginFuncInfo_func_names_get",_wrap_CvPluginFuncInfo_func_names_get,0,0,2,0}, +{"CvPluginFuncInfo_search_modules_set",_wrap_CvPluginFuncInfo_search_modules_set,0,0,2,0}, +{"CvPluginFuncInfo_search_modules_get",_wrap_CvPluginFuncInfo_search_modules_get,0,0,2,0}, +{"CvPluginFuncInfo_loaded_from_set",_wrap_CvPluginFuncInfo_loaded_from_set,0,0,2,0}, +{"CvPluginFuncInfo_loaded_from_get",_wrap_CvPluginFuncInfo_loaded_from_get,0,0,2,0}, +{"new_CvPluginFuncInfo",_wrap_new_CvPluginFuncInfo,0,0,2,_wrap_new_CvPluginFuncInfo_texinfo}, +{"delete_CvPluginFuncInfo",_wrap_delete_CvPluginFuncInfo,0,0,2,_wrap_delete_CvPluginFuncInfo_texinfo}, +{"CvModuleInfo_next_set",_wrap_CvModuleInfo_next_set,0,0,2,0}, +{"CvModuleInfo_next_get",_wrap_CvModuleInfo_next_get,0,0,2,0}, +{"CvModuleInfo_name_set",_wrap_CvModuleInfo_name_set,0,0,2,0}, +{"CvModuleInfo_name_get",_wrap_CvModuleInfo_name_get,0,0,2,0}, +{"CvModuleInfo_version_set",_wrap_CvModuleInfo_version_set,0,0,2,0}, +{"CvModuleInfo_version_get",_wrap_CvModuleInfo_version_get,0,0,2,0}, +{"CvModuleInfo_func_tab_set",_wrap_CvModuleInfo_func_tab_set,0,0,2,0}, +{"CvModuleInfo_func_tab_get",_wrap_CvModuleInfo_func_tab_get,0,0,2,0}, +{"new_CvModuleInfo",_wrap_new_CvModuleInfo,0,0,2,_wrap_new_CvModuleInfo_texinfo}, +{"delete_CvModuleInfo",_wrap_delete_CvModuleInfo,0,0,2,_wrap_delete_CvModuleInfo_texinfo}, +{"cvAlloc",_wrap_cvAlloc,0,0,2,_wrap_cvAlloc_texinfo}, +{"cvFree_",_wrap_cvFree_,0,0,2,_wrap_cvFree__texinfo}, +{"cvReleaseImageHeader",_wrap_cvReleaseImageHeader,0,0,2,_wrap_cvReleaseImageHeader_texinfo}, +{"cvReleaseImage",_wrap_cvReleaseImage,0,0,2,_wrap_cvReleaseImage_texinfo}, +{"cvResetImageROI",_wrap_cvResetImageROI,0,0,2,_wrap_cvResetImageROI_texinfo}, +{"cvCreateMatHeader",_wrap_cvCreateMatHeader,0,0,2,_wrap_cvCreateMatHeader_texinfo}, +{"cvInitMatHeader",_wrap_cvInitMatHeader,0,0,2,_wrap_cvInitMatHeader_texinfo}, +{"cvCreateMat",_wrap_cvCreateMat,0,0,2,_wrap_cvCreateMat_texinfo}, +{"cvReleaseMat",_wrap_cvReleaseMat,0,0,2,_wrap_cvReleaseMat_texinfo}, +{"cvDecRefData",_wrap_cvDecRefData,0,0,2,_wrap_cvDecRefData_texinfo}, +{"cvIncRefData",_wrap_cvIncRefData,0,0,2,_wrap_cvIncRefData_texinfo}, +{"cvCloneMat",_wrap_cvCloneMat,0,0,2,_wrap_cvCloneMat_texinfo}, +{"cvGetSubRect",_wrap_cvGetSubRect,0,0,2,_wrap_cvGetSubRect_texinfo}, +{"cvGetRows",_wrap_cvGetRows,0,0,2,_wrap_cvGetRows_texinfo}, +{"cvGetRow",_wrap_cvGetRow,0,0,2,_wrap_cvGetRow_texinfo}, +{"cvGetCols",_wrap_cvGetCols,0,0,2,_wrap_cvGetCols_texinfo}, +{"cvGetCol",_wrap_cvGetCol,0,0,2,_wrap_cvGetCol_texinfo}, +{"cvGetDiag",_wrap_cvGetDiag,0,0,2,_wrap_cvGetDiag_texinfo}, +{"cvScalarToRawData",_wrap_cvScalarToRawData,0,0,2,_wrap_cvScalarToRawData_texinfo}, +{"cvRawDataToScalar",_wrap_cvRawDataToScalar,0,0,2,_wrap_cvRawDataToScalar_texinfo}, +{"cvCreateMatNDHeader",_wrap_cvCreateMatNDHeader,0,0,2,_wrap_cvCreateMatNDHeader_texinfo}, +{"cvCreateMatND",_wrap_cvCreateMatND,0,0,2,_wrap_cvCreateMatND_texinfo}, +{"cvInitMatNDHeader",_wrap_cvInitMatNDHeader,0,0,2,_wrap_cvInitMatNDHeader_texinfo}, +{"cvReleaseMatND",_wrap_cvReleaseMatND,0,0,2,_wrap_cvReleaseMatND_texinfo}, +{"cvCloneMatND",_wrap_cvCloneMatND,0,0,2,_wrap_cvCloneMatND_texinfo}, +{"cvCreateSparseMat",_wrap_cvCreateSparseMat,0,0,2,_wrap_cvCreateSparseMat_texinfo}, +{"cvReleaseSparseMat",_wrap_cvReleaseSparseMat,0,0,2,_wrap_cvReleaseSparseMat_texinfo}, +{"cvCloneSparseMat",_wrap_cvCloneSparseMat,0,0,2,_wrap_cvCloneSparseMat_texinfo}, +{"cvInitSparseMatIterator",_wrap_cvInitSparseMatIterator,0,0,2,_wrap_cvInitSparseMatIterator_texinfo}, +{"cvGetNextSparseNode",_wrap_cvGetNextSparseNode,0,0,2,_wrap_cvGetNextSparseNode_texinfo}, +{"CvNArrayIterator_count_set",_wrap_CvNArrayIterator_count_set,0,0,2,0}, +{"CvNArrayIterator_count_get",_wrap_CvNArrayIterator_count_get,0,0,2,0}, +{"CvNArrayIterator_dims_set",_wrap_CvNArrayIterator_dims_set,0,0,2,0}, +{"CvNArrayIterator_dims_get",_wrap_CvNArrayIterator_dims_get,0,0,2,0}, +{"CvNArrayIterator_size_set",_wrap_CvNArrayIterator_size_set,0,0,2,0}, +{"CvNArrayIterator_size_get",_wrap_CvNArrayIterator_size_get,0,0,2,0}, +{"CvNArrayIterator_ptr_set",_wrap_CvNArrayIterator_ptr_set,0,0,2,0}, +{"CvNArrayIterator_ptr_get",_wrap_CvNArrayIterator_ptr_get,0,0,2,0}, +{"CvNArrayIterator_stack_set",_wrap_CvNArrayIterator_stack_set,0,0,2,0}, +{"CvNArrayIterator_stack_get",_wrap_CvNArrayIterator_stack_get,0,0,2,0}, +{"CvNArrayIterator_hdr_set",_wrap_CvNArrayIterator_hdr_set,0,0,2,0}, +{"CvNArrayIterator_hdr_get",_wrap_CvNArrayIterator_hdr_get,0,0,2,0}, +{"new_CvNArrayIterator",_wrap_new_CvNArrayIterator,0,0,2,_wrap_new_CvNArrayIterator_texinfo}, +{"delete_CvNArrayIterator",_wrap_delete_CvNArrayIterator,0,0,2,_wrap_delete_CvNArrayIterator_texinfo}, +{"cvInitNArrayIterator",_wrap_cvInitNArrayIterator,0,0,2,_wrap_cvInitNArrayIterator_texinfo}, +{"cvNextNArraySlice",_wrap_cvNextNArraySlice,0,0,2,_wrap_cvNextNArraySlice_texinfo}, +{"cvGetElemType",_wrap_cvGetElemType,0,0,2,_wrap_cvGetElemType_texinfo}, +{"cvGetDims",_wrap_cvGetDims,0,0,2,_wrap_cvGetDims_texinfo}, +{"cvGetDimSize",_wrap_cvGetDimSize,0,0,2,_wrap_cvGetDimSize_texinfo}, +{"cvPtr1D",_wrap_cvPtr1D,0,0,2,_wrap_cvPtr1D_texinfo}, +{"cvPtr2D",_wrap_cvPtr2D,0,0,2,_wrap_cvPtr2D_texinfo}, +{"cvPtr3D",_wrap_cvPtr3D,0,0,2,_wrap_cvPtr3D_texinfo}, +{"cvPtrND",_wrap_cvPtrND,0,0,2,_wrap_cvPtrND_texinfo}, +{"cvGet1D",_wrap_cvGet1D,0,0,2,_wrap_cvGet1D_texinfo}, +{"cvGet2D",_wrap_cvGet2D,0,0,2,_wrap_cvGet2D_texinfo}, +{"cvGet3D",_wrap_cvGet3D,0,0,2,_wrap_cvGet3D_texinfo}, +{"cvGetND",_wrap_cvGetND,0,0,2,_wrap_cvGetND_texinfo}, +{"cvGetReal1D",_wrap_cvGetReal1D,0,0,2,_wrap_cvGetReal1D_texinfo}, +{"cvGetReal2D",_wrap_cvGetReal2D,0,0,2,_wrap_cvGetReal2D_texinfo}, +{"cvGetReal3D",_wrap_cvGetReal3D,0,0,2,_wrap_cvGetReal3D_texinfo}, +{"cvGetRealND",_wrap_cvGetRealND,0,0,2,_wrap_cvGetRealND_texinfo}, +{"cvSet1D",_wrap_cvSet1D,0,0,2,_wrap_cvSet1D_texinfo}, +{"cvSet2D",_wrap_cvSet2D,0,0,2,_wrap_cvSet2D_texinfo}, +{"cvSet3D",_wrap_cvSet3D,0,0,2,_wrap_cvSet3D_texinfo}, +{"cvSetND",_wrap_cvSetND,0,0,2,_wrap_cvSetND_texinfo}, +{"cvSetReal1D",_wrap_cvSetReal1D,0,0,2,_wrap_cvSetReal1D_texinfo}, +{"cvSetReal2D",_wrap_cvSetReal2D,0,0,2,_wrap_cvSetReal2D_texinfo}, +{"cvSetReal3D",_wrap_cvSetReal3D,0,0,2,_wrap_cvSetReal3D_texinfo}, +{"cvSetRealND",_wrap_cvSetRealND,0,0,2,_wrap_cvSetRealND_texinfo}, +{"cvClearND",_wrap_cvClearND,0,0,2,_wrap_cvClearND_texinfo}, +{"cvGetMat",_wrap_cvGetMat,0,0,2,_wrap_cvGetMat_texinfo}, +{"cvReshapeMatND",_wrap_cvReshapeMatND,0,0,2,_wrap_cvReshapeMatND_texinfo}, +{"cvReshape",_wrap_cvReshape,0,0,2,_wrap_cvReshape_texinfo}, +{"cvRepeat",_wrap_cvRepeat,0,0,2,_wrap_cvRepeat_texinfo}, +{"cvCreateData",_wrap_cvCreateData,0,0,2,_wrap_cvCreateData_texinfo}, +{"cvReleaseData",_wrap_cvReleaseData,0,0,2,_wrap_cvReleaseData_texinfo}, +{"cvSetData",_wrap_cvSetData,0,0,2,_wrap_cvSetData_texinfo}, +{"cvGetRawData",_wrap_cvGetRawData,0,0,2,_wrap_cvGetRawData_texinfo}, +{"cvGetSize",_wrap_cvGetSize,0,0,2,_wrap_cvGetSize_texinfo}, +{"cvCopy",_wrap_cvCopy,0,0,2,_wrap_cvCopy_texinfo}, +{"cvSet",_wrap_cvSet,0,0,2,_wrap_cvSet_texinfo}, +{"cvSetZero",_wrap_cvSetZero,0,0,2,_wrap_cvSetZero_texinfo}, +{"cvSplit",_wrap_cvSplit,0,0,2,_wrap_cvSplit_texinfo}, +{"cvMerge",_wrap_cvMerge,0,0,2,_wrap_cvMerge_texinfo}, +{"cvMixChannels",_wrap_cvMixChannels,0,0,2,_wrap_cvMixChannels_texinfo}, +{"cvConvertScale",_wrap_cvConvertScale,0,0,2,_wrap_cvConvertScale_texinfo}, +{"cvConvertScaleAbs",_wrap_cvConvertScaleAbs,0,0,2,_wrap_cvConvertScaleAbs_texinfo}, +{"cvCheckTermCriteria",_wrap_cvCheckTermCriteria,0,0,2,_wrap_cvCheckTermCriteria_texinfo}, +{"cvAdd",_wrap_cvAdd,0,0,2,_wrap_cvAdd_texinfo}, +{"cvAddS",_wrap_cvAddS,0,0,2,_wrap_cvAddS_texinfo}, +{"cvSub",_wrap_cvSub,0,0,2,_wrap_cvSub_texinfo}, +{"cvSubS",_wrap_cvSubS,0,0,2,_wrap_cvSubS_texinfo}, +{"cvSubRS",_wrap_cvSubRS,0,0,2,_wrap_cvSubRS_texinfo}, +{"cvMul",_wrap_cvMul,0,0,2,_wrap_cvMul_texinfo}, +{"cvDiv",_wrap_cvDiv,0,0,2,_wrap_cvDiv_texinfo}, +{"cvScaleAdd",_wrap_cvScaleAdd,0,0,2,_wrap_cvScaleAdd_texinfo}, +{"cvAddWeighted",_wrap_cvAddWeighted,0,0,2,_wrap_cvAddWeighted_texinfo}, +{"cvDotProduct",_wrap_cvDotProduct,0,0,2,_wrap_cvDotProduct_texinfo}, +{"cvAnd",_wrap_cvAnd,0,0,2,_wrap_cvAnd_texinfo}, +{"cvAndS",_wrap_cvAndS,0,0,2,_wrap_cvAndS_texinfo}, +{"cvOr",_wrap_cvOr,0,0,2,_wrap_cvOr_texinfo}, +{"cvOrS",_wrap_cvOrS,0,0,2,_wrap_cvOrS_texinfo}, +{"cvXor",_wrap_cvXor,0,0,2,_wrap_cvXor_texinfo}, +{"cvXorS",_wrap_cvXorS,0,0,2,_wrap_cvXorS_texinfo}, +{"cvNot",_wrap_cvNot,0,0,2,_wrap_cvNot_texinfo}, +{"cvInRange",_wrap_cvInRange,0,0,2,_wrap_cvInRange_texinfo}, +{"cvInRangeS",_wrap_cvInRangeS,0,0,2,_wrap_cvInRangeS_texinfo}, +{"cvCmp",_wrap_cvCmp,0,0,2,_wrap_cvCmp_texinfo}, +{"cvCmpS",_wrap_cvCmpS,0,0,2,_wrap_cvCmpS_texinfo}, +{"cvMin",_wrap_cvMin,0,0,2,_wrap_cvMin_texinfo}, +{"cvMax",_wrap_cvMax,0,0,2,_wrap_cvMax_texinfo}, +{"cvMinS",_wrap_cvMinS,0,0,2,_wrap_cvMinS_texinfo}, +{"cvMaxS",_wrap_cvMaxS,0,0,2,_wrap_cvMaxS_texinfo}, +{"cvAbsDiff",_wrap_cvAbsDiff,0,0,2,_wrap_cvAbsDiff_texinfo}, +{"cvAbsDiffS",_wrap_cvAbsDiffS,0,0,2,_wrap_cvAbsDiffS_texinfo}, +{"cvCartToPolar",_wrap_cvCartToPolar,0,0,2,_wrap_cvCartToPolar_texinfo}, +{"cvPolarToCart",_wrap_cvPolarToCart,0,0,2,_wrap_cvPolarToCart_texinfo}, +{"cvPow",_wrap_cvPow,0,0,2,_wrap_cvPow_texinfo}, +{"cvExp",_wrap_cvExp,0,0,2,_wrap_cvExp_texinfo}, +{"cvLog",_wrap_cvLog,0,0,2,_wrap_cvLog_texinfo}, +{"cvFastArctan",_wrap_cvFastArctan,0,0,2,_wrap_cvFastArctan_texinfo}, +{"cvCbrt",_wrap_cvCbrt,0,0,2,_wrap_cvCbrt_texinfo}, +{"cvCheckArr",_wrap_cvCheckArr,0,0,2,_wrap_cvCheckArr_texinfo}, +{"cvRandArr",_wrap_cvRandArr,0,0,2,_wrap_cvRandArr_texinfo}, +{"cvRandShuffle",_wrap_cvRandShuffle,0,0,2,_wrap_cvRandShuffle_texinfo}, +{"cvSort",_wrap_cvSort,0,0,2,_wrap_cvSort_texinfo}, +{"cvSolveCubic",_wrap_cvSolveCubic,0,0,2,_wrap_cvSolveCubic_texinfo}, +{"cvSolvePoly",_wrap_cvSolvePoly,0,0,2,_wrap_cvSolvePoly_texinfo}, +{"cvCrossProduct",_wrap_cvCrossProduct,0,0,2,_wrap_cvCrossProduct_texinfo}, +{"cvGEMM",_wrap_cvGEMM,0,0,2,_wrap_cvGEMM_texinfo}, +{"cvTransform",_wrap_cvTransform,0,0,2,_wrap_cvTransform_texinfo}, +{"cvPerspectiveTransform",_wrap_cvPerspectiveTransform,0,0,2,_wrap_cvPerspectiveTransform_texinfo}, +{"cvMulTransposed",_wrap_cvMulTransposed,0,0,2,_wrap_cvMulTransposed_texinfo}, +{"cvTranspose",_wrap_cvTranspose,0,0,2,_wrap_cvTranspose_texinfo}, +{"cvCompleteSymm",_wrap_cvCompleteSymm,0,0,2,_wrap_cvCompleteSymm_texinfo}, +{"cvFlip",_wrap_cvFlip,0,0,2,_wrap_cvFlip_texinfo}, +{"cvSVD",_wrap_cvSVD,0,0,2,_wrap_cvSVD_texinfo}, +{"cvSVBkSb",_wrap_cvSVBkSb,0,0,2,_wrap_cvSVBkSb_texinfo}, +{"cvInvert",_wrap_cvInvert,0,0,2,_wrap_cvInvert_texinfo}, +{"cvSolve",_wrap_cvSolve,0,0,2,_wrap_cvSolve_texinfo}, +{"cvDet",_wrap_cvDet,0,0,2,_wrap_cvDet_texinfo}, +{"cvTrace",_wrap_cvTrace,0,0,2,_wrap_cvTrace_texinfo}, +{"cvEigenVV",_wrap_cvEigenVV,0,0,2,_wrap_cvEigenVV_texinfo}, +{"cvSetIdentity",_wrap_cvSetIdentity,0,0,2,_wrap_cvSetIdentity_texinfo}, +{"cvRange",_wrap_cvRange,0,0,2,_wrap_cvRange_texinfo}, +{"cvCalcCovarMatrix",_wrap_cvCalcCovarMatrix,0,0,2,_wrap_cvCalcCovarMatrix_texinfo}, +{"cvCalcPCA",_wrap_cvCalcPCA,0,0,2,_wrap_cvCalcPCA_texinfo}, +{"cvProjectPCA",_wrap_cvProjectPCA,0,0,2,_wrap_cvProjectPCA_texinfo}, +{"cvBackProjectPCA",_wrap_cvBackProjectPCA,0,0,2,_wrap_cvBackProjectPCA_texinfo}, +{"cvMahalanobis",_wrap_cvMahalanobis,0,0,2,_wrap_cvMahalanobis_texinfo}, +{"cvSum",_wrap_cvSum,0,0,2,_wrap_cvSum_texinfo}, +{"cvCountNonZero",_wrap_cvCountNonZero,0,0,2,_wrap_cvCountNonZero_texinfo}, +{"cvAvg",_wrap_cvAvg,0,0,2,_wrap_cvAvg_texinfo}, +{"cvAvgSdv",_wrap_cvAvgSdv,0,0,2,_wrap_cvAvgSdv_texinfo}, +{"cvMinMaxLoc",_wrap_cvMinMaxLoc,0,0,2,_wrap_cvMinMaxLoc_texinfo}, +{"cvNorm",_wrap_cvNorm,0,0,2,_wrap_cvNorm_texinfo}, +{"cvNormalize",_wrap_cvNormalize,0,0,2,_wrap_cvNormalize_texinfo}, +{"cvReduce",_wrap_cvReduce,0,0,2,_wrap_cvReduce_texinfo}, +{"cvDFT",_wrap_cvDFT,0,0,2,_wrap_cvDFT_texinfo}, +{"cvMulSpectrums",_wrap_cvMulSpectrums,0,0,2,_wrap_cvMulSpectrums_texinfo}, +{"cvGetOptimalDFTSize",_wrap_cvGetOptimalDFTSize,0,0,2,_wrap_cvGetOptimalDFTSize_texinfo}, +{"cvDCT",_wrap_cvDCT,0,0,2,_wrap_cvDCT_texinfo}, +{"cvSliceLength",_wrap_cvSliceLength,0,0,2,_wrap_cvSliceLength_texinfo}, +{"cvCreateMemStorage",_wrap_cvCreateMemStorage,0,0,2,_wrap_cvCreateMemStorage_texinfo}, +{"cvCreateChildMemStorage",_wrap_cvCreateChildMemStorage,0,0,2,_wrap_cvCreateChildMemStorage_texinfo}, +{"cvReleaseMemStorage",_wrap_cvReleaseMemStorage,0,0,2,_wrap_cvReleaseMemStorage_texinfo}, +{"cvClearMemStorage",_wrap_cvClearMemStorage,0,0,2,_wrap_cvClearMemStorage_texinfo}, +{"cvSaveMemStoragePos",_wrap_cvSaveMemStoragePos,0,0,2,_wrap_cvSaveMemStoragePos_texinfo}, +{"cvRestoreMemStoragePos",_wrap_cvRestoreMemStoragePos,0,0,2,_wrap_cvRestoreMemStoragePos_texinfo}, +{"cvMemStorageAlloc",_wrap_cvMemStorageAlloc,0,0,2,_wrap_cvMemStorageAlloc_texinfo}, +{"cvMemStorageAllocString",_wrap_cvMemStorageAllocString,0,0,2,_wrap_cvMemStorageAllocString_texinfo}, +{"cvCreateSeq",_wrap_cvCreateSeq,0,0,2,_wrap_cvCreateSeq_texinfo}, +{"cvSetSeqBlockSize",_wrap_cvSetSeqBlockSize,0,0,2,_wrap_cvSetSeqBlockSize_texinfo}, +{"cvSeqPush",_wrap_cvSeqPush,0,0,2,_wrap_cvSeqPush_texinfo}, +{"cvSeqPushFront",_wrap_cvSeqPushFront,0,0,2,_wrap_cvSeqPushFront_texinfo}, +{"cvSeqPop",_wrap_cvSeqPop,0,0,2,_wrap_cvSeqPop_texinfo}, +{"cvSeqPopFront",_wrap_cvSeqPopFront,0,0,2,_wrap_cvSeqPopFront_texinfo}, +{"cvSeqPushMulti",_wrap_cvSeqPushMulti,0,0,2,_wrap_cvSeqPushMulti_texinfo}, +{"cvSeqPopMulti",_wrap_cvSeqPopMulti,0,0,2,_wrap_cvSeqPopMulti_texinfo}, +{"cvSeqInsert",_wrap_cvSeqInsert,0,0,2,_wrap_cvSeqInsert_texinfo}, +{"cvSeqRemove",_wrap_cvSeqRemove,0,0,2,_wrap_cvSeqRemove_texinfo}, +{"cvClearSeq",_wrap_cvClearSeq,0,0,2,_wrap_cvClearSeq_texinfo}, +{"cvGetSeqElem",_wrap_cvGetSeqElem,0,0,2,_wrap_cvGetSeqElem_texinfo}, +{"cvSeqElemIdx",_wrap_cvSeqElemIdx,0,0,2,_wrap_cvSeqElemIdx_texinfo}, +{"cvStartAppendToSeq",_wrap_cvStartAppendToSeq,0,0,2,_wrap_cvStartAppendToSeq_texinfo}, +{"cvStartWriteSeq",_wrap_cvStartWriteSeq,0,0,2,_wrap_cvStartWriteSeq_texinfo}, +{"cvEndWriteSeq",_wrap_cvEndWriteSeq,0,0,2,_wrap_cvEndWriteSeq_texinfo}, +{"cvFlushSeqWriter",_wrap_cvFlushSeqWriter,0,0,2,_wrap_cvFlushSeqWriter_texinfo}, +{"cvStartReadSeq",_wrap_cvStartReadSeq,0,0,2,_wrap_cvStartReadSeq_texinfo}, +{"cvGetSeqReaderPos",_wrap_cvGetSeqReaderPos,0,0,2,_wrap_cvGetSeqReaderPos_texinfo}, +{"cvSetSeqReaderPos",_wrap_cvSetSeqReaderPos,0,0,2,_wrap_cvSetSeqReaderPos_texinfo}, +{"cvMakeSeqHeaderForArray",_wrap_cvMakeSeqHeaderForArray,0,0,2,_wrap_cvMakeSeqHeaderForArray_texinfo}, +{"cvSeqSlice",_wrap_cvSeqSlice,0,0,2,_wrap_cvSeqSlice_texinfo}, +{"cvCloneSeq",_wrap_cvCloneSeq,0,0,2,_wrap_cvCloneSeq_texinfo}, +{"cvSeqRemoveSlice",_wrap_cvSeqRemoveSlice,0,0,2,_wrap_cvSeqRemoveSlice_texinfo}, +{"cvSeqInsertSlice",_wrap_cvSeqInsertSlice,0,0,2,_wrap_cvSeqInsertSlice_texinfo}, +{"cvSeqSort",_wrap_cvSeqSort,0,0,2,_wrap_cvSeqSort_texinfo}, +{"cvSeqSearch",_wrap_cvSeqSearch,0,0,2,_wrap_cvSeqSearch_texinfo}, +{"cvSeqInvert",_wrap_cvSeqInvert,0,0,2,_wrap_cvSeqInvert_texinfo}, +{"cvSeqPartition",_wrap_cvSeqPartition,0,0,2,_wrap_cvSeqPartition_texinfo}, +{"cvChangeSeqBlock",_wrap_cvChangeSeqBlock,0,0,2,_wrap_cvChangeSeqBlock_texinfo}, +{"cvCreateSeqBlock",_wrap_cvCreateSeqBlock,0,0,2,_wrap_cvCreateSeqBlock_texinfo}, +{"cvCreateSet",_wrap_cvCreateSet,0,0,2,_wrap_cvCreateSet_texinfo}, +{"cvSetAdd",_wrap_cvSetAdd,0,0,2,_wrap_cvSetAdd_texinfo}, +{"cvSetNew",_wrap_cvSetNew,0,0,2,_wrap_cvSetNew_texinfo}, +{"cvSetRemoveByPtr",_wrap_cvSetRemoveByPtr,0,0,2,_wrap_cvSetRemoveByPtr_texinfo}, +{"cvSetRemove",_wrap_cvSetRemove,0,0,2,_wrap_cvSetRemove_texinfo}, +{"cvGetSetElem",_wrap_cvGetSetElem,0,0,2,_wrap_cvGetSetElem_texinfo}, +{"cvClearSet",_wrap_cvClearSet,0,0,2,_wrap_cvClearSet_texinfo}, +{"cvCreateGraph",_wrap_cvCreateGraph,0,0,2,_wrap_cvCreateGraph_texinfo}, +{"cvGraphAddVtx",_wrap_cvGraphAddVtx,0,0,2,_wrap_cvGraphAddVtx_texinfo}, +{"cvGraphRemoveVtx",_wrap_cvGraphRemoveVtx,0,0,2,_wrap_cvGraphRemoveVtx_texinfo}, +{"cvGraphRemoveVtxByPtr",_wrap_cvGraphRemoveVtxByPtr,0,0,2,_wrap_cvGraphRemoveVtxByPtr_texinfo}, +{"cvGraphAddEdge",_wrap_cvGraphAddEdge,0,0,2,_wrap_cvGraphAddEdge_texinfo}, +{"cvGraphAddEdgeByPtr",_wrap_cvGraphAddEdgeByPtr,0,0,2,_wrap_cvGraphAddEdgeByPtr_texinfo}, +{"cvGraphRemoveEdge",_wrap_cvGraphRemoveEdge,0,0,2,_wrap_cvGraphRemoveEdge_texinfo}, +{"cvGraphRemoveEdgeByPtr",_wrap_cvGraphRemoveEdgeByPtr,0,0,2,_wrap_cvGraphRemoveEdgeByPtr_texinfo}, +{"cvFindGraphEdge",_wrap_cvFindGraphEdge,0,0,2,_wrap_cvFindGraphEdge_texinfo}, +{"cvFindGraphEdgeByPtr",_wrap_cvFindGraphEdgeByPtr,0,0,2,_wrap_cvFindGraphEdgeByPtr_texinfo}, +{"cvClearGraph",_wrap_cvClearGraph,0,0,2,_wrap_cvClearGraph_texinfo}, +{"cvGraphVtxDegree",_wrap_cvGraphVtxDegree,0,0,2,_wrap_cvGraphVtxDegree_texinfo}, +{"cvGraphVtxDegreeByPtr",_wrap_cvGraphVtxDegreeByPtr,0,0,2,_wrap_cvGraphVtxDegreeByPtr_texinfo}, +{"CvGraphScanner_vtx_set",_wrap_CvGraphScanner_vtx_set,0,0,2,0}, +{"CvGraphScanner_vtx_get",_wrap_CvGraphScanner_vtx_get,0,0,2,0}, +{"CvGraphScanner_dst_set",_wrap_CvGraphScanner_dst_set,0,0,2,0}, +{"CvGraphScanner_dst_get",_wrap_CvGraphScanner_dst_get,0,0,2,0}, +{"CvGraphScanner_edge_set",_wrap_CvGraphScanner_edge_set,0,0,2,0}, +{"CvGraphScanner_edge_get",_wrap_CvGraphScanner_edge_get,0,0,2,0}, +{"CvGraphScanner_graph_set",_wrap_CvGraphScanner_graph_set,0,0,2,0}, +{"CvGraphScanner_graph_get",_wrap_CvGraphScanner_graph_get,0,0,2,0}, +{"CvGraphScanner_stack_set",_wrap_CvGraphScanner_stack_set,0,0,2,0}, +{"CvGraphScanner_stack_get",_wrap_CvGraphScanner_stack_get,0,0,2,0}, +{"CvGraphScanner_index_set",_wrap_CvGraphScanner_index_set,0,0,2,0}, +{"CvGraphScanner_index_get",_wrap_CvGraphScanner_index_get,0,0,2,0}, +{"CvGraphScanner_mask_set",_wrap_CvGraphScanner_mask_set,0,0,2,0}, +{"CvGraphScanner_mask_get",_wrap_CvGraphScanner_mask_get,0,0,2,0}, +{"delete_CvGraphScanner",_wrap_delete_CvGraphScanner,0,0,2,_wrap_delete_CvGraphScanner_texinfo}, +{"cvCreateGraphScanner",_wrap_cvCreateGraphScanner,0,0,2,_wrap_cvCreateGraphScanner_texinfo}, +{"cvReleaseGraphScanner",_wrap_cvReleaseGraphScanner,0,0,2,_wrap_cvReleaseGraphScanner_texinfo}, +{"cvNextGraphItem",_wrap_cvNextGraphItem,0,0,2,_wrap_cvNextGraphItem_texinfo}, +{"cvCloneGraph",_wrap_cvCloneGraph,0,0,2,_wrap_cvCloneGraph_texinfo}, +{"cvLine",_wrap_cvLine,0,0,2,_wrap_cvLine_texinfo}, +{"cvRectangle",_wrap_cvRectangle,0,0,2,_wrap_cvRectangle_texinfo}, +{"cvCircle",_wrap_cvCircle,0,0,2,_wrap_cvCircle_texinfo}, +{"cvEllipse",_wrap_cvEllipse,0,0,2,_wrap_cvEllipse_texinfo}, +{"cvEllipseBox",_wrap_cvEllipseBox,0,0,2,_wrap_cvEllipseBox_texinfo}, +{"cvFillConvexPoly",_wrap_cvFillConvexPoly,0,0,2,_wrap_cvFillConvexPoly_texinfo}, +{"cvFillPoly",_wrap_cvFillPoly,0,0,2,_wrap_cvFillPoly_texinfo}, +{"cvPolyLine",_wrap_cvPolyLine,0,0,2,_wrap_cvPolyLine_texinfo}, +{"cvClipLine",_wrap_cvClipLine,0,0,2,_wrap_cvClipLine_texinfo}, +{"cvInitLineIterator",_wrap_cvInitLineIterator,0,0,2,_wrap_cvInitLineIterator_texinfo}, +{"CvFont_font_face_set",_wrap_CvFont_font_face_set,0,0,2,0}, +{"CvFont_font_face_get",_wrap_CvFont_font_face_get,0,0,2,0}, +{"CvFont_ascii_set",_wrap_CvFont_ascii_set,0,0,2,0}, +{"CvFont_ascii_get",_wrap_CvFont_ascii_get,0,0,2,0}, +{"CvFont_greek_set",_wrap_CvFont_greek_set,0,0,2,0}, +{"CvFont_greek_get",_wrap_CvFont_greek_get,0,0,2,0}, +{"CvFont_cyrillic_set",_wrap_CvFont_cyrillic_set,0,0,2,0}, +{"CvFont_cyrillic_get",_wrap_CvFont_cyrillic_get,0,0,2,0}, +{"CvFont_hscale_set",_wrap_CvFont_hscale_set,0,0,2,0}, +{"CvFont_hscale_get",_wrap_CvFont_hscale_get,0,0,2,0}, +{"CvFont_vscale_set",_wrap_CvFont_vscale_set,0,0,2,0}, +{"CvFont_vscale_get",_wrap_CvFont_vscale_get,0,0,2,0}, +{"CvFont_shear_set",_wrap_CvFont_shear_set,0,0,2,0}, +{"CvFont_shear_get",_wrap_CvFont_shear_get,0,0,2,0}, +{"CvFont_thickness_set",_wrap_CvFont_thickness_set,0,0,2,0}, +{"CvFont_thickness_get",_wrap_CvFont_thickness_get,0,0,2,0}, +{"CvFont_dx_set",_wrap_CvFont_dx_set,0,0,2,0}, +{"CvFont_dx_get",_wrap_CvFont_dx_get,0,0,2,0}, +{"CvFont_line_type_set",_wrap_CvFont_line_type_set,0,0,2,0}, +{"CvFont_line_type_get",_wrap_CvFont_line_type_get,0,0,2,0}, +{"new_CvFont",_wrap_new_CvFont,0,0,2,_wrap_new_CvFont_texinfo}, +{"delete_CvFont",_wrap_delete_CvFont,0,0,2,_wrap_delete_CvFont_texinfo}, +{"cvInitFont",_wrap_cvInitFont,0,0,2,_wrap_cvInitFont_texinfo}, +{"cvFont",_wrap_cvFont,0,0,2,_wrap_cvFont_texinfo}, +{"cvPutText",_wrap_cvPutText,0,0,2,_wrap_cvPutText_texinfo}, +{"cvGetTextSize",_wrap_cvGetTextSize,0,0,2,_wrap_cvGetTextSize_texinfo}, +{"cvColorToScalar",_wrap_cvColorToScalar,0,0,2,_wrap_cvColorToScalar_texinfo}, +{"cvEllipse2Poly",_wrap_cvEllipse2Poly,0,0,2,_wrap_cvEllipse2Poly_texinfo}, +{"cvDrawContours",_wrap_cvDrawContours,0,0,2,_wrap_cvDrawContours_texinfo}, +{"cvLUT",_wrap_cvLUT,0,0,2,_wrap_cvLUT_texinfo}, +{"CvTreeNodeIterator_node_set",_wrap_CvTreeNodeIterator_node_set,0,0,2,0}, +{"CvTreeNodeIterator_node_get",_wrap_CvTreeNodeIterator_node_get,0,0,2,0}, +{"CvTreeNodeIterator_level_set",_wrap_CvTreeNodeIterator_level_set,0,0,2,0}, +{"CvTreeNodeIterator_level_get",_wrap_CvTreeNodeIterator_level_get,0,0,2,0}, +{"CvTreeNodeIterator_max_level_set",_wrap_CvTreeNodeIterator_max_level_set,0,0,2,0}, +{"CvTreeNodeIterator_max_level_get",_wrap_CvTreeNodeIterator_max_level_get,0,0,2,0}, +{"new_CvTreeNodeIterator",_wrap_new_CvTreeNodeIterator,0,0,2,_wrap_new_CvTreeNodeIterator_texinfo}, +{"delete_CvTreeNodeIterator",_wrap_delete_CvTreeNodeIterator,0,0,2,_wrap_delete_CvTreeNodeIterator_texinfo}, +{"cvInitTreeNodeIterator",_wrap_cvInitTreeNodeIterator,0,0,2,_wrap_cvInitTreeNodeIterator_texinfo}, +{"cvNextTreeNode",_wrap_cvNextTreeNode,0,0,2,_wrap_cvNextTreeNode_texinfo}, +{"cvPrevTreeNode",_wrap_cvPrevTreeNode,0,0,2,_wrap_cvPrevTreeNode_texinfo}, +{"cvInsertNodeIntoTree",_wrap_cvInsertNodeIntoTree,0,0,2,_wrap_cvInsertNodeIntoTree_texinfo}, +{"cvRemoveNodeFromTree",_wrap_cvRemoveNodeFromTree,0,0,2,_wrap_cvRemoveNodeFromTree_texinfo}, +{"cvTreeToNodeSeq",_wrap_cvTreeToNodeSeq,0,0,2,_wrap_cvTreeToNodeSeq_texinfo}, +{"cvKMeans2",_wrap_cvKMeans2,0,0,2,_wrap_cvKMeans2_texinfo}, +{"cvRegisterModule",_wrap_cvRegisterModule,0,0,2,_wrap_cvRegisterModule_texinfo}, +{"cvUseOptimized",_wrap_cvUseOptimized,0,0,2,_wrap_cvUseOptimized_texinfo}, +{"cvGetModuleInfo",_wrap_cvGetModuleInfo,0,0,2,_wrap_cvGetModuleInfo_texinfo}, +{"cvGetErrStatus",_wrap_cvGetErrStatus,0,0,2,_wrap_cvGetErrStatus_texinfo}, +{"cvSetErrStatus",_wrap_cvSetErrStatus,0,0,2,_wrap_cvSetErrStatus_texinfo}, +{"cvGetErrMode",_wrap_cvGetErrMode,0,0,2,_wrap_cvGetErrMode_texinfo}, +{"cvSetErrMode",_wrap_cvSetErrMode,0,0,2,_wrap_cvSetErrMode_texinfo}, +{"cvError",_wrap_cvError,0,0,2,_wrap_cvError_texinfo}, +{"cvErrorStr",_wrap_cvErrorStr,0,0,2,_wrap_cvErrorStr_texinfo}, +{"cvGetErrInfo",_wrap_cvGetErrInfo,0,0,2,_wrap_cvGetErrInfo_texinfo}, +{"cvErrorFromIppStatus",_wrap_cvErrorFromIppStatus,0,0,2,_wrap_cvErrorFromIppStatus_texinfo}, +{"cvRedirectError",_wrap_cvRedirectError,0,0,2,_wrap_cvRedirectError_texinfo}, +{"cvNulDevReport",_wrap_cvNulDevReport,0,0,2,_wrap_cvNulDevReport_texinfo}, +{"cvStdErrReport",_wrap_cvStdErrReport,0,0,2,_wrap_cvStdErrReport_texinfo}, +{"cvGuiBoxReport",_wrap_cvGuiBoxReport,0,0,2,_wrap_cvGuiBoxReport_texinfo}, +{"cvSetMemoryManager",_wrap_cvSetMemoryManager,0,0,2,_wrap_cvSetMemoryManager_texinfo}, +{"cvSetIPLAllocators",_wrap_cvSetIPLAllocators,0,0,2,_wrap_cvSetIPLAllocators_texinfo}, +{"cvOpenFileStorage",_wrap_cvOpenFileStorage,0,0,2,_wrap_cvOpenFileStorage_texinfo}, +{"cvReleaseFileStorage",_wrap_cvReleaseFileStorage,0,0,2,_wrap_cvReleaseFileStorage_texinfo}, +{"cvAttrValue",_wrap_cvAttrValue,0,0,2,_wrap_cvAttrValue_texinfo}, +{"cvStartWriteStruct",_wrap_cvStartWriteStruct,0,0,2,_wrap_cvStartWriteStruct_texinfo}, +{"cvEndWriteStruct",_wrap_cvEndWriteStruct,0,0,2,_wrap_cvEndWriteStruct_texinfo}, +{"cvWriteInt",_wrap_cvWriteInt,0,0,2,_wrap_cvWriteInt_texinfo}, +{"cvWriteReal",_wrap_cvWriteReal,0,0,2,_wrap_cvWriteReal_texinfo}, +{"cvWriteString",_wrap_cvWriteString,0,0,2,_wrap_cvWriteString_texinfo}, +{"cvWriteComment",_wrap_cvWriteComment,0,0,2,_wrap_cvWriteComment_texinfo}, +{"cvWrite",_wrap_cvWrite,0,0,2,_wrap_cvWrite_texinfo}, +{"cvStartNextStream",_wrap_cvStartNextStream,0,0,2,_wrap_cvStartNextStream_texinfo}, +{"cvWriteRawData",_wrap_cvWriteRawData,0,0,2,_wrap_cvWriteRawData_texinfo}, +{"cvGetHashedKey",_wrap_cvGetHashedKey,0,0,2,_wrap_cvGetHashedKey_texinfo}, +{"cvGetRootFileNode",_wrap_cvGetRootFileNode,0,0,2,_wrap_cvGetRootFileNode_texinfo}, +{"cvGetFileNode",_wrap_cvGetFileNode,0,0,2,_wrap_cvGetFileNode_texinfo}, +{"cvGetFileNodeByName",_wrap_cvGetFileNodeByName,0,0,2,_wrap_cvGetFileNodeByName_texinfo}, +{"cvReadInt",_wrap_cvReadInt,0,0,2,_wrap_cvReadInt_texinfo}, +{"cvReadIntByName",_wrap_cvReadIntByName,0,0,2,_wrap_cvReadIntByName_texinfo}, +{"cvReadReal",_wrap_cvReadReal,0,0,2,_wrap_cvReadReal_texinfo}, +{"cvReadRealByName",_wrap_cvReadRealByName,0,0,2,_wrap_cvReadRealByName_texinfo}, +{"cvReadString",_wrap_cvReadString,0,0,2,_wrap_cvReadString_texinfo}, +{"cvReadStringByName",_wrap_cvReadStringByName,0,0,2,_wrap_cvReadStringByName_texinfo}, +{"cvRead",_wrap_cvRead,0,0,2,_wrap_cvRead_texinfo}, +{"cvReadByName",_wrap_cvReadByName,0,0,2,_wrap_cvReadByName_texinfo}, +{"cvStartReadRawData",_wrap_cvStartReadRawData,0,0,2,_wrap_cvStartReadRawData_texinfo}, +{"cvReadRawDataSlice",_wrap_cvReadRawDataSlice,0,0,2,_wrap_cvReadRawDataSlice_texinfo}, +{"cvReadRawData",_wrap_cvReadRawData,0,0,2,_wrap_cvReadRawData_texinfo}, +{"cvWriteFileNode",_wrap_cvWriteFileNode,0,0,2,_wrap_cvWriteFileNode_texinfo}, +{"cvGetFileNodeName",_wrap_cvGetFileNodeName,0,0,2,_wrap_cvGetFileNodeName_texinfo}, +{"cvRegisterType",_wrap_cvRegisterType,0,0,2,_wrap_cvRegisterType_texinfo}, +{"cvUnregisterType",_wrap_cvUnregisterType,0,0,2,_wrap_cvUnregisterType_texinfo}, +{"cvFirstType",_wrap_cvFirstType,0,0,2,_wrap_cvFirstType_texinfo}, +{"cvFindType",_wrap_cvFindType,0,0,2,_wrap_cvFindType_texinfo}, +{"cvTypeOf",_wrap_cvTypeOf,0,0,2,_wrap_cvTypeOf_texinfo}, +{"cvRelease",_wrap_cvRelease,0,0,2,_wrap_cvRelease_texinfo}, +{"cvClone",_wrap_cvClone,0,0,2,_wrap_cvClone_texinfo}, +{"cvSave",_wrap_cvSave,0,0,2,_wrap_cvSave_texinfo}, +{"cvLoad",_wrap_cvLoad,0,0,2,_wrap_cvLoad_texinfo}, +{"cvGetTickCount",_wrap_cvGetTickCount,0,0,2,_wrap_cvGetTickCount_texinfo}, +{"cvGetTickFrequency",_wrap_cvGetTickFrequency,0,0,2,_wrap_cvGetTickFrequency_texinfo}, +{"cvGetNumThreads",_wrap_cvGetNumThreads,0,0,2,_wrap_cvGetNumThreads_texinfo}, +{"cvSetNumThreads",_wrap_cvSetNumThreads,0,0,2,_wrap_cvSetNumThreads_texinfo}, +{"cvGetThreadNum",_wrap_cvGetThreadNum,0,0,2,_wrap_cvGetThreadNum_texinfo}, +{"cvSetImageIOFunctions",_wrap_cvSetImageIOFunctions,0,0,2,_wrap_cvSetImageIOFunctions_texinfo}, +{"new_CvImage",_wrap_new_CvImage,0,0,2,_wrap_new_CvImage_texinfo}, +{"delete_CvImage",_wrap_delete_CvImage,0,0,2,_wrap_delete_CvImage_texinfo}, +{"CvImage_clone",_wrap_CvImage_clone,0,0,2,_wrap_CvImage_clone_texinfo}, +{"CvImage_create",_wrap_CvImage_create,0,0,2,_wrap_CvImage_create_texinfo}, +{"CvImage_release",_wrap_CvImage_release,0,0,2,_wrap_CvImage_release_texinfo}, +{"CvImage_clear",_wrap_CvImage_clear,0,0,2,_wrap_CvImage_clear_texinfo}, +{"CvImage_attach",_wrap_CvImage_attach,0,0,2,_wrap_CvImage_attach_texinfo}, +{"CvImage_detach",_wrap_CvImage_detach,0,0,2,_wrap_CvImage_detach_texinfo}, +{"CvImage_load",_wrap_CvImage_load,0,0,2,_wrap_CvImage_load_texinfo}, +{"CvImage_read",_wrap_CvImage_read,0,0,2,_wrap_CvImage_read_texinfo}, +{"CvImage_save",_wrap_CvImage_save,0,0,2,_wrap_CvImage_save_texinfo}, +{"CvImage_write",_wrap_CvImage_write,0,0,2,_wrap_CvImage_write_texinfo}, +{"CvImage_show",_wrap_CvImage_show,0,0,2,_wrap_CvImage_show_texinfo}, +{"CvImage_is_valid",_wrap_CvImage_is_valid,0,0,2,_wrap_CvImage_is_valid_texinfo}, +{"CvImage_width",_wrap_CvImage_width,0,0,2,_wrap_CvImage_width_texinfo}, +{"CvImage_height",_wrap_CvImage_height,0,0,2,_wrap_CvImage_height_texinfo}, +{"CvImage_size",_wrap_CvImage_size,0,0,2,_wrap_CvImage_size_texinfo}, +{"CvImage_roi_size",_wrap_CvImage_roi_size,0,0,2,_wrap_CvImage_roi_size_texinfo}, +{"CvImage_roi",_wrap_CvImage_roi,0,0,2,_wrap_CvImage_roi_texinfo}, +{"CvImage_coi",_wrap_CvImage_coi,0,0,2,_wrap_CvImage_coi_texinfo}, +{"CvImage_set_roi",_wrap_CvImage_set_roi,0,0,2,_wrap_CvImage_set_roi_texinfo}, +{"CvImage_reset_roi",_wrap_CvImage_reset_roi,0,0,2,_wrap_CvImage_reset_roi_texinfo}, +{"CvImage_set_coi",_wrap_CvImage_set_coi,0,0,2,_wrap_CvImage_set_coi_texinfo}, +{"CvImage_depth",_wrap_CvImage_depth,0,0,2,_wrap_CvImage_depth_texinfo}, +{"CvImage_channels",_wrap_CvImage_channels,0,0,2,_wrap_CvImage_channels_texinfo}, +{"CvImage_pix_size",_wrap_CvImage_pix_size,0,0,2,_wrap_CvImage_pix_size_texinfo}, +{"CvImage_data",_wrap_CvImage_data,0,0,2,_wrap_CvImage_data_texinfo}, +{"CvImage_step",_wrap_CvImage_step,0,0,2,_wrap_CvImage_step_texinfo}, +{"CvImage_origin",_wrap_CvImage_origin,0,0,2,_wrap_CvImage_origin_texinfo}, +{"CvImage_roi_row",_wrap_CvImage_roi_row,0,0,2,_wrap_CvImage_roi_row_texinfo}, +{"CvImage_asIplImage",_wrap_CvImage_asIplImage,0,0,2,_wrap_CvImage_asIplImage_texinfo}, +{"new_CvMatrix",_wrap_new_CvMatrix,0,0,2,_wrap_new_CvMatrix_texinfo}, +{"delete_CvMatrix",_wrap_delete_CvMatrix,0,0,2,_wrap_delete_CvMatrix_texinfo}, +{"CvMatrix_clone",_wrap_CvMatrix_clone,0,0,2,_wrap_CvMatrix_clone_texinfo}, +{"CvMatrix_set",_wrap_CvMatrix_set,0,0,2,_wrap_CvMatrix_set_texinfo}, +{"CvMatrix_create",_wrap_CvMatrix_create,0,0,2,_wrap_CvMatrix_create_texinfo}, +{"CvMatrix_addref",_wrap_CvMatrix_addref,0,0,2,_wrap_CvMatrix_addref_texinfo}, +{"CvMatrix_release",_wrap_CvMatrix_release,0,0,2,_wrap_CvMatrix_release_texinfo}, +{"CvMatrix_clear",_wrap_CvMatrix_clear,0,0,2,_wrap_CvMatrix_clear_texinfo}, +{"CvMatrix_load",_wrap_CvMatrix_load,0,0,2,_wrap_CvMatrix_load_texinfo}, +{"CvMatrix_read",_wrap_CvMatrix_read,0,0,2,_wrap_CvMatrix_read_texinfo}, +{"CvMatrix_save",_wrap_CvMatrix_save,0,0,2,_wrap_CvMatrix_save_texinfo}, +{"CvMatrix_write",_wrap_CvMatrix_write,0,0,2,_wrap_CvMatrix_write_texinfo}, +{"CvMatrix_show",_wrap_CvMatrix_show,0,0,2,_wrap_CvMatrix_show_texinfo}, +{"CvMatrix_is_valid",_wrap_CvMatrix_is_valid,0,0,2,_wrap_CvMatrix_is_valid_texinfo}, +{"CvMatrix_rows",_wrap_CvMatrix_rows,0,0,2,_wrap_CvMatrix_rows_texinfo}, +{"CvMatrix_cols",_wrap_CvMatrix_cols,0,0,2,_wrap_CvMatrix_cols_texinfo}, +{"CvMatrix_size",_wrap_CvMatrix_size,0,0,2,_wrap_CvMatrix_size_texinfo}, +{"CvMatrix_type",_wrap_CvMatrix_type,0,0,2,_wrap_CvMatrix_type_texinfo}, +{"CvMatrix_depth",_wrap_CvMatrix_depth,0,0,2,_wrap_CvMatrix_depth_texinfo}, +{"CvMatrix_channels",_wrap_CvMatrix_channels,0,0,2,_wrap_CvMatrix_channels_texinfo}, +{"CvMatrix_pix_size",_wrap_CvMatrix_pix_size,0,0,2,_wrap_CvMatrix_pix_size_texinfo}, +{"CvMatrix_data",_wrap_CvMatrix_data,0,0,2,_wrap_CvMatrix_data_texinfo}, +{"CvMatrix_step",_wrap_CvMatrix_step,0,0,2,_wrap_CvMatrix_step_texinfo}, +{"CvMatrix_set_data",_wrap_CvMatrix_set_data,0,0,2,_wrap_CvMatrix_set_data_texinfo}, +{"CvMatrix_row",_wrap_CvMatrix_row,0,0,2,_wrap_CvMatrix_row_texinfo}, +{"CvMatrix_asCvMat",_wrap_CvMatrix_asCvMat,0,0,2,_wrap_CvMatrix_asCvMat_texinfo}, +{"new_CvModule",_wrap_new_CvModule,0,0,2,_wrap_new_CvModule_texinfo}, +{"delete_CvModule",_wrap_delete_CvModule,0,0,2,_wrap_delete_CvModule_texinfo}, +{"CvModule_info_set",_wrap_CvModule_info_set,0,0,2,0}, +{"CvModule_info_get",_wrap_CvModule_info_get,0,0,2,0}, +{"CvModule_first",0,_wrap_CvModule_first_get,_wrap_CvModule_first_set,2,0}, +{"CvModule_last",0,_wrap_CvModule_last_get,_wrap_CvModule_last_set,2,0}, +{"new_CvType",_wrap_new_CvType,0,0,2,_wrap_new_CvType_texinfo}, +{"delete_CvType",_wrap_delete_CvType,0,0,2,_wrap_delete_CvType_texinfo}, +{"CvType_info_set",_wrap_CvType_info_set,0,0,2,0}, +{"CvType_info_get",_wrap_CvType_info_get,0,0,2,0}, +{"CvType_first",0,_wrap_CvType_first_get,_wrap_CvType_first_set,2,0}, +{"CvType_last",0,_wrap_CvType_last_get,_wrap_CvType_last_set,2,0}, +{"CvMoments_m00_set",_wrap_CvMoments_m00_set,0,0,2,0}, +{"CvMoments_m00_get",_wrap_CvMoments_m00_get,0,0,2,0}, +{"CvMoments_m10_set",_wrap_CvMoments_m10_set,0,0,2,0}, +{"CvMoments_m10_get",_wrap_CvMoments_m10_get,0,0,2,0}, +{"CvMoments_m01_set",_wrap_CvMoments_m01_set,0,0,2,0}, +{"CvMoments_m01_get",_wrap_CvMoments_m01_get,0,0,2,0}, +{"CvMoments_m20_set",_wrap_CvMoments_m20_set,0,0,2,0}, +{"CvMoments_m20_get",_wrap_CvMoments_m20_get,0,0,2,0}, +{"CvMoments_m11_set",_wrap_CvMoments_m11_set,0,0,2,0}, +{"CvMoments_m11_get",_wrap_CvMoments_m11_get,0,0,2,0}, +{"CvMoments_m02_set",_wrap_CvMoments_m02_set,0,0,2,0}, +{"CvMoments_m02_get",_wrap_CvMoments_m02_get,0,0,2,0}, +{"CvMoments_m30_set",_wrap_CvMoments_m30_set,0,0,2,0}, +{"CvMoments_m30_get",_wrap_CvMoments_m30_get,0,0,2,0}, +{"CvMoments_m21_set",_wrap_CvMoments_m21_set,0,0,2,0}, +{"CvMoments_m21_get",_wrap_CvMoments_m21_get,0,0,2,0}, +{"CvMoments_m12_set",_wrap_CvMoments_m12_set,0,0,2,0}, +{"CvMoments_m12_get",_wrap_CvMoments_m12_get,0,0,2,0}, +{"CvMoments_m03_set",_wrap_CvMoments_m03_set,0,0,2,0}, +{"CvMoments_m03_get",_wrap_CvMoments_m03_get,0,0,2,0}, +{"CvMoments_mu20_set",_wrap_CvMoments_mu20_set,0,0,2,0}, +{"CvMoments_mu20_get",_wrap_CvMoments_mu20_get,0,0,2,0}, +{"CvMoments_mu11_set",_wrap_CvMoments_mu11_set,0,0,2,0}, +{"CvMoments_mu11_get",_wrap_CvMoments_mu11_get,0,0,2,0}, +{"CvMoments_mu02_set",_wrap_CvMoments_mu02_set,0,0,2,0}, +{"CvMoments_mu02_get",_wrap_CvMoments_mu02_get,0,0,2,0}, +{"CvMoments_mu30_set",_wrap_CvMoments_mu30_set,0,0,2,0}, +{"CvMoments_mu30_get",_wrap_CvMoments_mu30_get,0,0,2,0}, +{"CvMoments_mu21_set",_wrap_CvMoments_mu21_set,0,0,2,0}, +{"CvMoments_mu21_get",_wrap_CvMoments_mu21_get,0,0,2,0}, +{"CvMoments_mu12_set",_wrap_CvMoments_mu12_set,0,0,2,0}, +{"CvMoments_mu12_get",_wrap_CvMoments_mu12_get,0,0,2,0}, +{"CvMoments_mu03_set",_wrap_CvMoments_mu03_set,0,0,2,0}, +{"CvMoments_mu03_get",_wrap_CvMoments_mu03_get,0,0,2,0}, +{"CvMoments_inv_sqrt_m00_set",_wrap_CvMoments_inv_sqrt_m00_set,0,0,2,0}, +{"CvMoments_inv_sqrt_m00_get",_wrap_CvMoments_inv_sqrt_m00_get,0,0,2,0}, +{"new_CvMoments",_wrap_new_CvMoments,0,0,2,_wrap_new_CvMoments_texinfo}, +{"delete_CvMoments",_wrap_delete_CvMoments,0,0,2,_wrap_delete_CvMoments_texinfo}, +{"CvHuMoments_hu1_set",_wrap_CvHuMoments_hu1_set,0,0,2,0}, +{"CvHuMoments_hu1_get",_wrap_CvHuMoments_hu1_get,0,0,2,0}, +{"CvHuMoments_hu2_set",_wrap_CvHuMoments_hu2_set,0,0,2,0}, +{"CvHuMoments_hu2_get",_wrap_CvHuMoments_hu2_get,0,0,2,0}, +{"CvHuMoments_hu3_set",_wrap_CvHuMoments_hu3_set,0,0,2,0}, +{"CvHuMoments_hu3_get",_wrap_CvHuMoments_hu3_get,0,0,2,0}, +{"CvHuMoments_hu4_set",_wrap_CvHuMoments_hu4_set,0,0,2,0}, +{"CvHuMoments_hu4_get",_wrap_CvHuMoments_hu4_get,0,0,2,0}, +{"CvHuMoments_hu5_set",_wrap_CvHuMoments_hu5_set,0,0,2,0}, +{"CvHuMoments_hu5_get",_wrap_CvHuMoments_hu5_get,0,0,2,0}, +{"CvHuMoments_hu6_set",_wrap_CvHuMoments_hu6_set,0,0,2,0}, +{"CvHuMoments_hu6_get",_wrap_CvHuMoments_hu6_get,0,0,2,0}, +{"CvHuMoments_hu7_set",_wrap_CvHuMoments_hu7_set,0,0,2,0}, +{"CvHuMoments_hu7_get",_wrap_CvHuMoments_hu7_get,0,0,2,0}, +{"new_CvHuMoments",_wrap_new_CvHuMoments,0,0,2,_wrap_new_CvHuMoments_texinfo}, +{"delete_CvHuMoments",_wrap_delete_CvHuMoments,0,0,2,_wrap_delete_CvHuMoments_texinfo}, +{"CvConnectedComp_area_set",_wrap_CvConnectedComp_area_set,0,0,2,0}, +{"CvConnectedComp_area_get",_wrap_CvConnectedComp_area_get,0,0,2,0}, +{"CvConnectedComp_value_set",_wrap_CvConnectedComp_value_set,0,0,2,0}, +{"CvConnectedComp_value_get",_wrap_CvConnectedComp_value_get,0,0,2,0}, +{"CvConnectedComp_rect_set",_wrap_CvConnectedComp_rect_set,0,0,2,0}, +{"CvConnectedComp_rect_get",_wrap_CvConnectedComp_rect_get,0,0,2,0}, +{"CvConnectedComp_contour_set",_wrap_CvConnectedComp_contour_set,0,0,2,0}, +{"CvConnectedComp_contour_get",_wrap_CvConnectedComp_contour_get,0,0,2,0}, +{"new_CvConnectedComp",_wrap_new_CvConnectedComp,0,0,2,_wrap_new_CvConnectedComp_texinfo}, +{"delete_CvConnectedComp",_wrap_delete_CvConnectedComp,0,0,2,_wrap_delete_CvConnectedComp_texinfo}, +{"CvChainPtReader_header_size_set",_wrap_CvChainPtReader_header_size_set,0,0,2,0}, +{"CvChainPtReader_header_size_get",_wrap_CvChainPtReader_header_size_get,0,0,2,0}, +{"CvChainPtReader_seq_set",_wrap_CvChainPtReader_seq_set,0,0,2,0}, +{"CvChainPtReader_seq_get",_wrap_CvChainPtReader_seq_get,0,0,2,0}, +{"CvChainPtReader_block_set",_wrap_CvChainPtReader_block_set,0,0,2,0}, +{"CvChainPtReader_block_get",_wrap_CvChainPtReader_block_get,0,0,2,0}, +{"CvChainPtReader_ptr_set",_wrap_CvChainPtReader_ptr_set,0,0,2,0}, +{"CvChainPtReader_ptr_get",_wrap_CvChainPtReader_ptr_get,0,0,2,0}, +{"CvChainPtReader_block_min_set",_wrap_CvChainPtReader_block_min_set,0,0,2,0}, +{"CvChainPtReader_block_min_get",_wrap_CvChainPtReader_block_min_get,0,0,2,0}, +{"CvChainPtReader_block_max_set",_wrap_CvChainPtReader_block_max_set,0,0,2,0}, +{"CvChainPtReader_block_max_get",_wrap_CvChainPtReader_block_max_get,0,0,2,0}, +{"CvChainPtReader_delta_index_set",_wrap_CvChainPtReader_delta_index_set,0,0,2,0}, +{"CvChainPtReader_delta_index_get",_wrap_CvChainPtReader_delta_index_get,0,0,2,0}, +{"CvChainPtReader_prev_elem_set",_wrap_CvChainPtReader_prev_elem_set,0,0,2,0}, +{"CvChainPtReader_prev_elem_get",_wrap_CvChainPtReader_prev_elem_get,0,0,2,0}, +{"CvChainPtReader_code_set",_wrap_CvChainPtReader_code_set,0,0,2,0}, +{"CvChainPtReader_code_get",_wrap_CvChainPtReader_code_get,0,0,2,0}, +{"CvChainPtReader_pt_set",_wrap_CvChainPtReader_pt_set,0,0,2,0}, +{"CvChainPtReader_pt_get",_wrap_CvChainPtReader_pt_get,0,0,2,0}, +{"CvChainPtReader_deltas_set",_wrap_CvChainPtReader_deltas_set,0,0,2,0}, +{"CvChainPtReader_deltas_get",_wrap_CvChainPtReader_deltas_get,0,0,2,0}, +{"new_CvChainPtReader",_wrap_new_CvChainPtReader,0,0,2,_wrap_new_CvChainPtReader_texinfo}, +{"delete_CvChainPtReader",_wrap_delete_CvChainPtReader,0,0,2,_wrap_delete_CvChainPtReader_texinfo}, +{"CvContourTree_flags_set",_wrap_CvContourTree_flags_set,0,0,2,0}, +{"CvContourTree_flags_get",_wrap_CvContourTree_flags_get,0,0,2,0}, +{"CvContourTree_header_size_set",_wrap_CvContourTree_header_size_set,0,0,2,0}, +{"CvContourTree_header_size_get",_wrap_CvContourTree_header_size_get,0,0,2,0}, +{"CvContourTree_h_prev_set",_wrap_CvContourTree_h_prev_set,0,0,2,0}, +{"CvContourTree_h_prev_get",_wrap_CvContourTree_h_prev_get,0,0,2,0}, +{"CvContourTree_h_next_set",_wrap_CvContourTree_h_next_set,0,0,2,0}, +{"CvContourTree_h_next_get",_wrap_CvContourTree_h_next_get,0,0,2,0}, +{"CvContourTree_v_prev_set",_wrap_CvContourTree_v_prev_set,0,0,2,0}, +{"CvContourTree_v_prev_get",_wrap_CvContourTree_v_prev_get,0,0,2,0}, +{"CvContourTree_v_next_set",_wrap_CvContourTree_v_next_set,0,0,2,0}, +{"CvContourTree_v_next_get",_wrap_CvContourTree_v_next_get,0,0,2,0}, +{"CvContourTree_total_set",_wrap_CvContourTree_total_set,0,0,2,0}, +{"CvContourTree_total_get",_wrap_CvContourTree_total_get,0,0,2,0}, +{"CvContourTree_elem_size_set",_wrap_CvContourTree_elem_size_set,0,0,2,0}, +{"CvContourTree_elem_size_get",_wrap_CvContourTree_elem_size_get,0,0,2,0}, +{"CvContourTree_block_max_set",_wrap_CvContourTree_block_max_set,0,0,2,0}, +{"CvContourTree_block_max_get",_wrap_CvContourTree_block_max_get,0,0,2,0}, +{"CvContourTree_ptr_set",_wrap_CvContourTree_ptr_set,0,0,2,0}, +{"CvContourTree_ptr_get",_wrap_CvContourTree_ptr_get,0,0,2,0}, +{"CvContourTree_delta_elems_set",_wrap_CvContourTree_delta_elems_set,0,0,2,0}, +{"CvContourTree_delta_elems_get",_wrap_CvContourTree_delta_elems_get,0,0,2,0}, +{"CvContourTree_storage_set",_wrap_CvContourTree_storage_set,0,0,2,0}, +{"CvContourTree_storage_get",_wrap_CvContourTree_storage_get,0,0,2,0}, +{"CvContourTree_free_blocks_set",_wrap_CvContourTree_free_blocks_set,0,0,2,0}, +{"CvContourTree_free_blocks_get",_wrap_CvContourTree_free_blocks_get,0,0,2,0}, +{"CvContourTree_first_set",_wrap_CvContourTree_first_set,0,0,2,0}, +{"CvContourTree_first_get",_wrap_CvContourTree_first_get,0,0,2,0}, +{"CvContourTree_p1_set",_wrap_CvContourTree_p1_set,0,0,2,0}, +{"CvContourTree_p1_get",_wrap_CvContourTree_p1_get,0,0,2,0}, +{"CvContourTree_p2_set",_wrap_CvContourTree_p2_set,0,0,2,0}, +{"CvContourTree_p2_get",_wrap_CvContourTree_p2_get,0,0,2,0}, +{"new_CvContourTree",_wrap_new_CvContourTree,0,0,2,_wrap_new_CvContourTree_texinfo}, +{"delete_CvContourTree",_wrap_delete_CvContourTree,0,0,2,_wrap_delete_CvContourTree_texinfo}, +{"CvConvexityDefect_start_set",_wrap_CvConvexityDefect_start_set,0,0,2,0}, +{"CvConvexityDefect_start_get",_wrap_CvConvexityDefect_start_get,0,0,2,0}, +{"CvConvexityDefect_end_set",_wrap_CvConvexityDefect_end_set,0,0,2,0}, +{"CvConvexityDefect_end_get",_wrap_CvConvexityDefect_end_get,0,0,2,0}, +{"CvConvexityDefect_depth_point_set",_wrap_CvConvexityDefect_depth_point_set,0,0,2,0}, +{"CvConvexityDefect_depth_point_get",_wrap_CvConvexityDefect_depth_point_get,0,0,2,0}, +{"CvConvexityDefect_depth_set",_wrap_CvConvexityDefect_depth_set,0,0,2,0}, +{"CvConvexityDefect_depth_get",_wrap_CvConvexityDefect_depth_get,0,0,2,0}, +{"new_CvConvexityDefect",_wrap_new_CvConvexityDefect,0,0,2,_wrap_new_CvConvexityDefect_texinfo}, +{"delete_CvConvexityDefect",_wrap_delete_CvConvexityDefect,0,0,2,_wrap_delete_CvConvexityDefect_texinfo}, +{"CvQuadEdge2D_flags_set",_wrap_CvQuadEdge2D_flags_set,0,0,2,0}, +{"CvQuadEdge2D_flags_get",_wrap_CvQuadEdge2D_flags_get,0,0,2,0}, +{"CvQuadEdge2D_pt_set",_wrap_CvQuadEdge2D_pt_set,0,0,2,0}, +{"CvQuadEdge2D_pt_get",_wrap_CvQuadEdge2D_pt_get,0,0,2,0}, +{"CvQuadEdge2D_next_set",_wrap_CvQuadEdge2D_next_set,0,0,2,0}, +{"CvQuadEdge2D_next_get",_wrap_CvQuadEdge2D_next_get,0,0,2,0}, +{"new_CvQuadEdge2D",_wrap_new_CvQuadEdge2D,0,0,2,_wrap_new_CvQuadEdge2D_texinfo}, +{"delete_CvQuadEdge2D",_wrap_delete_CvQuadEdge2D,0,0,2,_wrap_delete_CvQuadEdge2D_texinfo}, +{"CvSubdiv2DPoint_flags_set",_wrap_CvSubdiv2DPoint_flags_set,0,0,2,0}, +{"CvSubdiv2DPoint_flags_get",_wrap_CvSubdiv2DPoint_flags_get,0,0,2,0}, +{"CvSubdiv2DPoint_first_set",_wrap_CvSubdiv2DPoint_first_set,0,0,2,0}, +{"CvSubdiv2DPoint_first_get",_wrap_CvSubdiv2DPoint_first_get,0,0,2,0}, +{"CvSubdiv2DPoint_pt_set",_wrap_CvSubdiv2DPoint_pt_set,0,0,2,0}, +{"CvSubdiv2DPoint_pt_get",_wrap_CvSubdiv2DPoint_pt_get,0,0,2,0}, +{"new_CvSubdiv2DPoint",_wrap_new_CvSubdiv2DPoint,0,0,2,_wrap_new_CvSubdiv2DPoint_texinfo}, +{"delete_CvSubdiv2DPoint",_wrap_delete_CvSubdiv2DPoint,0,0,2,_wrap_delete_CvSubdiv2DPoint_texinfo}, +{"CvSubdiv2D_flags_set",_wrap_CvSubdiv2D_flags_set,0,0,2,0}, +{"CvSubdiv2D_flags_get",_wrap_CvSubdiv2D_flags_get,0,0,2,0}, +{"CvSubdiv2D_header_size_set",_wrap_CvSubdiv2D_header_size_set,0,0,2,0}, +{"CvSubdiv2D_header_size_get",_wrap_CvSubdiv2D_header_size_get,0,0,2,0}, +{"CvSubdiv2D_h_prev_set",_wrap_CvSubdiv2D_h_prev_set,0,0,2,0}, +{"CvSubdiv2D_h_prev_get",_wrap_CvSubdiv2D_h_prev_get,0,0,2,0}, +{"CvSubdiv2D_h_next_set",_wrap_CvSubdiv2D_h_next_set,0,0,2,0}, +{"CvSubdiv2D_h_next_get",_wrap_CvSubdiv2D_h_next_get,0,0,2,0}, +{"CvSubdiv2D_v_prev_set",_wrap_CvSubdiv2D_v_prev_set,0,0,2,0}, +{"CvSubdiv2D_v_prev_get",_wrap_CvSubdiv2D_v_prev_get,0,0,2,0}, +{"CvSubdiv2D_v_next_set",_wrap_CvSubdiv2D_v_next_set,0,0,2,0}, +{"CvSubdiv2D_v_next_get",_wrap_CvSubdiv2D_v_next_get,0,0,2,0}, +{"CvSubdiv2D_total_set",_wrap_CvSubdiv2D_total_set,0,0,2,0}, +{"CvSubdiv2D_total_get",_wrap_CvSubdiv2D_total_get,0,0,2,0}, +{"CvSubdiv2D_elem_size_set",_wrap_CvSubdiv2D_elem_size_set,0,0,2,0}, +{"CvSubdiv2D_elem_size_get",_wrap_CvSubdiv2D_elem_size_get,0,0,2,0}, +{"CvSubdiv2D_block_max_set",_wrap_CvSubdiv2D_block_max_set,0,0,2,0}, +{"CvSubdiv2D_block_max_get",_wrap_CvSubdiv2D_block_max_get,0,0,2,0}, +{"CvSubdiv2D_ptr_set",_wrap_CvSubdiv2D_ptr_set,0,0,2,0}, +{"CvSubdiv2D_ptr_get",_wrap_CvSubdiv2D_ptr_get,0,0,2,0}, +{"CvSubdiv2D_delta_elems_set",_wrap_CvSubdiv2D_delta_elems_set,0,0,2,0}, +{"CvSubdiv2D_delta_elems_get",_wrap_CvSubdiv2D_delta_elems_get,0,0,2,0}, +{"CvSubdiv2D_storage_set",_wrap_CvSubdiv2D_storage_set,0,0,2,0}, +{"CvSubdiv2D_storage_get",_wrap_CvSubdiv2D_storage_get,0,0,2,0}, +{"CvSubdiv2D_free_blocks_set",_wrap_CvSubdiv2D_free_blocks_set,0,0,2,0}, +{"CvSubdiv2D_free_blocks_get",_wrap_CvSubdiv2D_free_blocks_get,0,0,2,0}, +{"CvSubdiv2D_first_set",_wrap_CvSubdiv2D_first_set,0,0,2,0}, +{"CvSubdiv2D_first_get",_wrap_CvSubdiv2D_first_get,0,0,2,0}, +{"CvSubdiv2D_free_elems_set",_wrap_CvSubdiv2D_free_elems_set,0,0,2,0}, +{"CvSubdiv2D_free_elems_get",_wrap_CvSubdiv2D_free_elems_get,0,0,2,0}, +{"CvSubdiv2D_active_count_set",_wrap_CvSubdiv2D_active_count_set,0,0,2,0}, +{"CvSubdiv2D_active_count_get",_wrap_CvSubdiv2D_active_count_get,0,0,2,0}, +{"CvSubdiv2D_quad_edges_set",_wrap_CvSubdiv2D_quad_edges_set,0,0,2,0}, +{"CvSubdiv2D_quad_edges_get",_wrap_CvSubdiv2D_quad_edges_get,0,0,2,0}, +{"CvSubdiv2D_is_geometry_valid_set",_wrap_CvSubdiv2D_is_geometry_valid_set,0,0,2,0}, +{"CvSubdiv2D_is_geometry_valid_get",_wrap_CvSubdiv2D_is_geometry_valid_get,0,0,2,0}, +{"CvSubdiv2D_recent_edge_set",_wrap_CvSubdiv2D_recent_edge_set,0,0,2,0}, +{"CvSubdiv2D_recent_edge_get",_wrap_CvSubdiv2D_recent_edge_get,0,0,2,0}, +{"CvSubdiv2D_topleft_set",_wrap_CvSubdiv2D_topleft_set,0,0,2,0}, +{"CvSubdiv2D_topleft_get",_wrap_CvSubdiv2D_topleft_get,0,0,2,0}, +{"CvSubdiv2D_bottomright_set",_wrap_CvSubdiv2D_bottomright_set,0,0,2,0}, +{"CvSubdiv2D_bottomright_get",_wrap_CvSubdiv2D_bottomright_get,0,0,2,0}, +{"CvSubdiv2D_edges_set",_wrap_CvSubdiv2D_edges_set,0,0,2,0}, +{"CvSubdiv2D_edges_get",_wrap_CvSubdiv2D_edges_get,0,0,2,0}, +{"CvSubdiv2D_typed_edges_get",_wrap_CvSubdiv2D_typed_edges_get,0,0,2,_wrap_CvSubdiv2D_typed_edges_get_texinfo}, +{"CvSubdiv2D_typed_edges_set",_wrap_CvSubdiv2D_typed_edges_set,0,0,2,_wrap_CvSubdiv2D_typed_edges_set_texinfo}, +{"new_CvSubdiv2D",_wrap_new_CvSubdiv2D,0,0,2,_wrap_new_CvSubdiv2D_texinfo}, +{"delete_CvSubdiv2D",_wrap_delete_CvSubdiv2D,0,0,2,_wrap_delete_CvSubdiv2D_texinfo}, +{"CvMatrix3_m_set",_wrap_CvMatrix3_m_set,0,0,2,0}, +{"CvMatrix3_m_get",_wrap_CvMatrix3_m_get,0,0,2,0}, +{"new_CvMatrix3",_wrap_new_CvMatrix3,0,0,2,_wrap_new_CvMatrix3_texinfo}, +{"delete_CvMatrix3",_wrap_delete_CvMatrix3,0,0,2,_wrap_delete_CvMatrix3_texinfo}, +{"CvConDensation_MP_set",_wrap_CvConDensation_MP_set,0,0,2,0}, +{"CvConDensation_MP_get",_wrap_CvConDensation_MP_get,0,0,2,0}, +{"CvConDensation_DP_set",_wrap_CvConDensation_DP_set,0,0,2,0}, +{"CvConDensation_DP_get",_wrap_CvConDensation_DP_get,0,0,2,0}, +{"CvConDensation_DynamMatr_set",_wrap_CvConDensation_DynamMatr_set,0,0,2,0}, +{"CvConDensation_DynamMatr_get",_wrap_CvConDensation_DynamMatr_get,0,0,2,0}, +{"CvConDensation_State_set",_wrap_CvConDensation_State_set,0,0,2,0}, +{"CvConDensation_State_get",_wrap_CvConDensation_State_get,0,0,2,0}, +{"CvConDensation_SamplesNum_set",_wrap_CvConDensation_SamplesNum_set,0,0,2,0}, +{"CvConDensation_SamplesNum_get",_wrap_CvConDensation_SamplesNum_get,0,0,2,0}, +{"CvConDensation_flSamples_set",_wrap_CvConDensation_flSamples_set,0,0,2,0}, +{"CvConDensation_flSamples_get",_wrap_CvConDensation_flSamples_get,0,0,2,0}, +{"CvConDensation_flNewSamples_set",_wrap_CvConDensation_flNewSamples_set,0,0,2,0}, +{"CvConDensation_flNewSamples_get",_wrap_CvConDensation_flNewSamples_get,0,0,2,0}, +{"CvConDensation_flConfidence_set",_wrap_CvConDensation_flConfidence_set,0,0,2,0}, +{"CvConDensation_flConfidence_get",_wrap_CvConDensation_flConfidence_get,0,0,2,0}, +{"CvConDensation_flCumulative_set",_wrap_CvConDensation_flCumulative_set,0,0,2,0}, +{"CvConDensation_flCumulative_get",_wrap_CvConDensation_flCumulative_get,0,0,2,0}, +{"CvConDensation_Temp_set",_wrap_CvConDensation_Temp_set,0,0,2,0}, +{"CvConDensation_Temp_get",_wrap_CvConDensation_Temp_get,0,0,2,0}, +{"CvConDensation_RandomSample_set",_wrap_CvConDensation_RandomSample_set,0,0,2,0}, +{"CvConDensation_RandomSample_get",_wrap_CvConDensation_RandomSample_get,0,0,2,0}, +{"CvConDensation_RandS_set",_wrap_CvConDensation_RandS_set,0,0,2,0}, +{"CvConDensation_RandS_get",_wrap_CvConDensation_RandS_get,0,0,2,0}, +{"delete_CvConDensation",_wrap_delete_CvConDensation,0,0,2,_wrap_delete_CvConDensation_texinfo}, +{"CvKalman_MP_set",_wrap_CvKalman_MP_set,0,0,2,0}, +{"CvKalman_MP_get",_wrap_CvKalman_MP_get,0,0,2,0}, +{"CvKalman_DP_set",_wrap_CvKalman_DP_set,0,0,2,0}, +{"CvKalman_DP_get",_wrap_CvKalman_DP_get,0,0,2,0}, +{"CvKalman_CP_set",_wrap_CvKalman_CP_set,0,0,2,0}, +{"CvKalman_CP_get",_wrap_CvKalman_CP_get,0,0,2,0}, +{"CvKalman_PosterState_set",_wrap_CvKalman_PosterState_set,0,0,2,0}, +{"CvKalman_PosterState_get",_wrap_CvKalman_PosterState_get,0,0,2,0}, +{"CvKalman_PriorState_set",_wrap_CvKalman_PriorState_set,0,0,2,0}, +{"CvKalman_PriorState_get",_wrap_CvKalman_PriorState_get,0,0,2,0}, +{"CvKalman_DynamMatr_set",_wrap_CvKalman_DynamMatr_set,0,0,2,0}, +{"CvKalman_DynamMatr_get",_wrap_CvKalman_DynamMatr_get,0,0,2,0}, +{"CvKalman_MeasurementMatr_set",_wrap_CvKalman_MeasurementMatr_set,0,0,2,0}, +{"CvKalman_MeasurementMatr_get",_wrap_CvKalman_MeasurementMatr_get,0,0,2,0}, +{"CvKalman_MNCovariance_set",_wrap_CvKalman_MNCovariance_set,0,0,2,0}, +{"CvKalman_MNCovariance_get",_wrap_CvKalman_MNCovariance_get,0,0,2,0}, +{"CvKalman_PNCovariance_set",_wrap_CvKalman_PNCovariance_set,0,0,2,0}, +{"CvKalman_PNCovariance_get",_wrap_CvKalman_PNCovariance_get,0,0,2,0}, +{"CvKalman_KalmGainMatr_set",_wrap_CvKalman_KalmGainMatr_set,0,0,2,0}, +{"CvKalman_KalmGainMatr_get",_wrap_CvKalman_KalmGainMatr_get,0,0,2,0}, +{"CvKalman_PriorErrorCovariance_set",_wrap_CvKalman_PriorErrorCovariance_set,0,0,2,0}, +{"CvKalman_PriorErrorCovariance_get",_wrap_CvKalman_PriorErrorCovariance_get,0,0,2,0}, +{"CvKalman_PosterErrorCovariance_set",_wrap_CvKalman_PosterErrorCovariance_set,0,0,2,0}, +{"CvKalman_PosterErrorCovariance_get",_wrap_CvKalman_PosterErrorCovariance_get,0,0,2,0}, +{"CvKalman_Temp1_set",_wrap_CvKalman_Temp1_set,0,0,2,0}, +{"CvKalman_Temp1_get",_wrap_CvKalman_Temp1_get,0,0,2,0}, +{"CvKalman_Temp2_set",_wrap_CvKalman_Temp2_set,0,0,2,0}, +{"CvKalman_Temp2_get",_wrap_CvKalman_Temp2_get,0,0,2,0}, +{"CvKalman_state_pre_set",_wrap_CvKalman_state_pre_set,0,0,2,0}, +{"CvKalman_state_pre_get",_wrap_CvKalman_state_pre_get,0,0,2,0}, +{"CvKalman_state_post_set",_wrap_CvKalman_state_post_set,0,0,2,0}, +{"CvKalman_state_post_get",_wrap_CvKalman_state_post_get,0,0,2,0}, +{"CvKalman_transition_matrix_set",_wrap_CvKalman_transition_matrix_set,0,0,2,0}, +{"CvKalman_transition_matrix_get",_wrap_CvKalman_transition_matrix_get,0,0,2,0}, +{"CvKalman_control_matrix_set",_wrap_CvKalman_control_matrix_set,0,0,2,0}, +{"CvKalman_control_matrix_get",_wrap_CvKalman_control_matrix_get,0,0,2,0}, +{"CvKalman_measurement_matrix_set",_wrap_CvKalman_measurement_matrix_set,0,0,2,0}, +{"CvKalman_measurement_matrix_get",_wrap_CvKalman_measurement_matrix_get,0,0,2,0}, +{"CvKalman_process_noise_cov_set",_wrap_CvKalman_process_noise_cov_set,0,0,2,0}, +{"CvKalman_process_noise_cov_get",_wrap_CvKalman_process_noise_cov_get,0,0,2,0}, +{"CvKalman_measurement_noise_cov_set",_wrap_CvKalman_measurement_noise_cov_set,0,0,2,0}, +{"CvKalman_measurement_noise_cov_get",_wrap_CvKalman_measurement_noise_cov_get,0,0,2,0}, +{"CvKalman_error_cov_pre_set",_wrap_CvKalman_error_cov_pre_set,0,0,2,0}, +{"CvKalman_error_cov_pre_get",_wrap_CvKalman_error_cov_pre_get,0,0,2,0}, +{"CvKalman_gain_set",_wrap_CvKalman_gain_set,0,0,2,0}, +{"CvKalman_gain_get",_wrap_CvKalman_gain_get,0,0,2,0}, +{"CvKalman_error_cov_post_set",_wrap_CvKalman_error_cov_post_set,0,0,2,0}, +{"CvKalman_error_cov_post_get",_wrap_CvKalman_error_cov_post_get,0,0,2,0}, +{"CvKalman_temp1_set",_wrap_CvKalman_temp1_set,0,0,2,0}, +{"CvKalman_temp1_get",_wrap_CvKalman_temp1_get,0,0,2,0}, +{"CvKalman_temp2_set",_wrap_CvKalman_temp2_set,0,0,2,0}, +{"CvKalman_temp2_get",_wrap_CvKalman_temp2_get,0,0,2,0}, +{"CvKalman_temp3_set",_wrap_CvKalman_temp3_set,0,0,2,0}, +{"CvKalman_temp3_get",_wrap_CvKalman_temp3_get,0,0,2,0}, +{"CvKalman_temp4_set",_wrap_CvKalman_temp4_set,0,0,2,0}, +{"CvKalman_temp4_get",_wrap_CvKalman_temp4_get,0,0,2,0}, +{"CvKalman_temp5_set",_wrap_CvKalman_temp5_set,0,0,2,0}, +{"CvKalman_temp5_get",_wrap_CvKalman_temp5_get,0,0,2,0}, +{"delete_CvKalman",_wrap_delete_CvKalman,0,0,2,_wrap_delete_CvKalman_texinfo}, +{"CvHaarFeature_tilted_set",_wrap_CvHaarFeature_tilted_set,0,0,2,0}, +{"CvHaarFeature_tilted_get",_wrap_CvHaarFeature_tilted_get,0,0,2,0}, +{"CvHaarFeature_rect_get",_wrap_CvHaarFeature_rect_get,0,0,2,0}, +{"new_CvHaarFeature",_wrap_new_CvHaarFeature,0,0,2,_wrap_new_CvHaarFeature_texinfo}, +{"delete_CvHaarFeature",_wrap_delete_CvHaarFeature,0,0,2,_wrap_delete_CvHaarFeature_texinfo}, +{"CvHaarFeature_rect_r_set",_wrap_CvHaarFeature_rect_r_set,0,0,2,0}, +{"CvHaarFeature_rect_r_get",_wrap_CvHaarFeature_rect_r_get,0,0,2,0}, +{"CvHaarFeature_rect_weight_set",_wrap_CvHaarFeature_rect_weight_set,0,0,2,0}, +{"CvHaarFeature_rect_weight_get",_wrap_CvHaarFeature_rect_weight_get,0,0,2,0}, +{"new_CvHaarFeature_rect",_wrap_new_CvHaarFeature_rect,0,0,2,_wrap_new_CvHaarFeature_rect_texinfo}, +{"delete_CvHaarFeature_rect",_wrap_delete_CvHaarFeature_rect,0,0,2,_wrap_delete_CvHaarFeature_rect_texinfo}, +{"CvHaarClassifier_count_set",_wrap_CvHaarClassifier_count_set,0,0,2,0}, +{"CvHaarClassifier_count_get",_wrap_CvHaarClassifier_count_get,0,0,2,0}, +{"CvHaarClassifier_haar_feature_set",_wrap_CvHaarClassifier_haar_feature_set,0,0,2,0}, +{"CvHaarClassifier_haar_feature_get",_wrap_CvHaarClassifier_haar_feature_get,0,0,2,0}, +{"CvHaarClassifier_threshold_set",_wrap_CvHaarClassifier_threshold_set,0,0,2,0}, +{"CvHaarClassifier_threshold_get",_wrap_CvHaarClassifier_threshold_get,0,0,2,0}, +{"CvHaarClassifier_left_set",_wrap_CvHaarClassifier_left_set,0,0,2,0}, +{"CvHaarClassifier_left_get",_wrap_CvHaarClassifier_left_get,0,0,2,0}, +{"CvHaarClassifier_right_set",_wrap_CvHaarClassifier_right_set,0,0,2,0}, +{"CvHaarClassifier_right_get",_wrap_CvHaarClassifier_right_get,0,0,2,0}, +{"CvHaarClassifier_alpha_set",_wrap_CvHaarClassifier_alpha_set,0,0,2,0}, +{"CvHaarClassifier_alpha_get",_wrap_CvHaarClassifier_alpha_get,0,0,2,0}, +{"new_CvHaarClassifier",_wrap_new_CvHaarClassifier,0,0,2,_wrap_new_CvHaarClassifier_texinfo}, +{"delete_CvHaarClassifier",_wrap_delete_CvHaarClassifier,0,0,2,_wrap_delete_CvHaarClassifier_texinfo}, +{"CvHaarStageClassifier_count_set",_wrap_CvHaarStageClassifier_count_set,0,0,2,0}, +{"CvHaarStageClassifier_count_get",_wrap_CvHaarStageClassifier_count_get,0,0,2,0}, +{"CvHaarStageClassifier_threshold_set",_wrap_CvHaarStageClassifier_threshold_set,0,0,2,0}, +{"CvHaarStageClassifier_threshold_get",_wrap_CvHaarStageClassifier_threshold_get,0,0,2,0}, +{"CvHaarStageClassifier_classifier_set",_wrap_CvHaarStageClassifier_classifier_set,0,0,2,0}, +{"CvHaarStageClassifier_classifier_get",_wrap_CvHaarStageClassifier_classifier_get,0,0,2,0}, +{"CvHaarStageClassifier_next_set",_wrap_CvHaarStageClassifier_next_set,0,0,2,0}, +{"CvHaarStageClassifier_next_get",_wrap_CvHaarStageClassifier_next_get,0,0,2,0}, +{"CvHaarStageClassifier_child_set",_wrap_CvHaarStageClassifier_child_set,0,0,2,0}, +{"CvHaarStageClassifier_child_get",_wrap_CvHaarStageClassifier_child_get,0,0,2,0}, +{"CvHaarStageClassifier_parent_set",_wrap_CvHaarStageClassifier_parent_set,0,0,2,0}, +{"CvHaarStageClassifier_parent_get",_wrap_CvHaarStageClassifier_parent_get,0,0,2,0}, +{"new_CvHaarStageClassifier",_wrap_new_CvHaarStageClassifier,0,0,2,_wrap_new_CvHaarStageClassifier_texinfo}, +{"delete_CvHaarStageClassifier",_wrap_delete_CvHaarStageClassifier,0,0,2,_wrap_delete_CvHaarStageClassifier_texinfo}, +{"CvHaarClassifierCascade_flags_set",_wrap_CvHaarClassifierCascade_flags_set,0,0,2,0}, +{"CvHaarClassifierCascade_flags_get",_wrap_CvHaarClassifierCascade_flags_get,0,0,2,0}, +{"CvHaarClassifierCascade_count_set",_wrap_CvHaarClassifierCascade_count_set,0,0,2,0}, +{"CvHaarClassifierCascade_count_get",_wrap_CvHaarClassifierCascade_count_get,0,0,2,0}, +{"CvHaarClassifierCascade_orig_window_size_set",_wrap_CvHaarClassifierCascade_orig_window_size_set,0,0,2,0}, +{"CvHaarClassifierCascade_orig_window_size_get",_wrap_CvHaarClassifierCascade_orig_window_size_get,0,0,2,0}, +{"CvHaarClassifierCascade_real_window_size_set",_wrap_CvHaarClassifierCascade_real_window_size_set,0,0,2,0}, +{"CvHaarClassifierCascade_real_window_size_get",_wrap_CvHaarClassifierCascade_real_window_size_get,0,0,2,0}, +{"CvHaarClassifierCascade_scale_set",_wrap_CvHaarClassifierCascade_scale_set,0,0,2,0}, +{"CvHaarClassifierCascade_scale_get",_wrap_CvHaarClassifierCascade_scale_get,0,0,2,0}, +{"CvHaarClassifierCascade_stage_classifier_set",_wrap_CvHaarClassifierCascade_stage_classifier_set,0,0,2,0}, +{"CvHaarClassifierCascade_stage_classifier_get",_wrap_CvHaarClassifierCascade_stage_classifier_get,0,0,2,0}, +{"CvHaarClassifierCascade_hid_cascade_set",_wrap_CvHaarClassifierCascade_hid_cascade_set,0,0,2,0}, +{"CvHaarClassifierCascade_hid_cascade_get",_wrap_CvHaarClassifierCascade_hid_cascade_get,0,0,2,0}, +{"delete_CvHaarClassifierCascade",_wrap_delete_CvHaarClassifierCascade,0,0,2,_wrap_delete_CvHaarClassifierCascade_texinfo}, +{"CvAvgComp_rect_set",_wrap_CvAvgComp_rect_set,0,0,2,0}, +{"CvAvgComp_rect_get",_wrap_CvAvgComp_rect_get,0,0,2,0}, +{"CvAvgComp_neighbors_set",_wrap_CvAvgComp_neighbors_set,0,0,2,0}, +{"CvAvgComp_neighbors_get",_wrap_CvAvgComp_neighbors_get,0,0,2,0}, +{"new_CvAvgComp",_wrap_new_CvAvgComp,0,0,2,_wrap_new_CvAvgComp_texinfo}, +{"delete_CvAvgComp",_wrap_delete_CvAvgComp,0,0,2,_wrap_delete_CvAvgComp_texinfo}, +{"cvCopyMakeBorder",_wrap_cvCopyMakeBorder,0,0,2,_wrap_cvCopyMakeBorder_texinfo}, +{"cvSmooth",_wrap_cvSmooth,0,0,2,_wrap_cvSmooth_texinfo}, +{"cvFilter2D",_wrap_cvFilter2D,0,0,2,_wrap_cvFilter2D_texinfo}, +{"cvIntegral",_wrap_cvIntegral,0,0,2,_wrap_cvIntegral_texinfo}, +{"cvPyrDown",_wrap_cvPyrDown,0,0,2,_wrap_cvPyrDown_texinfo}, +{"cvPyrUp",_wrap_cvPyrUp,0,0,2,_wrap_cvPyrUp_texinfo}, +{"cvCreatePyramid",_wrap_cvCreatePyramid,0,0,2,_wrap_cvCreatePyramid_texinfo}, +{"cvReleasePyramid",_wrap_cvReleasePyramid,0,0,2,_wrap_cvReleasePyramid_texinfo}, +{"cvPyrSegmentationUntyped",_wrap_cvPyrSegmentationUntyped,0,0,2,_wrap_cvPyrSegmentationUntyped_texinfo}, +{"cvPyrMeanShiftFiltering",_wrap_cvPyrMeanShiftFiltering,0,0,2,_wrap_cvPyrMeanShiftFiltering_texinfo}, +{"cvWatershed",_wrap_cvWatershed,0,0,2,_wrap_cvWatershed_texinfo}, +{"cvInpaint",_wrap_cvInpaint,0,0,2,_wrap_cvInpaint_texinfo}, +{"cvSobel",_wrap_cvSobel,0,0,2,_wrap_cvSobel_texinfo}, +{"cvLaplace",_wrap_cvLaplace,0,0,2,_wrap_cvLaplace_texinfo}, +{"cvCvtColor",_wrap_cvCvtColor,0,0,2,_wrap_cvCvtColor_texinfo}, +{"cvResize",_wrap_cvResize,0,0,2,_wrap_cvResize_texinfo}, +{"cvWarpAffine",_wrap_cvWarpAffine,0,0,2,_wrap_cvWarpAffine_texinfo}, +{"cvGetAffineTransform",_wrap_cvGetAffineTransform,0,0,2,_wrap_cvGetAffineTransform_texinfo}, +{"cv2DRotationMatrix",_wrap_cv2DRotationMatrix,0,0,2,_wrap_cv2DRotationMatrix_texinfo}, +{"cvWarpPerspective",_wrap_cvWarpPerspective,0,0,2,_wrap_cvWarpPerspective_texinfo}, +{"cvGetPerspectiveTransform",_wrap_cvGetPerspectiveTransform,0,0,2,_wrap_cvGetPerspectiveTransform_texinfo}, +{"cvRemap",_wrap_cvRemap,0,0,2,_wrap_cvRemap_texinfo}, +{"cvConvertMaps",_wrap_cvConvertMaps,0,0,2,_wrap_cvConvertMaps_texinfo}, +{"cvLogPolar",_wrap_cvLogPolar,0,0,2,_wrap_cvLogPolar_texinfo}, +{"cvLinearPolar",_wrap_cvLinearPolar,0,0,2,_wrap_cvLinearPolar_texinfo}, +{"cvCreateStructuringElementEx",_wrap_cvCreateStructuringElementEx,0,0,2,_wrap_cvCreateStructuringElementEx_texinfo}, +{"cvReleaseStructuringElement",_wrap_cvReleaseStructuringElement,0,0,2,_wrap_cvReleaseStructuringElement_texinfo}, +{"cvErode",_wrap_cvErode,0,0,2,_wrap_cvErode_texinfo}, +{"cvDilate",_wrap_cvDilate,0,0,2,_wrap_cvDilate_texinfo}, +{"cvMorphologyEx",_wrap_cvMorphologyEx,0,0,2,_wrap_cvMorphologyEx_texinfo}, +{"cvMoments",_wrap_cvMoments,0,0,2,_wrap_cvMoments_texinfo}, +{"cvGetSpatialMoment",_wrap_cvGetSpatialMoment,0,0,2,_wrap_cvGetSpatialMoment_texinfo}, +{"cvGetCentralMoment",_wrap_cvGetCentralMoment,0,0,2,_wrap_cvGetCentralMoment_texinfo}, +{"cvGetNormalizedCentralMoment",_wrap_cvGetNormalizedCentralMoment,0,0,2,_wrap_cvGetNormalizedCentralMoment_texinfo}, +{"cvGetHuMoments",_wrap_cvGetHuMoments,0,0,2,_wrap_cvGetHuMoments_texinfo}, +{"cvSampleLine",_wrap_cvSampleLine,0,0,2,_wrap_cvSampleLine_texinfo}, +{"cvGetRectSubPix",_wrap_cvGetRectSubPix,0,0,2,_wrap_cvGetRectSubPix_texinfo}, +{"cvGetQuadrangleSubPix",_wrap_cvGetQuadrangleSubPix,0,0,2,_wrap_cvGetQuadrangleSubPix_texinfo}, +{"cvMatchTemplate",_wrap_cvMatchTemplate,0,0,2,_wrap_cvMatchTemplate_texinfo}, +{"cvCalcEMD2",_wrap_cvCalcEMD2,0,0,2,_wrap_cvCalcEMD2_texinfo}, +{"cvFindContoursUntyped",_wrap_cvFindContoursUntyped,0,0,2,_wrap_cvFindContoursUntyped_texinfo}, +{"cvStartFindContours",_wrap_cvStartFindContours,0,0,2,_wrap_cvStartFindContours_texinfo}, +{"cvFindNextContour",_wrap_cvFindNextContour,0,0,2,_wrap_cvFindNextContour_texinfo}, +{"cvSubstituteContour",_wrap_cvSubstituteContour,0,0,2,_wrap_cvSubstituteContour_texinfo}, +{"cvEndFindContours",_wrap_cvEndFindContours,0,0,2,_wrap_cvEndFindContours_texinfo}, +{"cvApproxChainsUntyped",_wrap_cvApproxChainsUntyped,0,0,2,_wrap_cvApproxChainsUntyped_texinfo}, +{"cvStartReadChainPoints",_wrap_cvStartReadChainPoints,0,0,2,_wrap_cvStartReadChainPoints_texinfo}, +{"cvReadChainPoint",_wrap_cvReadChainPoint,0,0,2,_wrap_cvReadChainPoint_texinfo}, +{"cvCalcOpticalFlowLK",_wrap_cvCalcOpticalFlowLK,0,0,2,_wrap_cvCalcOpticalFlowLK_texinfo}, +{"cvCalcOpticalFlowBM",_wrap_cvCalcOpticalFlowBM,0,0,2,_wrap_cvCalcOpticalFlowBM_texinfo}, +{"cvCalcOpticalFlowHS",_wrap_cvCalcOpticalFlowHS,0,0,2,_wrap_cvCalcOpticalFlowHS_texinfo}, +{"cvCalcOpticalFlowPyrLK",_wrap_cvCalcOpticalFlowPyrLK,0,0,2,_wrap_cvCalcOpticalFlowPyrLK_texinfo}, +{"cvCalcAffineFlowPyrLK",_wrap_cvCalcAffineFlowPyrLK,0,0,2,_wrap_cvCalcAffineFlowPyrLK_texinfo}, +{"cvEstimateRigidTransform",_wrap_cvEstimateRigidTransform,0,0,2,_wrap_cvEstimateRigidTransform_texinfo}, +{"cvUpdateMotionHistory",_wrap_cvUpdateMotionHistory,0,0,2,_wrap_cvUpdateMotionHistory_texinfo}, +{"cvCalcMotionGradient",_wrap_cvCalcMotionGradient,0,0,2,_wrap_cvCalcMotionGradient_texinfo}, +{"cvCalcGlobalOrientation",_wrap_cvCalcGlobalOrientation,0,0,2,_wrap_cvCalcGlobalOrientation_texinfo}, +{"cvAcc",_wrap_cvAcc,0,0,2,_wrap_cvAcc_texinfo}, +{"cvSquareAcc",_wrap_cvSquareAcc,0,0,2,_wrap_cvSquareAcc_texinfo}, +{"cvMultiplyAcc",_wrap_cvMultiplyAcc,0,0,2,_wrap_cvMultiplyAcc_texinfo}, +{"cvRunningAvg",_wrap_cvRunningAvg,0,0,2,_wrap_cvRunningAvg_texinfo}, +{"cvCamShift",_wrap_cvCamShift,0,0,2,_wrap_cvCamShift_texinfo}, +{"cvMeanShift",_wrap_cvMeanShift,0,0,2,_wrap_cvMeanShift_texinfo}, +{"cvCreateConDensation",_wrap_cvCreateConDensation,0,0,2,_wrap_cvCreateConDensation_texinfo}, +{"cvReleaseConDensation",_wrap_cvReleaseConDensation,0,0,2,_wrap_cvReleaseConDensation_texinfo}, +{"cvConDensUpdateByTime",_wrap_cvConDensUpdateByTime,0,0,2,_wrap_cvConDensUpdateByTime_texinfo}, +{"cvConDensInitSampleSet",_wrap_cvConDensInitSampleSet,0,0,2,_wrap_cvConDensInitSampleSet_texinfo}, +{"cvCreateKalman",_wrap_cvCreateKalman,0,0,2,_wrap_cvCreateKalman_texinfo}, +{"cvReleaseKalman",_wrap_cvReleaseKalman,0,0,2,_wrap_cvReleaseKalman_texinfo}, +{"cvKalmanPredict",_wrap_cvKalmanPredict,0,0,2,_wrap_cvKalmanPredict_texinfo}, +{"cvKalmanCorrect",_wrap_cvKalmanCorrect,0,0,2,_wrap_cvKalmanCorrect_texinfo}, +{"cvInitSubdivDelaunay2D",_wrap_cvInitSubdivDelaunay2D,0,0,2,_wrap_cvInitSubdivDelaunay2D_texinfo}, +{"cvCreateSubdiv2D",_wrap_cvCreateSubdiv2D,0,0,2,_wrap_cvCreateSubdiv2D_texinfo}, +{"cvCreateSubdivDelaunay2D",_wrap_cvCreateSubdivDelaunay2D,0,0,2,_wrap_cvCreateSubdivDelaunay2D_texinfo}, +{"cvSubdivDelaunay2DInsert",_wrap_cvSubdivDelaunay2DInsert,0,0,2,_wrap_cvSubdivDelaunay2DInsert_texinfo}, +{"cvSubdiv2DLocate",_wrap_cvSubdiv2DLocate,0,0,2,_wrap_cvSubdiv2DLocate_texinfo}, +{"cvCalcSubdivVoronoi2D",_wrap_cvCalcSubdivVoronoi2D,0,0,2,_wrap_cvCalcSubdivVoronoi2D_texinfo}, +{"cvClearSubdivVoronoi2D",_wrap_cvClearSubdivVoronoi2D,0,0,2,_wrap_cvClearSubdivVoronoi2D_texinfo}, +{"cvFindNearestPoint2D",_wrap_cvFindNearestPoint2D,0,0,2,_wrap_cvFindNearestPoint2D_texinfo}, +{"cvSubdiv2DNextEdge",_wrap_cvSubdiv2DNextEdge,0,0,2,_wrap_cvSubdiv2DNextEdge_texinfo}, +{"cvSubdiv2DRotateEdge",_wrap_cvSubdiv2DRotateEdge,0,0,2,_wrap_cvSubdiv2DRotateEdge_texinfo}, +{"cvSubdiv2DSymEdge",_wrap_cvSubdiv2DSymEdge,0,0,2,_wrap_cvSubdiv2DSymEdge_texinfo}, +{"cvSubdiv2DGetEdge",_wrap_cvSubdiv2DGetEdge,0,0,2,_wrap_cvSubdiv2DGetEdge_texinfo}, +{"cvSubdiv2DEdgeOrg",_wrap_cvSubdiv2DEdgeOrg,0,0,2,_wrap_cvSubdiv2DEdgeOrg_texinfo}, +{"cvSubdiv2DEdgeDst",_wrap_cvSubdiv2DEdgeDst,0,0,2,_wrap_cvSubdiv2DEdgeDst_texinfo}, +{"cvTriangleArea",_wrap_cvTriangleArea,0,0,2,_wrap_cvTriangleArea_texinfo}, +{"cvFindDominantPoints",_wrap_cvFindDominantPoints,0,0,2,_wrap_cvFindDominantPoints_texinfo}, +{"cvBoundingRect",_wrap_cvBoundingRect,0,0,2,_wrap_cvBoundingRect_texinfo}, +{"cvContourArea",_wrap_cvContourArea,0,0,2,_wrap_cvContourArea_texinfo}, +{"cvMinAreaRect2",_wrap_cvMinAreaRect2,0,0,2,_wrap_cvMinAreaRect2_texinfo}, +{"cvMinEnclosingCircle",_wrap_cvMinEnclosingCircle,0,0,2,_wrap_cvMinEnclosingCircle_texinfo}, +{"cvMatchShapes",_wrap_cvMatchShapes,0,0,2,_wrap_cvMatchShapes_texinfo}, +{"cvCreateContourTree",_wrap_cvCreateContourTree,0,0,2,_wrap_cvCreateContourTree_texinfo}, +{"cvContourFromContourTreeUntyped",_wrap_cvContourFromContourTreeUntyped,0,0,2,_wrap_cvContourFromContourTreeUntyped_texinfo}, +{"cvMatchContourTrees",_wrap_cvMatchContourTrees,0,0,2,_wrap_cvMatchContourTrees_texinfo}, +{"cvCalcPGH",_wrap_cvCalcPGH,0,0,2,_wrap_cvCalcPGH_texinfo}, +{"cvCheckContourConvexity",_wrap_cvCheckContourConvexity,0,0,2,_wrap_cvCheckContourConvexity_texinfo}, +{"cvConvexityDefectsUntyped",_wrap_cvConvexityDefectsUntyped,0,0,2,_wrap_cvConvexityDefectsUntyped_texinfo}, +{"cvFitEllipse2",_wrap_cvFitEllipse2,0,0,2,_wrap_cvFitEllipse2_texinfo}, +{"cvMaxRect",_wrap_cvMaxRect,0,0,2,_wrap_cvMaxRect_texinfo}, +{"cvBoxPoints",_wrap_cvBoxPoints,0,0,2,_wrap_cvBoxPoints_texinfo}, +{"cvPointSeqFromMat",_wrap_cvPointSeqFromMat,0,0,2,_wrap_cvPointSeqFromMat_texinfo}, +{"cvPointPolygonTest",_wrap_cvPointPolygonTest,0,0,2,_wrap_cvPointPolygonTest_texinfo}, +{"cvCreateHist",_wrap_cvCreateHist,0,0,2,_wrap_cvCreateHist_texinfo}, +{"cvSetHistBinRanges",_wrap_cvSetHistBinRanges,0,0,2,_wrap_cvSetHistBinRanges_texinfo}, +{"cvMakeHistHeaderForArray",_wrap_cvMakeHistHeaderForArray,0,0,2,_wrap_cvMakeHistHeaderForArray_texinfo}, +{"cvReleaseHist",_wrap_cvReleaseHist,0,0,2,_wrap_cvReleaseHist_texinfo}, +{"cvClearHist",_wrap_cvClearHist,0,0,2,_wrap_cvClearHist_texinfo}, +{"cvGetMinMaxHistValue",_wrap_cvGetMinMaxHistValue,0,0,2,_wrap_cvGetMinMaxHistValue_texinfo}, +{"cvNormalizeHist",_wrap_cvNormalizeHist,0,0,2,_wrap_cvNormalizeHist_texinfo}, +{"cvThreshHist",_wrap_cvThreshHist,0,0,2,_wrap_cvThreshHist_texinfo}, +{"cvCompareHist",_wrap_cvCompareHist,0,0,2,_wrap_cvCompareHist_texinfo}, +{"cvCopyHist",_wrap_cvCopyHist,0,0,2,_wrap_cvCopyHist_texinfo}, +{"cvCalcBayesianProb",_wrap_cvCalcBayesianProb,0,0,2,_wrap_cvCalcBayesianProb_texinfo}, +{"cvCalcArrHist",_wrap_cvCalcArrHist,0,0,2,_wrap_cvCalcArrHist_texinfo}, +{"cvCalcImageHist",_wrap_cvCalcImageHist,0,0,2,_wrap_cvCalcImageHist_texinfo}, +{"cvCalcArrBackProject",_wrap_cvCalcArrBackProject,0,0,2,_wrap_cvCalcArrBackProject_texinfo}, +{"cvCalcArrBackProjectPatch",_wrap_cvCalcArrBackProjectPatch,0,0,2,_wrap_cvCalcArrBackProjectPatch_texinfo}, +{"cvCalcProbDensity",_wrap_cvCalcProbDensity,0,0,2,_wrap_cvCalcProbDensity_texinfo}, +{"cvEqualizeHist",_wrap_cvEqualizeHist,0,0,2,_wrap_cvEqualizeHist_texinfo}, +{"cvCalcImageHomography",_wrap_cvCalcImageHomography,0,0,2,_wrap_cvCalcImageHomography_texinfo}, +{"cvDistTransform",_wrap_cvDistTransform,0,0,2,_wrap_cvDistTransform_texinfo}, +{"cvThreshold",_wrap_cvThreshold,0,0,2,_wrap_cvThreshold_texinfo}, +{"cvAdaptiveThreshold",_wrap_cvAdaptiveThreshold,0,0,2,_wrap_cvAdaptiveThreshold_texinfo}, +{"cvFloodFill",_wrap_cvFloodFill,0,0,2,_wrap_cvFloodFill_texinfo}, +{"cvCanny",_wrap_cvCanny,0,0,2,_wrap_cvCanny_texinfo}, +{"cvPreCornerDetect",_wrap_cvPreCornerDetect,0,0,2,_wrap_cvPreCornerDetect_texinfo}, +{"cvCornerEigenValsAndVecs",_wrap_cvCornerEigenValsAndVecs,0,0,2,_wrap_cvCornerEigenValsAndVecs_texinfo}, +{"cvCornerMinEigenVal",_wrap_cvCornerMinEigenVal,0,0,2,_wrap_cvCornerMinEigenVal_texinfo}, +{"cvCornerHarris",_wrap_cvCornerHarris,0,0,2,_wrap_cvCornerHarris_texinfo}, +{"cvFindCornerSubPix",_wrap_cvFindCornerSubPix,0,0,2,_wrap_cvFindCornerSubPix_texinfo}, +{"cvGoodFeaturesToTrack",_wrap_cvGoodFeaturesToTrack,0,0,2,_wrap_cvGoodFeaturesToTrack_texinfo}, +{"cvHoughLinesUntyped",_wrap_cvHoughLinesUntyped,0,0,2,_wrap_cvHoughLinesUntyped_texinfo}, +{"cvHoughCirclesUntyped",_wrap_cvHoughCirclesUntyped,0,0,2,_wrap_cvHoughCirclesUntyped_texinfo}, +{"cvFitLine",_wrap_cvFitLine,0,0,2,_wrap_cvFitLine_texinfo}, +{"cvCreateKDTree",_wrap_cvCreateKDTree,0,0,2,_wrap_cvCreateKDTree_texinfo}, +{"cvCreateSpillTree",_wrap_cvCreateSpillTree,0,0,2,_wrap_cvCreateSpillTree_texinfo}, +{"cvReleaseFeatureTree",_wrap_cvReleaseFeatureTree,0,0,2,_wrap_cvReleaseFeatureTree_texinfo}, +{"cvFindFeatures",_wrap_cvFindFeatures,0,0,2,_wrap_cvFindFeatures_texinfo}, +{"cvFindFeaturesBoxed",_wrap_cvFindFeaturesBoxed,0,0,2,_wrap_cvFindFeaturesBoxed_texinfo}, +{"cvCreateLSH",_wrap_cvCreateLSH,0,0,2,_wrap_cvCreateLSH_texinfo}, +{"cvCreateMemoryLSH",_wrap_cvCreateMemoryLSH,0,0,2,_wrap_cvCreateMemoryLSH_texinfo}, +{"cvReleaseLSH",_wrap_cvReleaseLSH,0,0,2,_wrap_cvReleaseLSH_texinfo}, +{"LSHSize",_wrap_LSHSize,0,0,2,_wrap_LSHSize_texinfo}, +{"cvLSHAdd",_wrap_cvLSHAdd,0,0,2,_wrap_cvLSHAdd_texinfo}, +{"cvLSHRemove",_wrap_cvLSHRemove,0,0,2,_wrap_cvLSHRemove_texinfo}, +{"cvLSHQuery",_wrap_cvLSHQuery,0,0,2,_wrap_cvLSHQuery_texinfo}, +{"CvSURFPoint_pt_set",_wrap_CvSURFPoint_pt_set,0,0,2,0}, +{"CvSURFPoint_pt_get",_wrap_CvSURFPoint_pt_get,0,0,2,0}, +{"CvSURFPoint_laplacian_set",_wrap_CvSURFPoint_laplacian_set,0,0,2,0}, +{"CvSURFPoint_laplacian_get",_wrap_CvSURFPoint_laplacian_get,0,0,2,0}, +{"CvSURFPoint_size_set",_wrap_CvSURFPoint_size_set,0,0,2,0}, +{"CvSURFPoint_size_get",_wrap_CvSURFPoint_size_get,0,0,2,0}, +{"CvSURFPoint_dir_set",_wrap_CvSURFPoint_dir_set,0,0,2,0}, +{"CvSURFPoint_dir_get",_wrap_CvSURFPoint_dir_get,0,0,2,0}, +{"CvSURFPoint_hessian_set",_wrap_CvSURFPoint_hessian_set,0,0,2,0}, +{"CvSURFPoint_hessian_get",_wrap_CvSURFPoint_hessian_get,0,0,2,0}, +{"new_CvSURFPoint",_wrap_new_CvSURFPoint,0,0,2,_wrap_new_CvSURFPoint_texinfo}, +{"delete_CvSURFPoint",_wrap_delete_CvSURFPoint,0,0,2,_wrap_delete_CvSURFPoint_texinfo}, +{"cvSURFPoint",_wrap_cvSURFPoint,0,0,2,_wrap_cvSURFPoint_texinfo}, +{"CvSURFParams_extended_set",_wrap_CvSURFParams_extended_set,0,0,2,0}, +{"CvSURFParams_extended_get",_wrap_CvSURFParams_extended_get,0,0,2,0}, +{"CvSURFParams_hessianThreshold_set",_wrap_CvSURFParams_hessianThreshold_set,0,0,2,0}, +{"CvSURFParams_hessianThreshold_get",_wrap_CvSURFParams_hessianThreshold_get,0,0,2,0}, +{"CvSURFParams_nOctaves_set",_wrap_CvSURFParams_nOctaves_set,0,0,2,0}, +{"CvSURFParams_nOctaves_get",_wrap_CvSURFParams_nOctaves_get,0,0,2,0}, +{"CvSURFParams_nOctaveLayers_set",_wrap_CvSURFParams_nOctaveLayers_set,0,0,2,0}, +{"CvSURFParams_nOctaveLayers_get",_wrap_CvSURFParams_nOctaveLayers_get,0,0,2,0}, +{"new_CvSURFParams",_wrap_new_CvSURFParams,0,0,2,_wrap_new_CvSURFParams_texinfo}, +{"delete_CvSURFParams",_wrap_delete_CvSURFParams,0,0,2,_wrap_delete_CvSURFParams_texinfo}, +{"cvSURFParams",_wrap_cvSURFParams,0,0,2,_wrap_cvSURFParams_texinfo}, +{"cvExtractSURF",_wrap_cvExtractSURF,0,0,2,_wrap_cvExtractSURF_texinfo}, +{"CvMSERParams_delta_set",_wrap_CvMSERParams_delta_set,0,0,2,0}, +{"CvMSERParams_delta_get",_wrap_CvMSERParams_delta_get,0,0,2,0}, +{"CvMSERParams_maxArea_set",_wrap_CvMSERParams_maxArea_set,0,0,2,0}, +{"CvMSERParams_maxArea_get",_wrap_CvMSERParams_maxArea_get,0,0,2,0}, +{"CvMSERParams_minArea_set",_wrap_CvMSERParams_minArea_set,0,0,2,0}, +{"CvMSERParams_minArea_get",_wrap_CvMSERParams_minArea_get,0,0,2,0}, +{"CvMSERParams_maxVariation_set",_wrap_CvMSERParams_maxVariation_set,0,0,2,0}, +{"CvMSERParams_maxVariation_get",_wrap_CvMSERParams_maxVariation_get,0,0,2,0}, +{"CvMSERParams_minDiversity_set",_wrap_CvMSERParams_minDiversity_set,0,0,2,0}, +{"CvMSERParams_minDiversity_get",_wrap_CvMSERParams_minDiversity_get,0,0,2,0}, +{"CvMSERParams_maxEvolution_set",_wrap_CvMSERParams_maxEvolution_set,0,0,2,0}, +{"CvMSERParams_maxEvolution_get",_wrap_CvMSERParams_maxEvolution_get,0,0,2,0}, +{"CvMSERParams_areaThreshold_set",_wrap_CvMSERParams_areaThreshold_set,0,0,2,0}, +{"CvMSERParams_areaThreshold_get",_wrap_CvMSERParams_areaThreshold_get,0,0,2,0}, +{"CvMSERParams_minMargin_set",_wrap_CvMSERParams_minMargin_set,0,0,2,0}, +{"CvMSERParams_minMargin_get",_wrap_CvMSERParams_minMargin_get,0,0,2,0}, +{"CvMSERParams_edgeBlurSize_set",_wrap_CvMSERParams_edgeBlurSize_set,0,0,2,0}, +{"CvMSERParams_edgeBlurSize_get",_wrap_CvMSERParams_edgeBlurSize_get,0,0,2,0}, +{"new_CvMSERParams",_wrap_new_CvMSERParams,0,0,2,_wrap_new_CvMSERParams_texinfo}, +{"delete_CvMSERParams",_wrap_delete_CvMSERParams,0,0,2,_wrap_delete_CvMSERParams_texinfo}, +{"cvMSERParams",_wrap_cvMSERParams,0,0,2,_wrap_cvMSERParams_texinfo}, +{"cvExtractMSER",_wrap_cvExtractMSER,0,0,2,_wrap_cvExtractMSER_texinfo}, +{"CvStarKeypoint_pt_set",_wrap_CvStarKeypoint_pt_set,0,0,2,0}, +{"CvStarKeypoint_pt_get",_wrap_CvStarKeypoint_pt_get,0,0,2,0}, +{"CvStarKeypoint_size_set",_wrap_CvStarKeypoint_size_set,0,0,2,0}, +{"CvStarKeypoint_size_get",_wrap_CvStarKeypoint_size_get,0,0,2,0}, +{"CvStarKeypoint_response_set",_wrap_CvStarKeypoint_response_set,0,0,2,0}, +{"CvStarKeypoint_response_get",_wrap_CvStarKeypoint_response_get,0,0,2,0}, +{"new_CvStarKeypoint",_wrap_new_CvStarKeypoint,0,0,2,_wrap_new_CvStarKeypoint_texinfo}, +{"delete_CvStarKeypoint",_wrap_delete_CvStarKeypoint,0,0,2,_wrap_delete_CvStarKeypoint_texinfo}, +{"cvStarKeypoint",_wrap_cvStarKeypoint,0,0,2,_wrap_cvStarKeypoint_texinfo}, +{"CvStarDetectorParams_maxSize_set",_wrap_CvStarDetectorParams_maxSize_set,0,0,2,0}, +{"CvStarDetectorParams_maxSize_get",_wrap_CvStarDetectorParams_maxSize_get,0,0,2,0}, +{"CvStarDetectorParams_responseThreshold_set",_wrap_CvStarDetectorParams_responseThreshold_set,0,0,2,0}, +{"CvStarDetectorParams_responseThreshold_get",_wrap_CvStarDetectorParams_responseThreshold_get,0,0,2,0}, +{"CvStarDetectorParams_lineThresholdProjected_set",_wrap_CvStarDetectorParams_lineThresholdProjected_set,0,0,2,0}, +{"CvStarDetectorParams_lineThresholdProjected_get",_wrap_CvStarDetectorParams_lineThresholdProjected_get,0,0,2,0}, +{"CvStarDetectorParams_lineThresholdBinarized_set",_wrap_CvStarDetectorParams_lineThresholdBinarized_set,0,0,2,0}, +{"CvStarDetectorParams_lineThresholdBinarized_get",_wrap_CvStarDetectorParams_lineThresholdBinarized_get,0,0,2,0}, +{"CvStarDetectorParams_suppressNonmaxSize_set",_wrap_CvStarDetectorParams_suppressNonmaxSize_set,0,0,2,0}, +{"CvStarDetectorParams_suppressNonmaxSize_get",_wrap_CvStarDetectorParams_suppressNonmaxSize_get,0,0,2,0}, +{"new_CvStarDetectorParams",_wrap_new_CvStarDetectorParams,0,0,2,_wrap_new_CvStarDetectorParams_texinfo}, +{"delete_CvStarDetectorParams",_wrap_delete_CvStarDetectorParams,0,0,2,_wrap_delete_CvStarDetectorParams_texinfo}, +{"cvStarDetectorParams",_wrap_cvStarDetectorParams,0,0,2,_wrap_cvStarDetectorParams_texinfo}, +{"cvGetStarKeypoints",_wrap_cvGetStarKeypoints,0,0,2,_wrap_cvGetStarKeypoints_texinfo}, +{"cvLoadHaarClassifierCascade",_wrap_cvLoadHaarClassifierCascade,0,0,2,_wrap_cvLoadHaarClassifierCascade_texinfo}, +{"cvReleaseHaarClassifierCascade",_wrap_cvReleaseHaarClassifierCascade,0,0,2,_wrap_cvReleaseHaarClassifierCascade_texinfo}, +{"cvSetImagesForHaarClassifierCascade",_wrap_cvSetImagesForHaarClassifierCascade,0,0,2,_wrap_cvSetImagesForHaarClassifierCascade_texinfo}, +{"cvRunHaarClassifierCascade",_wrap_cvRunHaarClassifierCascade,0,0,2,_wrap_cvRunHaarClassifierCascade_texinfo}, +{"cvUndistort2",_wrap_cvUndistort2,0,0,2,_wrap_cvUndistort2_texinfo}, +{"cvInitUndistortMap",_wrap_cvInitUndistortMap,0,0,2,_wrap_cvInitUndistortMap_texinfo}, +{"cvInitUndistortRectifyMap",_wrap_cvInitUndistortRectifyMap,0,0,2,_wrap_cvInitUndistortRectifyMap_texinfo}, +{"cvUndistortPoints",_wrap_cvUndistortPoints,0,0,2,_wrap_cvUndistortPoints_texinfo}, +{"cvRodrigues2",_wrap_cvRodrigues2,0,0,2,_wrap_cvRodrigues2_texinfo}, +{"cvFindHomography",_wrap_cvFindHomography,0,0,2,_wrap_cvFindHomography_texinfo}, +{"cvRQDecomp3x3",_wrap_cvRQDecomp3x3,0,0,2,_wrap_cvRQDecomp3x3_texinfo}, +{"cvDecomposeProjectionMatrix",_wrap_cvDecomposeProjectionMatrix,0,0,2,_wrap_cvDecomposeProjectionMatrix_texinfo}, +{"cvCalcMatMulDeriv",_wrap_cvCalcMatMulDeriv,0,0,2,_wrap_cvCalcMatMulDeriv_texinfo}, +{"cvComposeRT",_wrap_cvComposeRT,0,0,2,_wrap_cvComposeRT_texinfo}, +{"cvProjectPoints2",_wrap_cvProjectPoints2,0,0,2,_wrap_cvProjectPoints2_texinfo}, +{"cvFindExtrinsicCameraParams2",_wrap_cvFindExtrinsicCameraParams2,0,0,2,_wrap_cvFindExtrinsicCameraParams2_texinfo}, +{"cvInitIntrinsicParams2D",_wrap_cvInitIntrinsicParams2D,0,0,2,_wrap_cvInitIntrinsicParams2D_texinfo}, +{"cvFindChessboardCorners",_wrap_cvFindChessboardCorners,0,0,2,_wrap_cvFindChessboardCorners_texinfo}, +{"cvDrawChessboardCorners",_wrap_cvDrawChessboardCorners,0,0,2,_wrap_cvDrawChessboardCorners_texinfo}, +{"cvCalibrateCamera2",_wrap_cvCalibrateCamera2,0,0,2,_wrap_cvCalibrateCamera2_texinfo}, +{"cvCalibrationMatrixValues",_wrap_cvCalibrationMatrixValues,0,0,2,_wrap_cvCalibrationMatrixValues_texinfo}, +{"cvStereoCalibrate",_wrap_cvStereoCalibrate,0,0,2,_wrap_cvStereoCalibrate_texinfo}, +{"cvStereoRectify",_wrap_cvStereoRectify,0,0,2,_wrap_cvStereoRectify_texinfo}, +{"cvStereoRectifyUncalibrated",_wrap_cvStereoRectifyUncalibrated,0,0,2,_wrap_cvStereoRectifyUncalibrated_texinfo}, +{"cvCreatePOSITObject",_wrap_cvCreatePOSITObject,0,0,2,_wrap_cvCreatePOSITObject_texinfo}, +{"cvPOSIT",_wrap_cvPOSIT,0,0,2,_wrap_cvPOSIT_texinfo}, +{"cvReleasePOSITObject",_wrap_cvReleasePOSITObject,0,0,2,_wrap_cvReleasePOSITObject_texinfo}, +{"cvRANSACUpdateNumIters",_wrap_cvRANSACUpdateNumIters,0,0,2,_wrap_cvRANSACUpdateNumIters_texinfo}, +{"cvConvertPointsHomogeneous",_wrap_cvConvertPointsHomogeneous,0,0,2,_wrap_cvConvertPointsHomogeneous_texinfo}, +{"cvFindFundamentalMat",_wrap_cvFindFundamentalMat,0,0,2,_wrap_cvFindFundamentalMat_texinfo}, +{"cvComputeCorrespondEpilines",_wrap_cvComputeCorrespondEpilines,0,0,2,_wrap_cvComputeCorrespondEpilines_texinfo}, +{"cvTriangulatePoints",_wrap_cvTriangulatePoints,0,0,2,_wrap_cvTriangulatePoints_texinfo}, +{"cvCorrectMatches",_wrap_cvCorrectMatches,0,0,2,_wrap_cvCorrectMatches_texinfo}, +{"CvStereoBMState_preFilterType_set",_wrap_CvStereoBMState_preFilterType_set,0,0,2,0}, +{"CvStereoBMState_preFilterType_get",_wrap_CvStereoBMState_preFilterType_get,0,0,2,0}, +{"CvStereoBMState_preFilterSize_set",_wrap_CvStereoBMState_preFilterSize_set,0,0,2,0}, +{"CvStereoBMState_preFilterSize_get",_wrap_CvStereoBMState_preFilterSize_get,0,0,2,0}, +{"CvStereoBMState_preFilterCap_set",_wrap_CvStereoBMState_preFilterCap_set,0,0,2,0}, +{"CvStereoBMState_preFilterCap_get",_wrap_CvStereoBMState_preFilterCap_get,0,0,2,0}, +{"CvStereoBMState_SADWindowSize_set",_wrap_CvStereoBMState_SADWindowSize_set,0,0,2,0}, +{"CvStereoBMState_SADWindowSize_get",_wrap_CvStereoBMState_SADWindowSize_get,0,0,2,0}, +{"CvStereoBMState_minDisparity_set",_wrap_CvStereoBMState_minDisparity_set,0,0,2,0}, +{"CvStereoBMState_minDisparity_get",_wrap_CvStereoBMState_minDisparity_get,0,0,2,0}, +{"CvStereoBMState_numberOfDisparities_set",_wrap_CvStereoBMState_numberOfDisparities_set,0,0,2,0}, +{"CvStereoBMState_numberOfDisparities_get",_wrap_CvStereoBMState_numberOfDisparities_get,0,0,2,0}, +{"CvStereoBMState_textureThreshold_set",_wrap_CvStereoBMState_textureThreshold_set,0,0,2,0}, +{"CvStereoBMState_textureThreshold_get",_wrap_CvStereoBMState_textureThreshold_get,0,0,2,0}, +{"CvStereoBMState_uniquenessRatio_set",_wrap_CvStereoBMState_uniquenessRatio_set,0,0,2,0}, +{"CvStereoBMState_uniquenessRatio_get",_wrap_CvStereoBMState_uniquenessRatio_get,0,0,2,0}, +{"CvStereoBMState_speckleWindowSize_set",_wrap_CvStereoBMState_speckleWindowSize_set,0,0,2,0}, +{"CvStereoBMState_speckleWindowSize_get",_wrap_CvStereoBMState_speckleWindowSize_get,0,0,2,0}, +{"CvStereoBMState_speckleRange_set",_wrap_CvStereoBMState_speckleRange_set,0,0,2,0}, +{"CvStereoBMState_speckleRange_get",_wrap_CvStereoBMState_speckleRange_get,0,0,2,0}, +{"CvStereoBMState_trySmallerWindows_set",_wrap_CvStereoBMState_trySmallerWindows_set,0,0,2,0}, +{"CvStereoBMState_trySmallerWindows_get",_wrap_CvStereoBMState_trySmallerWindows_get,0,0,2,0}, +{"CvStereoBMState_preFilteredImg0_set",_wrap_CvStereoBMState_preFilteredImg0_set,0,0,2,0}, +{"CvStereoBMState_preFilteredImg0_get",_wrap_CvStereoBMState_preFilteredImg0_get,0,0,2,0}, +{"CvStereoBMState_preFilteredImg1_set",_wrap_CvStereoBMState_preFilteredImg1_set,0,0,2,0}, +{"CvStereoBMState_preFilteredImg1_get",_wrap_CvStereoBMState_preFilteredImg1_get,0,0,2,0}, +{"CvStereoBMState_slidingSumBuf_set",_wrap_CvStereoBMState_slidingSumBuf_set,0,0,2,0}, +{"CvStereoBMState_slidingSumBuf_get",_wrap_CvStereoBMState_slidingSumBuf_get,0,0,2,0}, +{"CvStereoBMState_dbmin_set",_wrap_CvStereoBMState_dbmin_set,0,0,2,0}, +{"CvStereoBMState_dbmin_get",_wrap_CvStereoBMState_dbmin_get,0,0,2,0}, +{"CvStereoBMState_dbmax_set",_wrap_CvStereoBMState_dbmax_set,0,0,2,0}, +{"CvStereoBMState_dbmax_get",_wrap_CvStereoBMState_dbmax_get,0,0,2,0}, +{"new_CvStereoBMState",_wrap_new_CvStereoBMState,0,0,2,_wrap_new_CvStereoBMState_texinfo}, +{"delete_CvStereoBMState",_wrap_delete_CvStereoBMState,0,0,2,_wrap_delete_CvStereoBMState_texinfo}, +{"cvCreateStereoBMState",_wrap_cvCreateStereoBMState,0,0,2,_wrap_cvCreateStereoBMState_texinfo}, +{"cvReleaseStereoBMState",_wrap_cvReleaseStereoBMState,0,0,2,_wrap_cvReleaseStereoBMState_texinfo}, +{"cvFindStereoCorrespondenceBM",_wrap_cvFindStereoCorrespondenceBM,0,0,2,_wrap_cvFindStereoCorrespondenceBM_texinfo}, +{"CvStereoGCState_Ithreshold_set",_wrap_CvStereoGCState_Ithreshold_set,0,0,2,0}, +{"CvStereoGCState_Ithreshold_get",_wrap_CvStereoGCState_Ithreshold_get,0,0,2,0}, +{"CvStereoGCState_interactionRadius_set",_wrap_CvStereoGCState_interactionRadius_set,0,0,2,0}, +{"CvStereoGCState_interactionRadius_get",_wrap_CvStereoGCState_interactionRadius_get,0,0,2,0}, +{"CvStereoGCState_K_set",_wrap_CvStereoGCState_K_set,0,0,2,0}, +{"CvStereoGCState_K_get",_wrap_CvStereoGCState_K_get,0,0,2,0}, +{"CvStereoGCState_lambda_set",_wrap_CvStereoGCState_lambda_set,0,0,2,0}, +{"CvStereoGCState_lambda_get",_wrap_CvStereoGCState_lambda_get,0,0,2,0}, +{"CvStereoGCState_lambda1_set",_wrap_CvStereoGCState_lambda1_set,0,0,2,0}, +{"CvStereoGCState_lambda1_get",_wrap_CvStereoGCState_lambda1_get,0,0,2,0}, +{"CvStereoGCState_lambda2_set",_wrap_CvStereoGCState_lambda2_set,0,0,2,0}, +{"CvStereoGCState_lambda2_get",_wrap_CvStereoGCState_lambda2_get,0,0,2,0}, +{"CvStereoGCState_occlusionCost_set",_wrap_CvStereoGCState_occlusionCost_set,0,0,2,0}, +{"CvStereoGCState_occlusionCost_get",_wrap_CvStereoGCState_occlusionCost_get,0,0,2,0}, +{"CvStereoGCState_minDisparity_set",_wrap_CvStereoGCState_minDisparity_set,0,0,2,0}, +{"CvStereoGCState_minDisparity_get",_wrap_CvStereoGCState_minDisparity_get,0,0,2,0}, +{"CvStereoGCState_numberOfDisparities_set",_wrap_CvStereoGCState_numberOfDisparities_set,0,0,2,0}, +{"CvStereoGCState_numberOfDisparities_get",_wrap_CvStereoGCState_numberOfDisparities_get,0,0,2,0}, +{"CvStereoGCState_maxIters_set",_wrap_CvStereoGCState_maxIters_set,0,0,2,0}, +{"CvStereoGCState_maxIters_get",_wrap_CvStereoGCState_maxIters_get,0,0,2,0}, +{"CvStereoGCState_left_set",_wrap_CvStereoGCState_left_set,0,0,2,0}, +{"CvStereoGCState_left_get",_wrap_CvStereoGCState_left_get,0,0,2,0}, +{"CvStereoGCState_right_set",_wrap_CvStereoGCState_right_set,0,0,2,0}, +{"CvStereoGCState_right_get",_wrap_CvStereoGCState_right_get,0,0,2,0}, +{"CvStereoGCState_dispLeft_set",_wrap_CvStereoGCState_dispLeft_set,0,0,2,0}, +{"CvStereoGCState_dispLeft_get",_wrap_CvStereoGCState_dispLeft_get,0,0,2,0}, +{"CvStereoGCState_dispRight_set",_wrap_CvStereoGCState_dispRight_set,0,0,2,0}, +{"CvStereoGCState_dispRight_get",_wrap_CvStereoGCState_dispRight_get,0,0,2,0}, +{"CvStereoGCState_ptrLeft_set",_wrap_CvStereoGCState_ptrLeft_set,0,0,2,0}, +{"CvStereoGCState_ptrLeft_get",_wrap_CvStereoGCState_ptrLeft_get,0,0,2,0}, +{"CvStereoGCState_ptrRight_set",_wrap_CvStereoGCState_ptrRight_set,0,0,2,0}, +{"CvStereoGCState_ptrRight_get",_wrap_CvStereoGCState_ptrRight_get,0,0,2,0}, +{"CvStereoGCState_vtxBuf_set",_wrap_CvStereoGCState_vtxBuf_set,0,0,2,0}, +{"CvStereoGCState_vtxBuf_get",_wrap_CvStereoGCState_vtxBuf_get,0,0,2,0}, +{"CvStereoGCState_edgeBuf_set",_wrap_CvStereoGCState_edgeBuf_set,0,0,2,0}, +{"CvStereoGCState_edgeBuf_get",_wrap_CvStereoGCState_edgeBuf_get,0,0,2,0}, +{"new_CvStereoGCState",_wrap_new_CvStereoGCState,0,0,2,_wrap_new_CvStereoGCState_texinfo}, +{"delete_CvStereoGCState",_wrap_delete_CvStereoGCState,0,0,2,_wrap_delete_CvStereoGCState_texinfo}, +{"cvCreateStereoGCState",_wrap_cvCreateStereoGCState,0,0,2,_wrap_cvCreateStereoGCState_texinfo}, +{"cvReleaseStereoGCState",_wrap_cvReleaseStereoGCState,0,0,2,_wrap_cvReleaseStereoGCState_texinfo}, +{"cvFindStereoCorrespondenceGC",_wrap_cvFindStereoCorrespondenceGC,0,0,2,_wrap_cvFindStereoCorrespondenceGC_texinfo}, +{"cvReprojectImageTo3D",_wrap_cvReprojectImageTo3D,0,0,2,_wrap_cvReprojectImageTo3D_texinfo}, +{"delete_CvLSH",_wrap_delete_CvLSH,0,0,2,_wrap_delete_CvLSH_texinfo}, +{"CvTuple_CvPoint_2_val_set",_wrap_CvTuple_CvPoint_2_val_set,0,0,2,0}, +{"CvTuple_CvPoint_2_val_get",_wrap_CvTuple_CvPoint_2_val_get,0,0,2,0}, +{"CvTuple_CvPoint_2___paren",_wrap_CvTuple_CvPoint_2___paren,0,0,2,_wrap_CvTuple_CvPoint_2___paren_texinfo}, +{"CvTuple_CvPoint_2___paren_asgn",_wrap_CvTuple_CvPoint_2___paren_asgn,0,0,2,_wrap_CvTuple_CvPoint_2___paren_asgn_texinfo}, +{"CvTuple_CvPoint_2___brace",_wrap_CvTuple_CvPoint_2___brace,0,0,2,_wrap_CvTuple_CvPoint_2___brace_texinfo}, +{"CvTuple_CvPoint_2___brace_asgn",_wrap_CvTuple_CvPoint_2___brace_asgn,0,0,2,_wrap_CvTuple_CvPoint_2___brace_asgn_texinfo}, +{"new_CvTuple_CvPoint_2",_wrap_new_CvTuple_CvPoint_2,0,0,2,_wrap_new_CvTuple_CvPoint_2_texinfo}, +{"delete_CvTuple_CvPoint_2",_wrap_delete_CvTuple_CvPoint_2,0,0,2,_wrap_delete_CvTuple_CvPoint_2_texinfo}, +{"CvTuple_float_2_val_set",_wrap_CvTuple_float_2_val_set,0,0,2,0}, +{"CvTuple_float_2_val_get",_wrap_CvTuple_float_2_val_get,0,0,2,0}, +{"CvTuple_float_2___paren",_wrap_CvTuple_float_2___paren,0,0,2,_wrap_CvTuple_float_2___paren_texinfo}, +{"CvTuple_float_2___paren_asgn",_wrap_CvTuple_float_2___paren_asgn,0,0,2,_wrap_CvTuple_float_2___paren_asgn_texinfo}, +{"CvTuple_float_2___brace",_wrap_CvTuple_float_2___brace,0,0,2,_wrap_CvTuple_float_2___brace_texinfo}, +{"CvTuple_float_2___brace_asgn",_wrap_CvTuple_float_2___brace_asgn,0,0,2,_wrap_CvTuple_float_2___brace_asgn_texinfo}, +{"new_CvTuple_float_2",_wrap_new_CvTuple_float_2,0,0,2,_wrap_new_CvTuple_float_2_texinfo}, +{"delete_CvTuple_float_2",_wrap_delete_CvTuple_float_2,0,0,2,_wrap_delete_CvTuple_float_2_texinfo}, +{"CvTuple_float_3_val_set",_wrap_CvTuple_float_3_val_set,0,0,2,0}, +{"CvTuple_float_3_val_get",_wrap_CvTuple_float_3_val_get,0,0,2,0}, +{"CvTuple_float_3___paren",_wrap_CvTuple_float_3___paren,0,0,2,_wrap_CvTuple_float_3___paren_texinfo}, +{"CvTuple_float_3___paren_asgn",_wrap_CvTuple_float_3___paren_asgn,0,0,2,_wrap_CvTuple_float_3___paren_asgn_texinfo}, +{"CvTuple_float_3___brace",_wrap_CvTuple_float_3___brace,0,0,2,_wrap_CvTuple_float_3___brace_texinfo}, +{"CvTuple_float_3___brace_asgn",_wrap_CvTuple_float_3___brace_asgn,0,0,2,_wrap_CvTuple_float_3___brace_asgn_texinfo}, +{"new_CvTuple_float_3",_wrap_new_CvTuple_float_3,0,0,2,_wrap_new_CvTuple_float_3_texinfo}, +{"delete_CvTuple_float_3",_wrap_delete_CvTuple_float_3,0,0,2,_wrap_delete_CvTuple_float_3_texinfo}, +{"CvSeq_CvPoint_cast",_wrap_CvSeq_CvPoint_cast,0,0,2,_wrap_CvSeq_CvPoint_cast_texinfo}, +{"CvSeq_CvPoint___paren",_wrap_CvSeq_CvPoint___paren,0,0,2,_wrap_CvSeq_CvPoint___paren_texinfo}, +{"CvSeq_CvPoint___paren_asgn",_wrap_CvSeq_CvPoint___paren_asgn,0,0,2,_wrap_CvSeq_CvPoint___paren_asgn_texinfo}, +{"CvSeq_CvPoint___brace",_wrap_CvSeq_CvPoint___brace,0,0,2,_wrap_CvSeq_CvPoint___brace_texinfo}, +{"CvSeq_CvPoint___brace_asgn",_wrap_CvSeq_CvPoint___brace_asgn,0,0,2,_wrap_CvSeq_CvPoint___brace_asgn_texinfo}, +{"CvSeq_CvPoint_append",_wrap_CvSeq_CvPoint_append,0,0,2,_wrap_CvSeq_CvPoint_append_texinfo}, +{"CvSeq_CvPoint_pop",_wrap_CvSeq_CvPoint_pop,0,0,2,_wrap_CvSeq_CvPoint_pop_texinfo}, +{"new_CvSeq_CvPoint",_wrap_new_CvSeq_CvPoint,0,0,2,_wrap_new_CvSeq_CvPoint_texinfo}, +{"delete_CvSeq_CvPoint",_wrap_delete_CvSeq_CvPoint,0,0,2,_wrap_delete_CvSeq_CvPoint_texinfo}, +{"CvSeq_CvPoint2D32f_cast",_wrap_CvSeq_CvPoint2D32f_cast,0,0,2,_wrap_CvSeq_CvPoint2D32f_cast_texinfo}, +{"CvSeq_CvPoint2D32f___paren",_wrap_CvSeq_CvPoint2D32f___paren,0,0,2,_wrap_CvSeq_CvPoint2D32f___paren_texinfo}, +{"CvSeq_CvPoint2D32f___paren_asgn",_wrap_CvSeq_CvPoint2D32f___paren_asgn,0,0,2,_wrap_CvSeq_CvPoint2D32f___paren_asgn_texinfo}, +{"CvSeq_CvPoint2D32f___brace",_wrap_CvSeq_CvPoint2D32f___brace,0,0,2,_wrap_CvSeq_CvPoint2D32f___brace_texinfo}, +{"CvSeq_CvPoint2D32f___brace_asgn",_wrap_CvSeq_CvPoint2D32f___brace_asgn,0,0,2,_wrap_CvSeq_CvPoint2D32f___brace_asgn_texinfo}, +{"CvSeq_CvPoint2D32f_append",_wrap_CvSeq_CvPoint2D32f_append,0,0,2,_wrap_CvSeq_CvPoint2D32f_append_texinfo}, +{"CvSeq_CvPoint2D32f_pop",_wrap_CvSeq_CvPoint2D32f_pop,0,0,2,_wrap_CvSeq_CvPoint2D32f_pop_texinfo}, +{"new_CvSeq_CvPoint2D32f",_wrap_new_CvSeq_CvPoint2D32f,0,0,2,_wrap_new_CvSeq_CvPoint2D32f_texinfo}, +{"delete_CvSeq_CvPoint2D32f",_wrap_delete_CvSeq_CvPoint2D32f,0,0,2,_wrap_delete_CvSeq_CvPoint2D32f_texinfo}, +{"CvSeq_CvRect_cast",_wrap_CvSeq_CvRect_cast,0,0,2,_wrap_CvSeq_CvRect_cast_texinfo}, +{"CvSeq_CvRect___paren",_wrap_CvSeq_CvRect___paren,0,0,2,_wrap_CvSeq_CvRect___paren_texinfo}, +{"CvSeq_CvRect___paren_asgn",_wrap_CvSeq_CvRect___paren_asgn,0,0,2,_wrap_CvSeq_CvRect___paren_asgn_texinfo}, +{"CvSeq_CvRect___brace",_wrap_CvSeq_CvRect___brace,0,0,2,_wrap_CvSeq_CvRect___brace_texinfo}, +{"CvSeq_CvRect___brace_asgn",_wrap_CvSeq_CvRect___brace_asgn,0,0,2,_wrap_CvSeq_CvRect___brace_asgn_texinfo}, +{"CvSeq_CvRect_append",_wrap_CvSeq_CvRect_append,0,0,2,_wrap_CvSeq_CvRect_append_texinfo}, +{"CvSeq_CvRect_pop",_wrap_CvSeq_CvRect_pop,0,0,2,_wrap_CvSeq_CvRect_pop_texinfo}, +{"new_CvSeq_CvRect",_wrap_new_CvSeq_CvRect,0,0,2,_wrap_new_CvSeq_CvRect_texinfo}, +{"delete_CvSeq_CvRect",_wrap_delete_CvSeq_CvRect,0,0,2,_wrap_delete_CvSeq_CvRect_texinfo}, +{"CvSeq_CvSeq_cast",_wrap_CvSeq_CvSeq_cast,0,0,2,_wrap_CvSeq_CvSeq_cast_texinfo}, +{"CvSeq_CvSeq___paren",_wrap_CvSeq_CvSeq___paren,0,0,2,_wrap_CvSeq_CvSeq___paren_texinfo}, +{"CvSeq_CvSeq___paren_asgn",_wrap_CvSeq_CvSeq___paren_asgn,0,0,2,_wrap_CvSeq_CvSeq___paren_asgn_texinfo}, +{"CvSeq_CvSeq___brace",_wrap_CvSeq_CvSeq___brace,0,0,2,_wrap_CvSeq_CvSeq___brace_texinfo}, +{"CvSeq_CvSeq___brace_asgn",_wrap_CvSeq_CvSeq___brace_asgn,0,0,2,_wrap_CvSeq_CvSeq___brace_asgn_texinfo}, +{"CvSeq_CvSeq_append",_wrap_CvSeq_CvSeq_append,0,0,2,_wrap_CvSeq_CvSeq_append_texinfo}, +{"CvSeq_CvSeq_pop",_wrap_CvSeq_CvSeq_pop,0,0,2,_wrap_CvSeq_CvSeq_pop_texinfo}, +{"new_CvSeq_CvSeq",_wrap_new_CvSeq_CvSeq,0,0,2,_wrap_new_CvSeq_CvSeq_texinfo}, +{"delete_CvSeq_CvSeq",_wrap_delete_CvSeq_CvSeq,0,0,2,_wrap_delete_CvSeq_CvSeq_texinfo}, +{"CvSeq_CvQuadEdge2D_cast",_wrap_CvSeq_CvQuadEdge2D_cast,0,0,2,_wrap_CvSeq_CvQuadEdge2D_cast_texinfo}, +{"CvSeq_CvQuadEdge2D___paren",_wrap_CvSeq_CvQuadEdge2D___paren,0,0,2,_wrap_CvSeq_CvQuadEdge2D___paren_texinfo}, +{"CvSeq_CvQuadEdge2D___paren_asgn",_wrap_CvSeq_CvQuadEdge2D___paren_asgn,0,0,2,_wrap_CvSeq_CvQuadEdge2D___paren_asgn_texinfo}, +{"CvSeq_CvQuadEdge2D___brace",_wrap_CvSeq_CvQuadEdge2D___brace,0,0,2,_wrap_CvSeq_CvQuadEdge2D___brace_texinfo}, +{"CvSeq_CvQuadEdge2D___brace_asgn",_wrap_CvSeq_CvQuadEdge2D___brace_asgn,0,0,2,_wrap_CvSeq_CvQuadEdge2D___brace_asgn_texinfo}, +{"CvSeq_CvQuadEdge2D_append",_wrap_CvSeq_CvQuadEdge2D_append,0,0,2,_wrap_CvSeq_CvQuadEdge2D_append_texinfo}, +{"CvSeq_CvQuadEdge2D_pop",_wrap_CvSeq_CvQuadEdge2D_pop,0,0,2,_wrap_CvSeq_CvQuadEdge2D_pop_texinfo}, +{"new_CvSeq_CvQuadEdge2D",_wrap_new_CvSeq_CvQuadEdge2D,0,0,2,_wrap_new_CvSeq_CvQuadEdge2D_texinfo}, +{"delete_CvSeq_CvQuadEdge2D",_wrap_delete_CvSeq_CvQuadEdge2D,0,0,2,_wrap_delete_CvSeq_CvQuadEdge2D_texinfo}, +{"CvSeq_CvConnectedComp_cast",_wrap_CvSeq_CvConnectedComp_cast,0,0,2,_wrap_CvSeq_CvConnectedComp_cast_texinfo}, +{"CvSeq_CvConnectedComp___paren",_wrap_CvSeq_CvConnectedComp___paren,0,0,2,_wrap_CvSeq_CvConnectedComp___paren_texinfo}, +{"CvSeq_CvConnectedComp___paren_asgn",_wrap_CvSeq_CvConnectedComp___paren_asgn,0,0,2,_wrap_CvSeq_CvConnectedComp___paren_asgn_texinfo}, +{"CvSeq_CvConnectedComp___brace",_wrap_CvSeq_CvConnectedComp___brace,0,0,2,_wrap_CvSeq_CvConnectedComp___brace_texinfo}, +{"CvSeq_CvConnectedComp___brace_asgn",_wrap_CvSeq_CvConnectedComp___brace_asgn,0,0,2,_wrap_CvSeq_CvConnectedComp___brace_asgn_texinfo}, +{"CvSeq_CvConnectedComp_append",_wrap_CvSeq_CvConnectedComp_append,0,0,2,_wrap_CvSeq_CvConnectedComp_append_texinfo}, +{"CvSeq_CvConnectedComp_pop",_wrap_CvSeq_CvConnectedComp_pop,0,0,2,_wrap_CvSeq_CvConnectedComp_pop_texinfo}, +{"new_CvSeq_CvConnectedComp",_wrap_new_CvSeq_CvConnectedComp,0,0,2,_wrap_new_CvSeq_CvConnectedComp_texinfo}, +{"delete_CvSeq_CvConnectedComp",_wrap_delete_CvSeq_CvConnectedComp,0,0,2,_wrap_delete_CvSeq_CvConnectedComp_texinfo}, +{"CvSeq_CvPoint_2_cast",_wrap_CvSeq_CvPoint_2_cast,0,0,2,_wrap_CvSeq_CvPoint_2_cast_texinfo}, +{"CvSeq_CvPoint_2___paren",_wrap_CvSeq_CvPoint_2___paren,0,0,2,_wrap_CvSeq_CvPoint_2___paren_texinfo}, +{"CvSeq_CvPoint_2___paren_asgn",_wrap_CvSeq_CvPoint_2___paren_asgn,0,0,2,_wrap_CvSeq_CvPoint_2___paren_asgn_texinfo}, +{"CvSeq_CvPoint_2___brace",_wrap_CvSeq_CvPoint_2___brace,0,0,2,_wrap_CvSeq_CvPoint_2___brace_texinfo}, +{"CvSeq_CvPoint_2___brace_asgn",_wrap_CvSeq_CvPoint_2___brace_asgn,0,0,2,_wrap_CvSeq_CvPoint_2___brace_asgn_texinfo}, +{"CvSeq_CvPoint_2_append",_wrap_CvSeq_CvPoint_2_append,0,0,2,_wrap_CvSeq_CvPoint_2_append_texinfo}, +{"CvSeq_CvPoint_2_pop",_wrap_CvSeq_CvPoint_2_pop,0,0,2,_wrap_CvSeq_CvPoint_2_pop_texinfo}, +{"new_CvSeq_CvPoint_2",_wrap_new_CvSeq_CvPoint_2,0,0,2,_wrap_new_CvSeq_CvPoint_2_texinfo}, +{"delete_CvSeq_CvPoint_2",_wrap_delete_CvSeq_CvPoint_2,0,0,2,_wrap_delete_CvSeq_CvPoint_2_texinfo}, +{"CvSeq_float_2_cast",_wrap_CvSeq_float_2_cast,0,0,2,_wrap_CvSeq_float_2_cast_texinfo}, +{"CvSeq_float_2___paren",_wrap_CvSeq_float_2___paren,0,0,2,_wrap_CvSeq_float_2___paren_texinfo}, +{"CvSeq_float_2___paren_asgn",_wrap_CvSeq_float_2___paren_asgn,0,0,2,_wrap_CvSeq_float_2___paren_asgn_texinfo}, +{"CvSeq_float_2___brace",_wrap_CvSeq_float_2___brace,0,0,2,_wrap_CvSeq_float_2___brace_texinfo}, +{"CvSeq_float_2___brace_asgn",_wrap_CvSeq_float_2___brace_asgn,0,0,2,_wrap_CvSeq_float_2___brace_asgn_texinfo}, +{"CvSeq_float_2_append",_wrap_CvSeq_float_2_append,0,0,2,_wrap_CvSeq_float_2_append_texinfo}, +{"CvSeq_float_2_pop",_wrap_CvSeq_float_2_pop,0,0,2,_wrap_CvSeq_float_2_pop_texinfo}, +{"new_CvSeq_float_2",_wrap_new_CvSeq_float_2,0,0,2,_wrap_new_CvSeq_float_2_texinfo}, +{"delete_CvSeq_float_2",_wrap_delete_CvSeq_float_2,0,0,2,_wrap_delete_CvSeq_float_2_texinfo}, +{"CvSeq_float_3_cast",_wrap_CvSeq_float_3_cast,0,0,2,_wrap_CvSeq_float_3_cast_texinfo}, +{"CvSeq_float_3___paren",_wrap_CvSeq_float_3___paren,0,0,2,_wrap_CvSeq_float_3___paren_texinfo}, +{"CvSeq_float_3___paren_asgn",_wrap_CvSeq_float_3___paren_asgn,0,0,2,_wrap_CvSeq_float_3___paren_asgn_texinfo}, +{"CvSeq_float_3___brace",_wrap_CvSeq_float_3___brace,0,0,2,_wrap_CvSeq_float_3___brace_texinfo}, +{"CvSeq_float_3___brace_asgn",_wrap_CvSeq_float_3___brace_asgn,0,0,2,_wrap_CvSeq_float_3___brace_asgn_texinfo}, +{"CvSeq_float_3_append",_wrap_CvSeq_float_3_append,0,0,2,_wrap_CvSeq_float_3_append_texinfo}, +{"CvSeq_float_3_pop",_wrap_CvSeq_float_3_pop,0,0,2,_wrap_CvSeq_float_3_pop_texinfo}, +{"new_CvSeq_float_3",_wrap_new_CvSeq_float_3,0,0,2,_wrap_new_CvSeq_float_3_texinfo}, +{"delete_CvSeq_float_3",_wrap_delete_CvSeq_float_3,0,0,2,_wrap_delete_CvSeq_float_3_texinfo}, +{0,0,0,0,0} +}; + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static void *_p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq **) ((CvTypedSeq< CvTuple< CvPoint,2 > > **) x)); +} +static void *_p_p_CvTypedSeqT_CvTupleT_float_2_t_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq **) ((CvTypedSeq< CvTuple< float,2 > > **) x)); +} +static void *_p_p_CvTypedSeqT_CvConnectedComp_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq **) ((CvTypedSeq< CvConnectedComp > **) x)); +} +static void *_p_p_CvTypedSeqT_CvRect_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq **) ((CvTypedSeq< CvRect > **) x)); +} +static void *_p_p_CvTypedSeqT_CvPoint_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq **) ((CvTypedSeq< CvPoint > **) x)); +} +static void *_p_p_CvTypedSeqT_CvTupleT_float_3_t_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq **) ((CvTypedSeq< CvTuple< float,3 > > **) x)); +} +static void *_p_p_CvTypedSeqT_CvSeq_p_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq **) ((CvTypedSeq< CvSeq * > **) x)); +} +static void *_p_p_CvTypedSeqT_CvQuadEdge2D_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq **) ((CvTypedSeq< CvQuadEdge2D > **) x)); +} +static void *_p_p_CvTypedSeqT_CvPoint2D32f_tTo_p_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq **) ((CvTypedSeq< CvPoint2D32f > **) x)); +} +static void *_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq *) ((CvTypedSeq< CvTuple< CvPoint,2 > > *) x)); +} +static void *_p_CvTypedSeqT_CvTupleT_float_2_t_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq *) ((CvTypedSeq< CvTuple< float,2 > > *) x)); +} +static void *_p_CvTypedSeqT_CvConnectedComp_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq *) ((CvTypedSeq< CvConnectedComp > *) x)); +} +static void *_p_CvTypedSeqT_CvRect_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq *) ((CvTypedSeq< CvRect > *) x)); +} +static void *_p_CvTypedSeqT_CvPoint_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq *) ((CvTypedSeq< CvPoint > *) x)); +} +static void *_p_CvTypedSeqT_CvTupleT_float_3_t_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq *) ((CvTypedSeq< CvTuple< float,3 > > *) x)); +} +static void *_p_CvTypedSeqT_CvSeq_p_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq *) ((CvTypedSeq< CvSeq * > *) x)); +} +static void *_p_CvTypedSeqT_CvQuadEdge2D_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq *) ((CvTypedSeq< CvQuadEdge2D > *) x)); +} +static void *_p_CvTypedSeqT_CvPoint2D32f_tTo_p_CvSeq(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((CvSeq *) ((CvTypedSeq< CvPoint2D32f > *) x)); +} +static swig_type_info _swigt__p_Cv32suf = {"_p_Cv32suf", "Cv32suf *", 0, 0, (void*)&_wrap_class_Cv32suf, 0}; +static swig_type_info _swigt__p_Cv64suf = {"_p_Cv64suf", "Cv64suf *", 0, 0, (void*)&_wrap_class_Cv64suf, 0}; +static swig_type_info _swigt__p_CvAttrList = {"_p_CvAttrList", "CvAttrList *", 0, 0, (void*)&_wrap_class_CvAttrList, 0}; +static swig_type_info _swigt__p_CvAvgComp = {"_p_CvAvgComp", "CvAvgComp *", 0, 0, (void*)&_wrap_class_CvAvgComp, 0}; +static swig_type_info _swigt__p_CvBox2D = {"_p_CvBox2D", "CvBox2D *", 0, 0, (void*)&_wrap_class_CvBox2D, 0}; +static swig_type_info _swigt__p_CvChain = {"_p_CvChain", "CvChain *", 0, 0, (void*)&_wrap_class_CvChain, 0}; +static swig_type_info _swigt__p_CvChainPtReader = {"_p_CvChainPtReader", "CvChainPtReader *", 0, 0, (void*)&_wrap_class_CvChainPtReader, 0}; +static swig_type_info _swigt__p_CvConDensation = {"_p_CvConDensation", "CvConDensation *", 0, 0, (void*)&_wrap_class_CvConDensation, 0}; +static swig_type_info _swigt__p_CvConnectedComp = {"_p_CvConnectedComp", "CvConnectedComp *", 0, 0, (void*)&_wrap_class_CvConnectedComp, 0}; +static swig_type_info _swigt__p_CvContour = {"_p_CvContour", "CvPoint2DSeq *|CvContour *", 0, 0, (void*)&_wrap_class_CvContour, 0}; +static swig_type_info _swigt__p_CvContourTree = {"_p_CvContourTree", "CvContourTree *", 0, 0, (void*)&_wrap_class_CvContourTree, 0}; +static swig_type_info _swigt__p_CvConvexityDefect = {"_p_CvConvexityDefect", "CvConvexityDefect *", 0, 0, (void*)&_wrap_class_CvConvexityDefect, 0}; +static swig_type_info _swigt__p_CvFeatureTree = {"_p_CvFeatureTree", "CvFeatureTree *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_CvFileNode = {"_p_CvFileNode", "CvFileNode *", 0, 0, (void*)&_wrap_class_CvFileNode, 0}; +static swig_type_info _swigt__p_CvFileNode_data = {"_p_CvFileNode_data", "CvFileNode_data *", 0, 0, (void*)&_wrap_class_CvFileNode_data, 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*)&_wrap_class_CvFont, 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*)&_wrap_class_CvGraph, 0}; +static swig_type_info _swigt__p_CvGraphEdge = {"_p_CvGraphEdge", "CvGraphEdge *", 0, 0, (void*)&_wrap_class_CvGraphEdge, 0}; +static swig_type_info _swigt__p_CvGraphScanner = {"_p_CvGraphScanner", "CvGraphScanner *", 0, 0, (void*)&_wrap_class_CvGraphScanner, 0}; +static swig_type_info _swigt__p_CvGraphVtx = {"_p_CvGraphVtx", "CvGraphVtx *", 0, 0, (void*)&_wrap_class_CvGraphVtx, 0}; +static swig_type_info _swigt__p_CvGraphVtx2D = {"_p_CvGraphVtx2D", "CvGraphVtx2D *", 0, 0, (void*)&_wrap_class_CvGraphVtx2D, 0}; +static swig_type_info _swigt__p_CvHaarClassifier = {"_p_CvHaarClassifier", "CvHaarClassifier *", 0, 0, (void*)&_wrap_class_CvHaarClassifier, 0}; +static swig_type_info _swigt__p_CvHaarClassifierCascade = {"_p_CvHaarClassifierCascade", "CvHaarClassifierCascade *", 0, 0, (void*)&_wrap_class_CvHaarClassifierCascade, 0}; +static swig_type_info _swigt__p_CvHaarFeature = {"_p_CvHaarFeature", "CvHaarFeature *", 0, 0, (void*)&_wrap_class_CvHaarFeature, 0}; +static swig_type_info _swigt__p_CvHaarFeature_rect = {"_p_CvHaarFeature_rect", "CvHaarFeature_rect *", 0, 0, (void*)&_wrap_class_CvHaarFeature_rect, 0}; +static swig_type_info _swigt__p_CvHaarStageClassifier = {"_p_CvHaarStageClassifier", "CvHaarStageClassifier *", 0, 0, (void*)&_wrap_class_CvHaarStageClassifier, 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*)&_wrap_class_CvHistogram, 0}; +static swig_type_info _swigt__p_CvHuMoments = {"_p_CvHuMoments", "CvHuMoments *", 0, 0, (void*)&_wrap_class_CvHuMoments, 0}; +static swig_type_info _swigt__p_CvImage = {"_p_CvImage", "CvImage *", 0, 0, (void*)&_wrap_class_CvImage, 0}; +static swig_type_info _swigt__p_CvKalman = {"_p_CvKalman", "CvKalman *", 0, 0, (void*)&_wrap_class_CvKalman, 0}; +static swig_type_info _swigt__p_CvLSH = {"_p_CvLSH", "CvLSH *", 0, 0, (void*)&_wrap_class_CvLSH, 0}; +static swig_type_info _swigt__p_CvLSHOperations = {"_p_CvLSHOperations", "CvLSHOperations *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_CvLineIterator = {"_p_CvLineIterator", "CvLineIterator *", 0, 0, (void*)&_wrap_class_CvLineIterator, 0}; +static swig_type_info _swigt__p_CvMSERParams = {"_p_CvMSERParams", "CvMSERParams *", 0, 0, (void*)&_wrap_class_CvMSERParams, 0}; +static swig_type_info _swigt__p_CvMat = {"_p_CvMat", "CvMat *", 0, 0, (void*)&_wrap_class_CvMat, 0}; +static swig_type_info _swigt__p_CvMatND = {"_p_CvMatND", "CvMatND *", 0, 0, (void*)&_wrap_class_CvMatND, 0}; +static swig_type_info _swigt__p_CvMatND_data = {"_p_CvMatND_data", "CvMatND_data *", 0, 0, (void*)&_wrap_class_CvMatND_data, 0}; +static swig_type_info _swigt__p_CvMatND_dim = {"_p_CvMatND_dim", "CvMatND_dim *", 0, 0, (void*)&_wrap_class_CvMatND_dim, 0}; +static swig_type_info _swigt__p_CvMat_data = {"_p_CvMat_data", "CvMat_data *", 0, 0, (void*)&_wrap_class_CvMat_data, 0}; +static swig_type_info _swigt__p_CvMatrix = {"_p_CvMatrix", "CvMatrix *", 0, 0, (void*)&_wrap_class_CvMatrix, 0}; +static swig_type_info _swigt__p_CvMatrix3 = {"_p_CvMatrix3", "CvMatrix3 *", 0, 0, (void*)&_wrap_class_CvMatrix3, 0}; +static swig_type_info _swigt__p_CvMemBlock = {"_p_CvMemBlock", "CvMemBlock *", 0, 0, (void*)&_wrap_class_CvMemBlock, 0}; +static swig_type_info _swigt__p_CvMemStorage = {"_p_CvMemStorage", "CvMemStorage *", 0, 0, (void*)&_wrap_class_CvMemStorage, 0}; +static swig_type_info _swigt__p_CvMemStoragePos = {"_p_CvMemStoragePos", "CvMemStoragePos *", 0, 0, (void*)&_wrap_class_CvMemStoragePos, 0}; +static swig_type_info _swigt__p_CvModule = {"_p_CvModule", "CvModule *", 0, 0, (void*)&_wrap_class_CvModule, 0}; +static swig_type_info _swigt__p_CvModuleInfo = {"_p_CvModuleInfo", "CvModuleInfo *", 0, 0, (void*)&_wrap_class_CvModuleInfo, 0}; +static swig_type_info _swigt__p_CvMoments = {"_p_CvMoments", "CvMoments *", 0, 0, (void*)&_wrap_class_CvMoments, 0}; +static swig_type_info _swigt__p_CvNArrayIterator = {"_p_CvNArrayIterator", "CvNArrayIterator *", 0, 0, (void*)&_wrap_class_CvNArrayIterator, 0}; +static swig_type_info _swigt__p_CvNextEdgeType = {"_p_CvNextEdgeType", "enum CvNextEdgeType *|CvNextEdgeType *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_CvPOSITObject = {"_p_CvPOSITObject", "CvPOSITObject *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_CvPluginFuncInfo = {"_p_CvPluginFuncInfo", "CvPluginFuncInfo *", 0, 0, (void*)&_wrap_class_CvPluginFuncInfo, 0}; +static swig_type_info _swigt__p_CvPoint = {"_p_CvPoint", "CvPoint *", 0, 0, (void*)&_wrap_class_CvPoint, 0}; +static swig_type_info _swigt__p_CvPoint2D32f = {"_p_CvPoint2D32f", "CvPoint2D32f *", 0, 0, (void*)&_wrap_class_CvPoint2D32f, 0}; +static swig_type_info _swigt__p_CvPoint2D64f = {"_p_CvPoint2D64f", "CvPoint2D64f *", 0, 0, (void*)&_wrap_class_CvPoint2D64f, 0}; +static swig_type_info _swigt__p_CvPoint3D32f = {"_p_CvPoint3D32f", "CvPoint3D32f *", 0, 0, (void*)&_wrap_class_CvPoint3D32f, 0}; +static swig_type_info _swigt__p_CvPoint3D64f = {"_p_CvPoint3D64f", "CvPoint3D64f *", 0, 0, (void*)&_wrap_class_CvPoint3D64f, 0}; +static swig_type_info _swigt__p_CvQuadEdge2D = {"_p_CvQuadEdge2D", "CvQuadEdge2D *", 0, 0, (void*)&_wrap_class_CvQuadEdge2D, 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_CvRandState = {"_p_CvRandState", "CvRandState *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_CvRect = {"_p_CvRect", "CvRect *", 0, 0, (void*)&_wrap_class_CvRect, 0}; +static swig_type_info _swigt__p_CvSURFParams = {"_p_CvSURFParams", "CvSURFParams *", 0, 0, (void*)&_wrap_class_CvSURFParams, 0}; +static swig_type_info _swigt__p_CvSURFPoint = {"_p_CvSURFPoint", "CvSURFPoint *", 0, 0, (void*)&_wrap_class_CvSURFPoint, 0}; +static swig_type_info _swigt__p_CvScalar = {"_p_CvScalar", "CvScalar *", 0, 0, (void*)&_wrap_class_CvScalar, 0}; +static swig_type_info _swigt__p_CvSeq = {"_p_CvSeq", "CvSeq *", 0, 0, (void*)&_wrap_class_CvSeq, 0}; +static swig_type_info _swigt__p_CvSeqBlock = {"_p_CvSeqBlock", "CvSeqBlock *", 0, 0, (void*)&_wrap_class_CvSeqBlock, 0}; +static swig_type_info _swigt__p_CvSeqReader = {"_p_CvSeqReader", "CvSeqReader *", 0, 0, (void*)&_wrap_class_CvSeqReader, 0}; +static swig_type_info _swigt__p_CvSeqWriter = {"_p_CvSeqWriter", "CvSeqWriter *", 0, 0, (void*)&_wrap_class_CvSeqWriter, 0}; +static swig_type_info _swigt__p_CvSet = {"_p_CvSet", "CvSet *", 0, 0, (void*)&_wrap_class_CvSet, 0}; +static swig_type_info _swigt__p_CvSetElem = {"_p_CvSetElem", "CvSetElem *", 0, 0, (void*)&_wrap_class_CvSetElem, 0}; +static swig_type_info _swigt__p_CvSize = {"_p_CvSize", "CvSize *", 0, 0, (void*)&_wrap_class_CvSize, 0}; +static swig_type_info _swigt__p_CvSize2D32f = {"_p_CvSize2D32f", "CvSize2D32f *", 0, 0, (void*)&_wrap_class_CvSize2D32f, 0}; +static swig_type_info _swigt__p_CvSlice = {"_p_CvSlice", "CvSlice *", 0, 0, (void*)&_wrap_class_CvSlice, 0}; +static swig_type_info _swigt__p_CvSparseMat = {"_p_CvSparseMat", "CvSparseMat *", 0, 0, (void*)&_wrap_class_CvSparseMat, 0}; +static swig_type_info _swigt__p_CvSparseMatIterator = {"_p_CvSparseMatIterator", "CvSparseMatIterator *", 0, 0, (void*)&_wrap_class_CvSparseMatIterator, 0}; +static swig_type_info _swigt__p_CvSparseNode = {"_p_CvSparseNode", "CvSparseNode *", 0, 0, (void*)&_wrap_class_CvSparseNode, 0}; +static swig_type_info _swigt__p_CvStarDetectorParams = {"_p_CvStarDetectorParams", "CvStarDetectorParams *", 0, 0, (void*)&_wrap_class_CvStarDetectorParams, 0}; +static swig_type_info _swigt__p_CvStarKeypoint = {"_p_CvStarKeypoint", "CvStarKeypoint *", 0, 0, (void*)&_wrap_class_CvStarKeypoint, 0}; +static swig_type_info _swigt__p_CvStereoBMState = {"_p_CvStereoBMState", "CvStereoBMState *", 0, 0, (void*)&_wrap_class_CvStereoBMState, 0}; +static swig_type_info _swigt__p_CvStereoGCState = {"_p_CvStereoGCState", "CvStereoGCState *", 0, 0, (void*)&_wrap_class_CvStereoGCState, 0}; +static swig_type_info _swigt__p_CvString = {"_p_CvString", "CvString *", 0, 0, (void*)&_wrap_class_CvString, 0}; +static swig_type_info _swigt__p_CvStringHashNode = {"_p_CvStringHashNode", "CvStringHashNode *", 0, 0, (void*)&_wrap_class_CvStringHashNode, 0}; +static swig_type_info _swigt__p_CvSubdiv2D = {"_p_CvSubdiv2D", "CvSubdiv2D *", 0, 0, (void*)&_wrap_class_CvSubdiv2D, 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*)&_wrap_class_CvSubdiv2DPoint, 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*)&_wrap_class_CvTermCriteria, 0}; +static swig_type_info _swigt__p_CvTreeNodeIterator = {"_p_CvTreeNodeIterator", "CvTreeNodeIterator *", 0, 0, (void*)&_wrap_class_CvTreeNodeIterator, 0}; +static swig_type_info _swigt__p_CvTupleT_CvPoint_2_t = {"_p_CvTupleT_CvPoint_2_t", "CvTuple< CvPoint,2 > *", 0, 0, (void*)&_wrap_class_CvTuple_CvPoint_2, 0}; +static swig_type_info _swigt__p_CvTupleT_float_2_t = {"_p_CvTupleT_float_2_t", "CvTuple< float,2 > *", 0, 0, (void*)&_wrap_class_CvTuple_float_2, 0}; +static swig_type_info _swigt__p_CvTupleT_float_3_t = {"_p_CvTupleT_float_3_t", "CvTuple< float,3 > *", 0, 0, (void*)&_wrap_class_CvTuple_float_3, 0}; +static swig_type_info _swigt__p_CvType = {"_p_CvType", "CvType *", 0, 0, (void*)&_wrap_class_CvType, 0}; +static swig_type_info _swigt__p_CvTypeInfo = {"_p_CvTypeInfo", "CvTypeInfo *", 0, 0, (void*)&_wrap_class_CvTypeInfo, 0}; +static swig_type_info _swigt__p_CvTypedSeqT_CvConnectedComp_t = {"_p_CvTypedSeqT_CvConnectedComp_t", "CvTypedSeq< CvConnectedComp > *", 0, 0, (void*)&_wrap_class_CvSeq_CvConnectedComp, 0}; +static swig_type_info _swigt__p_CvTypedSeqT_CvPoint2D32f_t = {"_p_CvTypedSeqT_CvPoint2D32f_t", "CvTypedSeq< CvPoint2D32f > *", 0, 0, (void*)&_wrap_class_CvSeq_CvPoint2D32f, 0}; +static swig_type_info _swigt__p_CvTypedSeqT_CvPoint_t = {"_p_CvTypedSeqT_CvPoint_t", "CvTypedSeq< CvPoint > *", 0, 0, (void*)&_wrap_class_CvSeq_CvPoint, 0}; +static swig_type_info _swigt__p_CvTypedSeqT_CvQuadEdge2D_t = {"_p_CvTypedSeqT_CvQuadEdge2D_t", "CvTypedSeq< CvQuadEdge2D > *", 0, 0, (void*)&_wrap_class_CvSeq_CvQuadEdge2D, 0}; +static swig_type_info _swigt__p_CvTypedSeqT_CvRect_t = {"_p_CvTypedSeqT_CvRect_t", "CvTypedSeq< CvRect > *", 0, 0, (void*)&_wrap_class_CvSeq_CvRect, 0}; +static swig_type_info _swigt__p_CvTypedSeqT_CvSeq_p_t = {"_p_CvTypedSeqT_CvSeq_p_t", "CvTypedSeq< CvSeq * > *", 0, 0, (void*)&_wrap_class_CvSeq_CvSeq, 0}; +static swig_type_info _swigt__p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t = {"_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t", "CvTypedSeq< CvTuple< CvPoint,2 > > *", 0, 0, (void*)&_wrap_class_CvSeq_CvPoint_2, 0}; +static swig_type_info _swigt__p_CvTypedSeqT_CvTupleT_float_2_t_t = {"_p_CvTypedSeqT_CvTupleT_float_2_t_t", "CvTypedSeq< CvTuple< float,2 > > *", 0, 0, (void*)&_wrap_class_CvSeq_float_2, 0}; +static swig_type_info _swigt__p_CvTypedSeqT_CvTupleT_float_3_t_t = {"_p_CvTypedSeqT_CvTupleT_float_3_t_t", "CvTypedSeq< CvTuple< float,3 > > *", 0, 0, (void*)&_wrap_class_CvSeq_float_3, 0}; +static swig_type_info _swigt__p__CvContourScanner = {"_p__CvContourScanner", "_CvContourScanner *|CvContourScanner", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p__IplConvKernel = {"_p__IplConvKernel", "_IplConvKernel *|IplConvKernel *", 0, 0, (void*)&_wrap_class_IplConvKernel, 0}; +static swig_type_info _swigt__p__IplConvKernelFP = {"_p__IplConvKernelFP", "_IplConvKernelFP *|IplConvKernelFP *", 0, 0, (void*)&_wrap_class_IplConvKernelFP, 0}; +static swig_type_info _swigt__p__IplImage = {"_p__IplImage", "_IplImage *|IplImage *", 0, 0, (void*)&_wrap_class_IplImage, 0}; +static swig_type_info _swigt__p__IplROI = {"_p__IplROI", "_IplROI *|IplROI *", 0, 0, (void*)&_wrap_class_IplROI, 0}; +static swig_type_info _swigt__p__IplTileInfo = {"_p__IplTileInfo", "_IplTileInfo *|IplTileInfo *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_a_2__float = {"_p_a_2__float", "float (*)[2]", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_a_2__signed_char = {"_p_a_2__signed_char", "signed char (*)[2]|schar (*)[2]", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_a_3__float = {"_p_a_3__float", "float (*)[3]", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_int_int_int_int_int__p__IplROI = {"_p_f_int_int_int_int_int__p__IplROI", "Cv_iplCreateROI|_IplROI *(*)(int,int,int,int,int)", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage = {"_p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage", "_IplImage *(*)(int,int,int,char *,char *,int,int,int,int,int,IplROI *,IplImage *,void *,IplTileInfo *)|Cv_iplCreateImageHeader", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int = {"_p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int", "int (*)(int,char const *,char const *,char const *,int,void *)|CvErrorCallback", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_CvFileStorage_p_CvFileNode__p_void = {"_p_f_p_CvFileStorage_p_CvFileNode__p_void", "void *(*)(CvFileStorage *,CvFileNode *)|CvReadFunc", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void = {"_p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void", "void (*)(CvFileStorage *,char const *,void const *,CvAttrList)|CvWriteFunc", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p__IplImage_int__void = {"_p_f_p__IplImage_int__void", "Cv_iplDeallocate|void (*)(_IplImage *,int)", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p__IplImage_int_int__void = {"_p_f_p__IplImage_int_int__void", "Cv_iplAllocateImageData|void (*)(_IplImage *,int,int)", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_p_void__void = {"_p_f_p_p_void__void", "void (*)(void **)|CvReleaseFunc", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_q_const__IplImage__p__IplImage = {"_p_f_p_q_const__IplImage__p__IplImage", "_IplImage *(*)(IplImage const *)|Cv_iplCloneImage", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_q_const__char_int__p_CvMat = {"_p_f_p_q_const__char_int__p_CvMat", "CvMat *(*)(char const *,int)|CvLoadImageMFunc", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_q_const__char_int__p__IplImage = {"_p_f_p_q_const__char_int__p__IplImage", "CvLoadImageFunc|_IplImage *(*)(char const *,int)", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_q_const__char_p_q_const__void__void = {"_p_f_p_q_const__char_p_q_const__void__void", "CvShowImageFunc|void (*)(char const *,void const *)", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_q_const__char_p_q_const__void_p_q_const__int__int = {"_p_f_p_q_const__char_p_q_const__void_p_q_const__int__int", "CvSaveImageFunc|int (*)(char const *,void const *,int const *)", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_q_const__float_p_q_const__float_p_void__float = {"_p_f_p_q_const__float_p_q_const__float_p_void__float", "CvDistanceFunction|float (*)(float const *,float const *,void *)", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_q_const__void__int = {"_p_f_p_q_const__void__int", "CvIsInstanceFunc|int (*)(void const *)", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_q_const__void__p_void = {"_p_f_p_q_const__void__p_void", "CvCloneFunc|void *(*)(void const *)", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_q_const__void_p_q_const__void_p_void__int = {"_p_f_p_q_const__void_p_q_const__void_p_void__int", "CvCmpFunc|int (*)(void const *,void const *,void *)", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_void_p_void__int = {"_p_f_p_void_p_void__int", "int (*)(void *,void *)|CvFreeFunc", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_size_t_p_void__p_void = {"_p_f_size_t_p_void__p_void", "CvAllocFunc|void *(*)(size_t,void *)", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_float = {"_p_float", "float *|CvVect32f|CvMatr32f", 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_CvConDensation = {"_p_p_CvConDensation", "CvConDensation **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvFileStorage = {"_p_p_CvFileStorage", "CvFileStorage **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvGraphEdge = {"_p_p_CvGraphEdge", "CvGraphEdge **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvGraphScanner = {"_p_p_CvGraphScanner", "CvGraphScanner **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvGraphVtx = {"_p_p_CvGraphVtx", "CvGraphVtx **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvHaarClassifierCascade = {"_p_p_CvHaarClassifierCascade", "CvHaarClassifierCascade **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvHistogram = {"_p_p_CvHistogram", "CvHistogram **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvKalman = {"_p_p_CvKalman", "CvKalman **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvLSH = {"_p_p_CvLSH", "CvLSH **", 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_CvMatND = {"_p_p_CvMatND", "CvMatND **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvMemStorage = {"_p_p_CvMemStorage", "CvMemStorage **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvPOSITObject = {"_p_p_CvPOSITObject", "CvPOSITObject **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvPoint = {"_p_p_CvPoint", "CvPoint **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvSeq = {"_p_p_CvSeq", "CvSeq **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t = {"_p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_CvTypedSeqT_CvTupleT_float_2_t_t = {"_p_p_CvTypedSeqT_CvTupleT_float_2_t_t", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_CvTypedSeqT_CvRect_t = {"_p_p_CvTypedSeqT_CvRect_t", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_CvTypedSeqT_CvPoint_t = {"_p_p_CvTypedSeqT_CvPoint_t", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_CvTypedSeqT_CvQuadEdge2D_t = {"_p_p_CvTypedSeqT_CvQuadEdge2D_t", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_CvTypedSeqT_CvSeq_p_t = {"_p_p_CvTypedSeqT_CvSeq_p_t", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_CvTypedSeqT_CvPoint2D32f_t = {"_p_p_CvTypedSeqT_CvPoint2D32f_t", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_CvTypedSeqT_CvTupleT_float_3_t_t = {"_p_p_CvTypedSeqT_CvTupleT_float_3_t_t", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_CvTypedSeqT_CvConnectedComp_t = {"_p_p_CvTypedSeqT_CvConnectedComp_t", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_CvSeqBlock = {"_p_p_CvSeqBlock", "CvSeqBlock **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvSetElem = {"_p_p_CvSetElem", "CvSetElem **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvSparseMat = {"_p_p_CvSparseMat", "CvSparseMat **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvStereoBMState = {"_p_p_CvStereoBMState", "CvStereoBMState **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvStereoGCState = {"_p_p_CvStereoGCState", "CvStereoGCState **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_CvSubdiv2DPoint = {"_p_p_CvSubdiv2DPoint", "CvSubdiv2DPoint **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p__CvContourScanner = {"_p_p__CvContourScanner", "CvContourScanner *|_CvContourScanner **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p__IplConvKernel = {"_p_p__IplConvKernel", "_IplConvKernel **|IplConvKernel **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p__IplImage = {"_p_p__IplImage", "_IplImage **|IplImage **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 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_p_CvMat = {"_p_p_p_CvMat", "CvMat ***", 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_p_void = {"_p_p_void", "void **|CvArr **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_short = {"_p_short", "short *", 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_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t = {"_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t", "std::vector< CvPoint,std::allocator< CvPoint > > *|std::vector< CvPoint > *", 0, 0, (void*)&_wrap_class_CvPointVector, 0}; +static swig_type_info _swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type = {"_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type", "std::vector< CvPoint >::allocator_type *|std::allocator< CvPoint > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type = {"_p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type", "std::vector< CvPoint >::value_type *|CvPoint *", 0, 0, (void*)&_wrap_class_CvPoint, 0}; +static swig_type_info _swigt__p_std__vectorT_float_std__allocatorT_float_t_t = {"_p_std__vectorT_float_std__allocatorT_float_t_t", "std::vector< float > *|std::vector< float,std::allocator< float > > *", 0, 0, (void*)&_wrap_class_FloatVector, 0}; +static swig_type_info _swigt__p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type = {"_p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type", "std::vector< float >::allocator_type *|std::allocator< float > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_swig__OctSwigIterator = {"_p_swig__OctSwigIterator", "swig::OctSwigIterator *", 0, 0, (void*)&_wrap_class_OctSwigIterator, 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_int = {"_p_unsigned_int", "unsigned int *", 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_value_type = {"_p_value_type", "value_type *", 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__p_Cv32suf, + &_swigt__p_Cv64suf, + &_swigt__p_CvAttrList, + &_swigt__p_CvAvgComp, + &_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_CvFeatureTree, + &_swigt__p_CvFileNode, + &_swigt__p_CvFileNode_data, + &_swigt__p_CvFileStorage, + &_swigt__p_CvFilter, + &_swigt__p_CvFont, + &_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_CvHaarFeature_rect, + &_swigt__p_CvHaarStageClassifier, + &_swigt__p_CvHidHaarClassifierCascade, + &_swigt__p_CvHistogram, + &_swigt__p_CvHuMoments, + &_swigt__p_CvImage, + &_swigt__p_CvKalman, + &_swigt__p_CvLSH, + &_swigt__p_CvLSHOperations, + &_swigt__p_CvLineIterator, + &_swigt__p_CvMSERParams, + &_swigt__p_CvMat, + &_swigt__p_CvMatND, + &_swigt__p_CvMatND_data, + &_swigt__p_CvMatND_dim, + &_swigt__p_CvMat_data, + &_swigt__p_CvMatrix, + &_swigt__p_CvMatrix3, + &_swigt__p_CvMemBlock, + &_swigt__p_CvMemStorage, + &_swigt__p_CvMemStoragePos, + &_swigt__p_CvModule, + &_swigt__p_CvModuleInfo, + &_swigt__p_CvMoments, + &_swigt__p_CvNArrayIterator, + &_swigt__p_CvNextEdgeType, + &_swigt__p_CvPOSITObject, + &_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_CvRandState, + &_swigt__p_CvRect, + &_swigt__p_CvSURFParams, + &_swigt__p_CvSURFPoint, + &_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_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_CvTreeNodeIterator, + &_swigt__p_CvTupleT_CvPoint_2_t, + &_swigt__p_CvTupleT_float_2_t, + &_swigt__p_CvTupleT_float_3_t, + &_swigt__p_CvType, + &_swigt__p_CvTypeInfo, + &_swigt__p_CvTypedSeqT_CvConnectedComp_t, + &_swigt__p_CvTypedSeqT_CvPoint2D32f_t, + &_swigt__p_CvTypedSeqT_CvPoint_t, + &_swigt__p_CvTypedSeqT_CvQuadEdge2D_t, + &_swigt__p_CvTypedSeqT_CvRect_t, + &_swigt__p_CvTypedSeqT_CvSeq_p_t, + &_swigt__p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, + &_swigt__p_CvTypedSeqT_CvTupleT_float_2_t_t, + &_swigt__p_CvTypedSeqT_CvTupleT_float_3_t_t, + &_swigt__p__CvContourScanner, + &_swigt__p__IplConvKernel, + &_swigt__p__IplConvKernelFP, + &_swigt__p__IplImage, + &_swigt__p__IplROI, + &_swigt__p__IplTileInfo, + &_swigt__p_a_2__float, + &_swigt__p_a_2__signed_char, + &_swigt__p_a_3__float, + &_swigt__p_allocator_type, + &_swigt__p_char, + &_swigt__p_difference_type, + &_swigt__p_double, + &_swigt__p_f_int_int_int_int_int__p__IplROI, + &_swigt__p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage, + &_swigt__p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int, + &_swigt__p_f_p_CvFileStorage_p_CvFileNode__p_void, + &_swigt__p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void, + &_swigt__p_f_p__IplImage_int__void, + &_swigt__p_f_p__IplImage_int_int__void, + &_swigt__p_f_p_p_void__void, + &_swigt__p_f_p_q_const__IplImage__p__IplImage, + &_swigt__p_f_p_q_const__char_int__p_CvMat, + &_swigt__p_f_p_q_const__char_int__p__IplImage, + &_swigt__p_f_p_q_const__char_p_q_const__void__void, + &_swigt__p_f_p_q_const__char_p_q_const__void_p_q_const__int__int, + &_swigt__p_f_p_q_const__float_p_q_const__float_p_void__float, + &_swigt__p_f_p_q_const__void__int, + &_swigt__p_f_p_q_const__void__p_void, + &_swigt__p_f_p_q_const__void_p_q_const__void_p_void__int, + &_swigt__p_f_p_void_p_void__int, + &_swigt__p_f_size_t_p_void__p_void, + &_swigt__p_float, + &_swigt__p_int, + &_swigt__p_int64_t, + &_swigt__p_p_CvConDensation, + &_swigt__p_p_CvFileStorage, + &_swigt__p_p_CvGraphEdge, + &_swigt__p_p_CvGraphScanner, + &_swigt__p_p_CvGraphVtx, + &_swigt__p_p_CvHaarClassifierCascade, + &_swigt__p_p_CvHistogram, + &_swigt__p_p_CvKalman, + &_swigt__p_p_CvLSH, + &_swigt__p_p_CvMat, + &_swigt__p_p_CvMatND, + &_swigt__p_p_CvMemStorage, + &_swigt__p_p_CvPOSITObject, + &_swigt__p_p_CvPoint, + &_swigt__p_p_CvSeq, + &_swigt__p_p_CvSeqBlock, + &_swigt__p_p_CvSetElem, + &_swigt__p_p_CvSparseMat, + &_swigt__p_p_CvStereoBMState, + &_swigt__p_p_CvStereoGCState, + &_swigt__p_p_CvSubdiv2DPoint, + &_swigt__p_p_CvTypedSeqT_CvConnectedComp_t, + &_swigt__p_p_CvTypedSeqT_CvPoint2D32f_t, + &_swigt__p_p_CvTypedSeqT_CvPoint_t, + &_swigt__p_p_CvTypedSeqT_CvQuadEdge2D_t, + &_swigt__p_p_CvTypedSeqT_CvRect_t, + &_swigt__p_p_CvTypedSeqT_CvSeq_p_t, + &_swigt__p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, + &_swigt__p_p_CvTypedSeqT_CvTupleT_float_2_t_t, + &_swigt__p_p_CvTypedSeqT_CvTupleT_float_3_t_t, + &_swigt__p_p__CvContourScanner, + &_swigt__p_p__IplConvKernel, + &_swigt__p_p__IplImage, + &_swigt__p_p_char, + &_swigt__p_p_float, + &_swigt__p_p_p_CvMat, + &_swigt__p_p_unsigned_char, + &_swigt__p_p_void, + &_swigt__p_short, + &_swigt__p_signed_char, + &_swigt__p_size_t, + &_swigt__p_size_type, + &_swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, + &_swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type, + &_swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, + &_swigt__p_std__vectorT_float_std__allocatorT_float_t_t, + &_swigt__p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type, + &_swigt__p_swig__OctSwigIterator, + &_swigt__p_uint64_t, + &_swigt__p_unsigned_char, + &_swigt__p_unsigned_int, + &_swigt__p_unsigned_short, + &_swigt__p_value_type, + &_swigt__p_void, +}; + +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_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_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_CvFeatureTree[] = { {&_swigt__p_CvFeatureTree, 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_CvFileNode_data[] = { {&_swigt__p_CvFileNode_data, 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_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_CvHaarFeature_rect[] = { {&_swigt__p_CvHaarFeature_rect, 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_CvImage[] = { {&_swigt__p_CvImage, 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_CvLSH[] = { {&_swigt__p_CvLSH, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvLSHOperations[] = { {&_swigt__p_CvLSHOperations, 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_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_CvMatND_data[] = { {&_swigt__p_CvMatND_data, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvMatND_dim[] = { {&_swigt__p_CvMatND_dim, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvMat_data[] = { {&_swigt__p_CvMat_data, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvMatrix[] = { {&_swigt__p_CvMatrix, 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_CvModule[] = { {&_swigt__p_CvModule, 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_CvPOSITObject[] = { {&_swigt__p_CvPOSITObject, 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_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0, 0, 0}, {&_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_CvRandState[] = { {&_swigt__p_CvRandState, 0, 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_CvScalar[] = { {&_swigt__p_CvScalar, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvSeq[] = { {&_swigt__p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, _p_CvTypedSeqT_CvTupleT_CvPoint_2_t_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvTupleT_float_2_t_t, _p_CvTypedSeqT_CvTupleT_float_2_t_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvRect_t, _p_CvTypedSeqT_CvRect_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvPoint_t, _p_CvTypedSeqT_CvPoint_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvQuadEdge2D_t, _p_CvTypedSeqT_CvQuadEdge2D_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvSeq_p_t, _p_CvTypedSeqT_CvSeq_p_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvPoint2D32f_t, _p_CvTypedSeqT_CvPoint2D32f_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvSeq, 0, 0, 0}, {&_swigt__p_CvTypedSeqT_CvTupleT_float_3_t_t, _p_CvTypedSeqT_CvTupleT_float_3_t_tTo_p_CvSeq, 0, 0}, {&_swigt__p_CvTypedSeqT_CvConnectedComp_t, _p_CvTypedSeqT_CvConnectedComp_tTo_p_CvSeq, 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_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_CvTreeNodeIterator[] = { {&_swigt__p_CvTreeNodeIterator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvTupleT_CvPoint_2_t[] = { {&_swigt__p_CvTupleT_CvPoint_2_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvTupleT_float_2_t[] = { {&_swigt__p_CvTupleT_float_2_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvTupleT_float_3_t[] = { {&_swigt__p_CvTupleT_float_3_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvType[] = { {&_swigt__p_CvType, 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_CvTypedSeqT_CvConnectedComp_t[] = { {&_swigt__p_CvTypedSeqT_CvConnectedComp_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvTypedSeqT_CvPoint2D32f_t[] = { {&_swigt__p_CvTypedSeqT_CvPoint2D32f_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvTypedSeqT_CvPoint_t[] = { {&_swigt__p_CvTypedSeqT_CvPoint_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvTypedSeqT_CvQuadEdge2D_t[] = { {&_swigt__p_CvTypedSeqT_CvQuadEdge2D_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvTypedSeqT_CvRect_t[] = { {&_swigt__p_CvTypedSeqT_CvRect_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvTypedSeqT_CvSeq_p_t[] = { {&_swigt__p_CvTypedSeqT_CvSeq_p_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t[] = { {&_swigt__p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvTypedSeqT_CvTupleT_float_2_t_t[] = { {&_swigt__p_CvTypedSeqT_CvTupleT_float_2_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CvTypedSeqT_CvTupleT_float_3_t_t[] = { {&_swigt__p_CvTypedSeqT_CvTupleT_float_3_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p__CvContourScanner[] = { {&_swigt__p__CvContourScanner, 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_a_2__float[] = { {&_swigt__p_a_2__float, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_a_2__signed_char[] = { {&_swigt__p_a_2__signed_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_a_3__float[] = { {&_swigt__p_a_3__float, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_allocator_type[] = { {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_int_int_int_int_int__p__IplROI[] = { {&_swigt__p_f_int_int_int_int_int__p__IplROI, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage[] = { {&_swigt__p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int[] = { {&_swigt__p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_CvFileStorage_p_CvFileNode__p_void[] = { {&_swigt__p_f_p_CvFileStorage_p_CvFileNode__p_void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void[] = { {&_swigt__p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p__IplImage_int__void[] = { {&_swigt__p_f_p__IplImage_int__void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p__IplImage_int_int__void[] = { {&_swigt__p_f_p__IplImage_int_int__void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_p_void__void[] = { {&_swigt__p_f_p_p_void__void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_q_const__IplImage__p__IplImage[] = { {&_swigt__p_f_p_q_const__IplImage__p__IplImage, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_q_const__char_int__p_CvMat[] = { {&_swigt__p_f_p_q_const__char_int__p_CvMat, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_q_const__char_int__p__IplImage[] = { {&_swigt__p_f_p_q_const__char_int__p__IplImage, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_q_const__char_p_q_const__void__void[] = { {&_swigt__p_f_p_q_const__char_p_q_const__void__void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_q_const__char_p_q_const__void_p_q_const__int__int[] = { {&_swigt__p_f_p_q_const__char_p_q_const__void_p_q_const__int__int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_q_const__float_p_q_const__float_p_void__float[] = { {&_swigt__p_f_p_q_const__float_p_q_const__float_p_void__float, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_q_const__void__int[] = { {&_swigt__p_f_p_q_const__void__int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_q_const__void__p_void[] = { {&_swigt__p_f_p_q_const__void__p_void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_q_const__void_p_q_const__void_p_void__int[] = { {&_swigt__p_f_p_q_const__void_p_q_const__void_p_void__int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_void_p_void__int[] = { {&_swigt__p_f_p_void_p_void__int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_size_t_p_void__p_void[] = { {&_swigt__p_f_size_t_p_void__p_void, 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_CvConDensation[] = { {&_swigt__p_p_CvConDensation, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvFileStorage[] = { {&_swigt__p_p_CvFileStorage, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvGraphEdge[] = { {&_swigt__p_p_CvGraphEdge, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvGraphScanner[] = { {&_swigt__p_p_CvGraphScanner, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvGraphVtx[] = { {&_swigt__p_p_CvGraphVtx, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvHaarClassifierCascade[] = { {&_swigt__p_p_CvHaarClassifierCascade, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvHistogram[] = { {&_swigt__p_p_CvHistogram, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvKalman[] = { {&_swigt__p_p_CvKalman, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvLSH[] = { {&_swigt__p_p_CvLSH, 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_CvMatND[] = { {&_swigt__p_p_CvMatND, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvMemStorage[] = { {&_swigt__p_p_CvMemStorage, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvPOSITObject[] = { {&_swigt__p_p_CvPOSITObject, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvPoint[] = { {&_swigt__p_p_CvPoint, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t[] = {{&_swigt__p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvTypedSeqT_CvTupleT_float_2_t_t[] = {{&_swigt__p_p_CvTypedSeqT_CvTupleT_float_2_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvTypedSeqT_CvRect_t[] = {{&_swigt__p_p_CvTypedSeqT_CvRect_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvTypedSeqT_CvPoint_t[] = {{&_swigt__p_p_CvTypedSeqT_CvPoint_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvTypedSeqT_CvQuadEdge2D_t[] = {{&_swigt__p_p_CvTypedSeqT_CvQuadEdge2D_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvTypedSeqT_CvSeq_p_t[] = {{&_swigt__p_p_CvTypedSeqT_CvSeq_p_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvTypedSeqT_CvPoint2D32f_t[] = {{&_swigt__p_p_CvTypedSeqT_CvPoint2D32f_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvTypedSeqT_CvTupleT_float_3_t_t[] = {{&_swigt__p_p_CvTypedSeqT_CvTupleT_float_3_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvTypedSeqT_CvConnectedComp_t[] = {{&_swigt__p_p_CvTypedSeqT_CvConnectedComp_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvSeq[] = { {&_swigt__p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, _p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvTupleT_float_2_t_t, _p_p_CvTypedSeqT_CvTupleT_float_2_t_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvRect_t, _p_p_CvTypedSeqT_CvRect_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvPoint_t, _p_p_CvTypedSeqT_CvPoint_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvQuadEdge2D_t, _p_p_CvTypedSeqT_CvQuadEdge2D_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvSeq_p_t, _p_p_CvTypedSeqT_CvSeq_p_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvPoint2D32f_t, _p_p_CvTypedSeqT_CvPoint2D32f_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvSeq, 0, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvTupleT_float_3_t_t, _p_p_CvTypedSeqT_CvTupleT_float_3_t_tTo_p_p_CvSeq, 0, 0}, {&_swigt__p_p_CvTypedSeqT_CvConnectedComp_t, _p_p_CvTypedSeqT_CvConnectedComp_tTo_p_p_CvSeq, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvSeqBlock[] = { {&_swigt__p_p_CvSeqBlock, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvSetElem[] = { {&_swigt__p_p_CvSetElem, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvSparseMat[] = { {&_swigt__p_p_CvSparseMat, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvStereoBMState[] = { {&_swigt__p_p_CvStereoBMState, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvStereoGCState[] = { {&_swigt__p_p_CvStereoGCState, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_CvSubdiv2DPoint[] = { {&_swigt__p_p_CvSubdiv2DPoint, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p__CvContourScanner[] = { {&_swigt__p_p__CvContourScanner, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p__IplConvKernel[] = { {&_swigt__p_p__IplConvKernel, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p__IplImage[] = { {&_swigt__p_p__IplImage, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 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_p_CvMat[] = { {&_swigt__p_p_p_CvMat, 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_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 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_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t[] = { {&_swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type[] = { {&_swigt__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, 0, 0, 0}, {&_swigt__p_CvPoint, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_float_std__allocatorT_float_t_t[] = { {&_swigt__p_std__vectorT_float_std__allocatorT_float_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type[] = { {&_swigt__p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_swig__OctSwigIterator[] = { {&_swigt__p_swig__OctSwigIterator, 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_int[] = { {&_swigt__p_unsigned_int, 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_value_type[] = { {&_swigt__p_value_type, 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__p_Cv32suf, + _swigc__p_Cv64suf, + _swigc__p_CvAttrList, + _swigc__p_CvAvgComp, + _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_CvFeatureTree, + _swigc__p_CvFileNode, + _swigc__p_CvFileNode_data, + _swigc__p_CvFileStorage, + _swigc__p_CvFilter, + _swigc__p_CvFont, + _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_CvHaarFeature_rect, + _swigc__p_CvHaarStageClassifier, + _swigc__p_CvHidHaarClassifierCascade, + _swigc__p_CvHistogram, + _swigc__p_CvHuMoments, + _swigc__p_CvImage, + _swigc__p_CvKalman, + _swigc__p_CvLSH, + _swigc__p_CvLSHOperations, + _swigc__p_CvLineIterator, + _swigc__p_CvMSERParams, + _swigc__p_CvMat, + _swigc__p_CvMatND, + _swigc__p_CvMatND_data, + _swigc__p_CvMatND_dim, + _swigc__p_CvMat_data, + _swigc__p_CvMatrix, + _swigc__p_CvMatrix3, + _swigc__p_CvMemBlock, + _swigc__p_CvMemStorage, + _swigc__p_CvMemStoragePos, + _swigc__p_CvModule, + _swigc__p_CvModuleInfo, + _swigc__p_CvMoments, + _swigc__p_CvNArrayIterator, + _swigc__p_CvNextEdgeType, + _swigc__p_CvPOSITObject, + _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_CvRandState, + _swigc__p_CvRect, + _swigc__p_CvSURFParams, + _swigc__p_CvSURFPoint, + _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_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_CvTreeNodeIterator, + _swigc__p_CvTupleT_CvPoint_2_t, + _swigc__p_CvTupleT_float_2_t, + _swigc__p_CvTupleT_float_3_t, + _swigc__p_CvType, + _swigc__p_CvTypeInfo, + _swigc__p_CvTypedSeqT_CvConnectedComp_t, + _swigc__p_CvTypedSeqT_CvPoint2D32f_t, + _swigc__p_CvTypedSeqT_CvPoint_t, + _swigc__p_CvTypedSeqT_CvQuadEdge2D_t, + _swigc__p_CvTypedSeqT_CvRect_t, + _swigc__p_CvTypedSeqT_CvSeq_p_t, + _swigc__p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, + _swigc__p_CvTypedSeqT_CvTupleT_float_2_t_t, + _swigc__p_CvTypedSeqT_CvTupleT_float_3_t_t, + _swigc__p__CvContourScanner, + _swigc__p__IplConvKernel, + _swigc__p__IplConvKernelFP, + _swigc__p__IplImage, + _swigc__p__IplROI, + _swigc__p__IplTileInfo, + _swigc__p_a_2__float, + _swigc__p_a_2__signed_char, + _swigc__p_a_3__float, + _swigc__p_allocator_type, + _swigc__p_char, + _swigc__p_difference_type, + _swigc__p_double, + _swigc__p_f_int_int_int_int_int__p__IplROI, + _swigc__p_f_int_int_int_p_char_p_char_int_int_int_int_int_p_IplROI_p_IplImage_p_void_p_IplTileInfo__p__IplImage, + _swigc__p_f_int_p_q_const__char_p_q_const__char_p_q_const__char_int_p_void__int, + _swigc__p_f_p_CvFileStorage_p_CvFileNode__p_void, + _swigc__p_f_p_CvFileStorage_p_q_const__char_p_q_const__void_CvAttrList__void, + _swigc__p_f_p__IplImage_int__void, + _swigc__p_f_p__IplImage_int_int__void, + _swigc__p_f_p_p_void__void, + _swigc__p_f_p_q_const__IplImage__p__IplImage, + _swigc__p_f_p_q_const__char_int__p_CvMat, + _swigc__p_f_p_q_const__char_int__p__IplImage, + _swigc__p_f_p_q_const__char_p_q_const__void__void, + _swigc__p_f_p_q_const__char_p_q_const__void_p_q_const__int__int, + _swigc__p_f_p_q_const__float_p_q_const__float_p_void__float, + _swigc__p_f_p_q_const__void__int, + _swigc__p_f_p_q_const__void__p_void, + _swigc__p_f_p_q_const__void_p_q_const__void_p_void__int, + _swigc__p_f_p_void_p_void__int, + _swigc__p_f_size_t_p_void__p_void, + _swigc__p_float, + _swigc__p_int, + _swigc__p_int64_t, + _swigc__p_p_CvConDensation, + _swigc__p_p_CvFileStorage, + _swigc__p_p_CvGraphEdge, + _swigc__p_p_CvGraphScanner, + _swigc__p_p_CvGraphVtx, + _swigc__p_p_CvHaarClassifierCascade, + _swigc__p_p_CvHistogram, + _swigc__p_p_CvKalman, + _swigc__p_p_CvLSH, + _swigc__p_p_CvMat, + _swigc__p_p_CvMatND, + _swigc__p_p_CvMemStorage, + _swigc__p_p_CvPOSITObject, + _swigc__p_p_CvPoint, + _swigc__p_p_CvSeq, + _swigc__p_p_CvSeqBlock, + _swigc__p_p_CvSetElem, + _swigc__p_p_CvSparseMat, + _swigc__p_p_CvStereoBMState, + _swigc__p_p_CvStereoGCState, + _swigc__p_p_CvSubdiv2DPoint, + _swigc__p_p_CvTypedSeqT_CvConnectedComp_t, + _swigc__p_p_CvTypedSeqT_CvPoint2D32f_t, + _swigc__p_p_CvTypedSeqT_CvPoint_t, + _swigc__p_p_CvTypedSeqT_CvQuadEdge2D_t, + _swigc__p_p_CvTypedSeqT_CvRect_t, + _swigc__p_p_CvTypedSeqT_CvSeq_p_t, + _swigc__p_p_CvTypedSeqT_CvTupleT_CvPoint_2_t_t, + _swigc__p_p_CvTypedSeqT_CvTupleT_float_2_t_t, + _swigc__p_p_CvTypedSeqT_CvTupleT_float_3_t_t, + _swigc__p_p__CvContourScanner, + _swigc__p_p__IplConvKernel, + _swigc__p_p__IplImage, + _swigc__p_p_char, + _swigc__p_p_float, + _swigc__p_p_p_CvMat, + _swigc__p_p_unsigned_char, + _swigc__p_p_void, + _swigc__p_short, + _swigc__p_signed_char, + _swigc__p_size_t, + _swigc__p_size_type, + _swigc__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t, + _swigc__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__allocator_type, + _swigc__p_std__vectorT_CvPoint_std__allocatorT_CvPoint_t_t__value_type, + _swigc__p_std__vectorT_float_std__allocatorT_float_t_t, + _swigc__p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type, + _swigc__p_swig__OctSwigIterator, + _swigc__p_uint64_t, + _swigc__p_unsigned_char, + _swigc__p_unsigned_int, + _swigc__p_unsigned_short, + _swigc__p_value_type, + _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;jassign(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) +{ + SWIG_Octave_SetConstant(module_ns,"sizeof_CvContour",SWIG_From_size_t((size_t)(sizeof(CvContour)))); + SWIG_Octave_SetConstant(module_ns,"sizeof_CvPoint",SWIG_From_size_t((size_t)(sizeof(CvPoint)))); + SWIG_Octave_SetConstant(module_ns,"sizeof_CvSeq",SWIG_From_size_t((size_t)(sizeof(CvSeq)))); + SWIG_Octave_SetConstant(module_ns,"CV_AUTOSTEP",SWIG_From_int((int)(0x7fffffff))); + SWIG_Octave_SetConstant(module_ns,"CV_MAX_ARR",SWIG_From_int((int)(10))); + SWIG_Octave_SetConstant(module_ns,"CV_NO_DEPTH_CHECK",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_NO_CN_CHECK",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_NO_SIZE_CHECK",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_CMP_EQ",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_CMP_GT",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_CMP_GE",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_CMP_LT",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_CMP_LE",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_CMP_NE",SWIG_From_int((int)(5))); + SWIG_Octave_SetConstant(module_ns,"CV_CHECK_RANGE",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_CHECK_QUIET",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_RAND_UNI",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_RAND_NORMAL",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_SORT_EVERY_ROW",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_SORT_EVERY_COLUMN",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_SORT_ASCENDING",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_SORT_DESCENDING",SWIG_From_int((int)(16))); + SWIG_Octave_SetConstant(module_ns,"CV_GEMM_A_T",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_GEMM_B_T",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_GEMM_C_T",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_SVD_MODIFY_A",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_SVD_U_T",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_SVD_V_T",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_LU",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_SVD",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_SVD_SYM",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_CHOLESKY",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_QR",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_NORMAL",SWIG_From_int((int)(16))); + SWIG_Octave_SetConstant(module_ns,"CV_COVAR_SCRAMBLED",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_COVAR_NORMAL",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_COVAR_USE_AVG",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_COVAR_SCALE",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_COVAR_ROWS",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_COVAR_COLS",SWIG_From_int((int)(16))); + SWIG_Octave_SetConstant(module_ns,"CV_PCA_DATA_AS_ROW",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_PCA_DATA_AS_COL",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_PCA_USE_AVG",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_C",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_L1",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_L2",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_NORM_MASK",SWIG_From_int((int)(7))); + SWIG_Octave_SetConstant(module_ns,"CV_RELATIVE",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_DIFF",SWIG_From_int((int)(16))); + SWIG_Octave_SetConstant(module_ns,"CV_MINMAX",SWIG_From_int((int)(32))); + SWIG_Octave_SetConstant(module_ns,"CV_DIFF_C",SWIG_From_int((int)((16|1)))); + SWIG_Octave_SetConstant(module_ns,"CV_DIFF_L1",SWIG_From_int((int)((16|2)))); + SWIG_Octave_SetConstant(module_ns,"CV_DIFF_L2",SWIG_From_int((int)((16|4)))); + SWIG_Octave_SetConstant(module_ns,"CV_RELATIVE_C",SWIG_From_int((int)((8|1)))); + SWIG_Octave_SetConstant(module_ns,"CV_RELATIVE_L1",SWIG_From_int((int)((8|2)))); + SWIG_Octave_SetConstant(module_ns,"CV_RELATIVE_L2",SWIG_From_int((int)((8|4)))); + SWIG_Octave_SetConstant(module_ns,"CV_REDUCE_SUM",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_REDUCE_AVG",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_REDUCE_MAX",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_REDUCE_MIN",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_DXT_FORWARD",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_DXT_INVERSE",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_DXT_SCALE",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_DXT_INV_SCALE",SWIG_From_int((int)((1+2)))); + SWIG_Octave_SetConstant(module_ns,"CV_DXT_INVERSE_SCALE",SWIG_From_int((int)((1+2)))); + SWIG_Octave_SetConstant(module_ns,"CV_DXT_ROWS",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_DXT_MUL_CONJ",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_FRONT",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_BACK",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_VERTEX",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_TREE_EDGE",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_BACK_EDGE",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_FORWARD_EDGE",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_CROSS_EDGE",SWIG_From_int((int)(16))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_ANY_EDGE",SWIG_From_int((int)(30))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_NEW_TREE",SWIG_From_int((int)(32))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_BACKTRACKING",SWIG_From_int((int)(64))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_OVER",SWIG_From_int((int)(-1))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_ALL_ITEMS",SWIG_From_int((int)(-1))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_ITEM_VISITED_FLAG",SWIG_From_int((int)((1 << 30)))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_SEARCH_TREE_NODE_FLAG",SWIG_From_int((int)((1 << 29)))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_FORWARD_EDGE_FLAG",SWIG_From_int((int)((1 << 28)))); + SWIG_Octave_SetConstant(module_ns,"CV_FILLED",SWIG_From_int((int)(-1))); + SWIG_Octave_SetConstant(module_ns,"CV_AA",SWIG_From_int((int)(16))); + SWIG_Octave_SetConstant(module_ns,"CV_FONT_HERSHEY_SIMPLEX",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_FONT_HERSHEY_PLAIN",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_FONT_HERSHEY_DUPLEX",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_FONT_HERSHEY_COMPLEX",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_FONT_HERSHEY_TRIPLEX",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_FONT_HERSHEY_COMPLEX_SMALL",SWIG_From_int((int)(5))); + SWIG_Octave_SetConstant(module_ns,"CV_FONT_HERSHEY_SCRIPT_SIMPLEX",SWIG_From_int((int)(6))); + SWIG_Octave_SetConstant(module_ns,"CV_FONT_HERSHEY_SCRIPT_COMPLEX",SWIG_From_int((int)(7))); + SWIG_Octave_SetConstant(module_ns,"CV_FONT_ITALIC",SWIG_From_int((int)(16))); + SWIG_Octave_SetConstant(module_ns,"CV_FONT_VECTOR0",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_KMEANS_USE_INITIAL_LABELS",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_ErrModeLeaf",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_ErrModeParent",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_ErrModeSilent",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_MAJOR_VERSION",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_MINOR_VERSION",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_SUBMINOR_VERSION",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_PI",octave_value(3.1415926535897932384626433832795)); + SWIG_Octave_SetConstant(module_ns,"CV_LOG2",octave_value(0.69314718055994530941723212145818)); + SWIG_Octave_SetConstant(module_ns,"IPL_DEPTH_SIGN",SWIG_From_int((int)(0x80000000))); + SWIG_Octave_SetConstant(module_ns,"IPL_DEPTH_1U",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"IPL_DEPTH_8U",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"IPL_DEPTH_16U",SWIG_From_int((int)(16))); + SWIG_Octave_SetConstant(module_ns,"IPL_DEPTH_32F",SWIG_From_int((int)(32))); + SWIG_Octave_SetConstant(module_ns,"IPL_DEPTH_8S",SWIG_From_int((int)((0x80000000|8)))); + SWIG_Octave_SetConstant(module_ns,"IPL_DEPTH_16S",SWIG_From_int((int)((0x80000000|16)))); + SWIG_Octave_SetConstant(module_ns,"IPL_DEPTH_32S",SWIG_From_int((int)((0x80000000|32)))); + SWIG_Octave_SetConstant(module_ns,"IPL_DATA_ORDER_PIXEL",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"IPL_DATA_ORDER_PLANE",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"IPL_ORIGIN_TL",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"IPL_ORIGIN_BL",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"IPL_ALIGN_4BYTES",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"IPL_ALIGN_8BYTES",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"IPL_ALIGN_16BYTES",SWIG_From_int((int)(16))); + SWIG_Octave_SetConstant(module_ns,"IPL_ALIGN_32BYTES",SWIG_From_int((int)(32))); + SWIG_Octave_SetConstant(module_ns,"IPL_ALIGN_DWORD",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"IPL_ALIGN_QWORD",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"IPL_BORDER_CONSTANT",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"IPL_BORDER_REPLICATE",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"IPL_BORDER_REFLECT",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"IPL_BORDER_WRAP",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"IPL_IMAGE_HEADER",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"IPL_IMAGE_DATA",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"IPL_IMAGE_ROI",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"IPL_BORDER_REFLECT_101",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_IMAGE",SWIG_FromCharPtr("opencv-image")); + SWIG_Octave_SetConstant(module_ns,"IPL_DEPTH_64F",SWIG_From_int((int)(64))); + SWIG_Octave_SetConstant(module_ns,"CV_CN_MAX",SWIG_From_int((int)(64))); + SWIG_Octave_SetConstant(module_ns,"CV_CN_SHIFT",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_DEPTH_MAX",SWIG_From_int((int)((1 << 3)))); + SWIG_Octave_SetConstant(module_ns,"CV_8U",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_8S",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_16U",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_16S",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_32S",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_32F",SWIG_From_int((int)(5))); + SWIG_Octave_SetConstant(module_ns,"CV_64F",SWIG_From_int((int)(6))); + SWIG_Octave_SetConstant(module_ns,"CV_USRTYPE1",SWIG_From_int((int)(7))); + SWIG_Octave_SetConstant(module_ns,"CV_MAT_DEPTH_MASK",SWIG_From_int((int)(((1 << 3) -1)))); + SWIG_Octave_SetConstant(module_ns,"CV_8UC1",SWIG_From_int((int)((((0) &((1 << 3) -1)) +(((1) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_8UC2",SWIG_From_int((int)((((0) &((1 << 3) -1)) +(((2) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_8UC3",SWIG_From_int((int)((((0) &((1 << 3) -1)) +(((3) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_8UC4",SWIG_From_int((int)((((0) &((1 << 3) -1)) +(((4) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_8SC1",SWIG_From_int((int)((((1) &((1 << 3) -1)) +(((1) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_8SC2",SWIG_From_int((int)((((1) &((1 << 3) -1)) +(((2) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_8SC3",SWIG_From_int((int)((((1) &((1 << 3) -1)) +(((3) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_8SC4",SWIG_From_int((int)((((1) &((1 << 3) -1)) +(((4) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_16UC1",SWIG_From_int((int)((((2) &((1 << 3) -1)) +(((1) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_16UC2",SWIG_From_int((int)((((2) &((1 << 3) -1)) +(((2) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_16UC3",SWIG_From_int((int)((((2) &((1 << 3) -1)) +(((3) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_16UC4",SWIG_From_int((int)((((2) &((1 << 3) -1)) +(((4) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_16SC1",SWIG_From_int((int)((((3) &((1 << 3) -1)) +(((1) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_16SC2",SWIG_From_int((int)((((3) &((1 << 3) -1)) +(((2) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_16SC3",SWIG_From_int((int)((((3) &((1 << 3) -1)) +(((3) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_16SC4",SWIG_From_int((int)((((3) &((1 << 3) -1)) +(((4) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_32SC1",SWIG_From_int((int)((((4) &((1 << 3) -1)) +(((1) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_32SC2",SWIG_From_int((int)((((4) &((1 << 3) -1)) +(((2) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_32SC3",SWIG_From_int((int)((((4) &((1 << 3) -1)) +(((3) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_32SC4",SWIG_From_int((int)((((4) &((1 << 3) -1)) +(((4) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_32FC1",SWIG_From_int((int)((((5) &((1 << 3) -1)) +(((1) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_32FC2",SWIG_From_int((int)((((5) &((1 << 3) -1)) +(((2) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_32FC3",SWIG_From_int((int)((((5) &((1 << 3) -1)) +(((3) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_32FC4",SWIG_From_int((int)((((5) &((1 << 3) -1)) +(((4) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_64FC1",SWIG_From_int((int)((((6) &((1 << 3) -1)) +(((1) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_64FC2",SWIG_From_int((int)((((6) &((1 << 3) -1)) +(((2) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_64FC3",SWIG_From_int((int)((((6) &((1 << 3) -1)) +(((3) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_64FC4",SWIG_From_int((int)((((6) &((1 << 3) -1)) +(((4) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_AUTO_STEP",SWIG_From_int((int)(0x7fffffff))); + SWIG_Octave_SetConstant(module_ns,"CV_MAT_CN_MASK",SWIG_From_int((int)(((64-1) << 3)))); + SWIG_Octave_SetConstant(module_ns,"CV_MAT_TYPE_MASK",SWIG_From_int((int)(((1 << 3) *64-1)))); + SWIG_Octave_SetConstant(module_ns,"CV_MAT_CONT_FLAG_SHIFT",SWIG_From_int((int)(14))); + SWIG_Octave_SetConstant(module_ns,"CV_MAT_CONT_FLAG",SWIG_From_int((int)((1 << 14)))); + SWIG_Octave_SetConstant(module_ns,"CV_MAT_TEMP_FLAG_SHIFT",SWIG_From_int((int)(15))); + SWIG_Octave_SetConstant(module_ns,"CV_MAT_TEMP_FLAG",SWIG_From_int((int)((1 << 15)))); + SWIG_Octave_SetConstant(module_ns,"CV_MAGIC_MASK",SWIG_From_int((int)(0xFFFF0000))); + SWIG_Octave_SetConstant(module_ns,"CV_MAT_MAGIC_VAL",SWIG_From_int((int)(0x42420000))); + SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_MAT",SWIG_FromCharPtr("opencv-matrix")); + SWIG_Octave_SetConstant(module_ns,"CV_MATND_MAGIC_VAL",SWIG_From_int((int)(0x42430000))); + SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_MATND",SWIG_FromCharPtr("opencv-nd-matrix")); + SWIG_Octave_SetConstant(module_ns,"CV_MAX_DIM",SWIG_From_int((int)(32))); + SWIG_Octave_SetConstant(module_ns,"CV_MAX_DIM_HEAP",SWIG_From_int((int)((1 << 16)))); + SWIG_Octave_SetConstant(module_ns,"CV_SPARSE_MAT_MAGIC_VAL",SWIG_From_int((int)(0x42440000))); + SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_SPARSE_MAT",SWIG_FromCharPtr("opencv-sparse-matrix")); + SWIG_Octave_SetConstant(module_ns,"CV_HIST_MAGIC_VAL",SWIG_From_int((int)(0x42450000))); + SWIG_Octave_SetConstant(module_ns,"CV_HIST_UNIFORM_FLAG",SWIG_From_int((int)((1 << 10)))); + SWIG_Octave_SetConstant(module_ns,"CV_HIST_RANGES_FLAG",SWIG_From_int((int)((1 << 11)))); + SWIG_Octave_SetConstant(module_ns,"CV_HIST_ARRAY",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_HIST_SPARSE",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_HIST_TREE",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_HIST_UNIFORM",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_TERMCRIT_ITER",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_TERMCRIT_NUMBER",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_TERMCRIT_EPS",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_WHOLE_SEQ_END_INDEX",SWIG_From_int((int)(0x3fffffff))); + SWIG_Octave_SetConstant(module_ns,"CV_STORAGE_MAGIC_VAL",SWIG_From_int((int)(0x42890000))); + SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_SEQ",SWIG_FromCharPtr("opencv-sequence")); + SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_SEQ_TREE",SWIG_FromCharPtr("opencv-sequence-tree")); + SWIG_Octave_SetConstant(module_ns,"CV_SET_ELEM_IDX_MASK",SWIG_From_int((int)(((1 << 26) -1)))); + SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_GRAPH",SWIG_FromCharPtr("opencv-graph")); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_MAGIC_VAL",SWIG_From_int((int)(0x42990000))); + SWIG_Octave_SetConstant(module_ns,"CV_SET_MAGIC_VAL",SWIG_From_int((int)(0x42980000))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_ELTYPE_BITS",SWIG_From_int((int)(9))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_ELTYPE_MASK",SWIG_From_int((int)(((1 << 9) -1)))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_ELTYPE_POINT",SWIG_From_int((int)((((4) &((1 << 3) -1)) +(((2) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_ELTYPE_CODE",SWIG_From_int((int)((((0) &((1 << 3) -1)) +(((1) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_ELTYPE_GENERIC",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_ELTYPE_PTR",SWIG_From_int((int)(7))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_ELTYPE_PPOINT",SWIG_From_int((int)(7))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_ELTYPE_INDEX",SWIG_From_int((int)((((4) &((1 << 3) -1)) +(((1) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_ELTYPE_GRAPH_EDGE",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_ELTYPE_GRAPH_VERTEX",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_ELTYPE_TRIAN_ATR",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_ELTYPE_CONNECTED_COMP",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_ELTYPE_POINT3D",SWIG_From_int((int)((((5) &((1 << 3) -1)) +(((3) -1) << 3))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_KIND_BITS",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_KIND_MASK",SWIG_From_int((int)((((1 << 3) -1) << 9)))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_KIND_GENERIC",SWIG_From_int((int)((0 << 9)))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_KIND_CURVE",SWIG_From_int((int)((1 << 9)))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_KIND_BIN_TREE",SWIG_From_int((int)((2 << 9)))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_KIND_GRAPH",SWIG_From_int((int)((3 << 9)))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_KIND_SUBDIV2D",SWIG_From_int((int)((4 << 9)))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_FLAG_SHIFT",SWIG_From_int((int)((3+9)))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_FLAG_CLOSED",SWIG_From_int((int)((1 << (3+9))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_FLAG_SIMPLE",SWIG_From_int((int)((2 << (3+9))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_FLAG_CONVEX",SWIG_From_int((int)((4 << (3+9))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_FLAG_HOLE",SWIG_From_int((int)((8 << (3+9))))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH_FLAG_ORIENTED",SWIG_From_int((int)((1 << (3+9))))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAPH",SWIG_From_int((int)((3 << 9)))); + SWIG_Octave_SetConstant(module_ns,"CV_ORIENTED_GRAPH",SWIG_From_int((int)(((3 << 9)|(1 << (3+9)))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_POINT_SET",SWIG_From_int((int)(((0 << 9)|(((4) &((1 << 3) -1)) +(((2) -1) << 3)))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_POINT3D_SET",SWIG_From_int((int)(((0 << 9)|(((5) &((1 << 3) -1)) +(((3) -1) << 3)))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_POLYLINE",SWIG_From_int((int)(((1 << 9)|(((4) &((1 << 3) -1)) +(((2) -1) << 3)))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_POLYGON",SWIG_From_int((int)(((1 << (3+9))|((1 << 9)|(((4) &((1 << 3) -1)) +(((2) -1) << 3))))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_CONTOUR",SWIG_From_int((int)(((1 << (3+9))|((1 << 9)|(((4) &((1 << 3) -1)) +(((2) -1) << 3))))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_SIMPLE_POLYGON",SWIG_From_int((int)(((2 << (3+9))|((1 << (3+9))|((1 << 9)|(((4) &((1 << 3) -1)) +(((2) -1) << 3)))))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_CHAIN",SWIG_From_int((int)(((1 << 9)|(((0) &((1 << 3) -1)) +(((1) -1) << 3)))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_CHAIN_CONTOUR",SWIG_From_int((int)(((1 << (3+9))|((1 << 9)|(((0) &((1 << 3) -1)) +(((1) -1) << 3))))))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_POLYGON_TREE",SWIG_From_int((int)(((2 << 9)|0)))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_CONNECTED_COMP",SWIG_From_int((int)(((0 << 9)|0)))); + SWIG_Octave_SetConstant(module_ns,"CV_SEQ_INDEX",SWIG_From_int((int)(((0 << 9)|(((4) &((1 << 3) -1)) +(((1) -1) << 3)))))); + SWIG_Octave_SetConstant(module_ns,"CV_STORAGE_READ",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_STORAGE_WRITE",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_STORAGE_WRITE_TEXT",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_STORAGE_WRITE_BINARY",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_STORAGE_APPEND",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_NONE",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_INT",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_INTEGER",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_REAL",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_FLOAT",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_STR",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_STRING",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_REF",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_SEQ",SWIG_From_int((int)(5))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_MAP",SWIG_From_int((int)(6))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_TYPE_MASK",SWIG_From_int((int)(7))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_FLOW",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_USER",SWIG_From_int((int)(16))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_EMPTY",SWIG_From_int((int)(32))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_NAMED",SWIG_From_int((int)(64))); + SWIG_Octave_SetConstant(module_ns,"CV_NODE_SEQ_SIMPLE",SWIG_From_int((int)(256))); + SWIG_Octave_SetConstant(module_ns,"CV_StsOk",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_StsBackTrace",SWIG_From_int((int)(-1))); + SWIG_Octave_SetConstant(module_ns,"CV_StsError",SWIG_From_int((int)(-2))); + SWIG_Octave_SetConstant(module_ns,"CV_StsInternal",SWIG_From_int((int)(-3))); + SWIG_Octave_SetConstant(module_ns,"CV_StsNoMem",SWIG_From_int((int)(-4))); + SWIG_Octave_SetConstant(module_ns,"CV_StsBadArg",SWIG_From_int((int)(-5))); + SWIG_Octave_SetConstant(module_ns,"CV_StsBadFunc",SWIG_From_int((int)(-6))); + SWIG_Octave_SetConstant(module_ns,"CV_StsNoConv",SWIG_From_int((int)(-7))); + SWIG_Octave_SetConstant(module_ns,"CV_StsAutoTrace",SWIG_From_int((int)(-8))); + SWIG_Octave_SetConstant(module_ns,"CV_HeaderIsNull",SWIG_From_int((int)(-9))); + SWIG_Octave_SetConstant(module_ns,"CV_BadImageSize",SWIG_From_int((int)(-10))); + SWIG_Octave_SetConstant(module_ns,"CV_BadOffset",SWIG_From_int((int)(-11))); + SWIG_Octave_SetConstant(module_ns,"CV_BadDataPtr",SWIG_From_int((int)(-12))); + SWIG_Octave_SetConstant(module_ns,"CV_BadStep",SWIG_From_int((int)(-13))); + SWIG_Octave_SetConstant(module_ns,"CV_BadModelOrChSeq",SWIG_From_int((int)(-14))); + SWIG_Octave_SetConstant(module_ns,"CV_BadNumChannels",SWIG_From_int((int)(-15))); + SWIG_Octave_SetConstant(module_ns,"CV_BadNumChannel1U",SWIG_From_int((int)(-16))); + SWIG_Octave_SetConstant(module_ns,"CV_BadDepth",SWIG_From_int((int)(-17))); + SWIG_Octave_SetConstant(module_ns,"CV_BadAlphaChannel",SWIG_From_int((int)(-18))); + SWIG_Octave_SetConstant(module_ns,"CV_BadOrder",SWIG_From_int((int)(-19))); + SWIG_Octave_SetConstant(module_ns,"CV_BadOrigin",SWIG_From_int((int)(-20))); + SWIG_Octave_SetConstant(module_ns,"CV_BadAlign",SWIG_From_int((int)(-21))); + SWIG_Octave_SetConstant(module_ns,"CV_BadCallBack",SWIG_From_int((int)(-22))); + SWIG_Octave_SetConstant(module_ns,"CV_BadTileSize",SWIG_From_int((int)(-23))); + SWIG_Octave_SetConstant(module_ns,"CV_BadCOI",SWIG_From_int((int)(-24))); + SWIG_Octave_SetConstant(module_ns,"CV_BadROISize",SWIG_From_int((int)(-25))); + SWIG_Octave_SetConstant(module_ns,"CV_MaskIsTiled",SWIG_From_int((int)(-26))); + SWIG_Octave_SetConstant(module_ns,"CV_StsNullPtr",SWIG_From_int((int)(-27))); + SWIG_Octave_SetConstant(module_ns,"CV_StsVecLengthErr",SWIG_From_int((int)(-28))); + SWIG_Octave_SetConstant(module_ns,"CV_StsFilterStructContentErr",SWIG_From_int((int)(-29))); + SWIG_Octave_SetConstant(module_ns,"CV_StsKernelStructContentErr",SWIG_From_int((int)(-30))); + SWIG_Octave_SetConstant(module_ns,"CV_StsFilterOffsetErr",SWIG_From_int((int)(-31))); + SWIG_Octave_SetConstant(module_ns,"CV_StsBadSize",SWIG_From_int((int)(-201))); + SWIG_Octave_SetConstant(module_ns,"CV_StsDivByZero",SWIG_From_int((int)(-202))); + SWIG_Octave_SetConstant(module_ns,"CV_StsInplaceNotSupported",SWIG_From_int((int)(-203))); + SWIG_Octave_SetConstant(module_ns,"CV_StsObjectNotFound",SWIG_From_int((int)(-204))); + SWIG_Octave_SetConstant(module_ns,"CV_StsUnmatchedFormats",SWIG_From_int((int)(-205))); + SWIG_Octave_SetConstant(module_ns,"CV_StsBadFlag",SWIG_From_int((int)(-206))); + SWIG_Octave_SetConstant(module_ns,"CV_StsBadPoint",SWIG_From_int((int)(-207))); + SWIG_Octave_SetConstant(module_ns,"CV_StsBadMask",SWIG_From_int((int)(-208))); + SWIG_Octave_SetConstant(module_ns,"CV_StsUnmatchedSizes",SWIG_From_int((int)(-209))); + SWIG_Octave_SetConstant(module_ns,"CV_StsUnsupportedFormat",SWIG_From_int((int)(-210))); + SWIG_Octave_SetConstant(module_ns,"CV_StsOutOfRange",SWIG_From_int((int)(-211))); + SWIG_Octave_SetConstant(module_ns,"CV_StsParseError",SWIG_From_int((int)(-212))); + SWIG_Octave_SetConstant(module_ns,"CV_StsNotImplemented",SWIG_From_int((int)(-213))); + SWIG_Octave_SetConstant(module_ns,"CV_StsBadMemBlock",SWIG_From_int((int)(-214))); + SWIG_Octave_SetConstant(module_ns,"CV_StsAssert",SWIG_From_int((int)(-215))); + SWIG_Octave_SetConstant(module_ns,"CV_BLUR_NO_SCALE",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_BLUR",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_GAUSSIAN",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_MEDIAN",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_BILATERAL",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_INPAINT_NS",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_INPAINT_TELEA",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_SCHARR",SWIG_From_int((int)(-1))); + SWIG_Octave_SetConstant(module_ns,"CV_MAX_SOBEL_KSIZE",SWIG_From_int((int)(7))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR2BGRA",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_RGB2RGBA",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_BGRA2BGR",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_RGBA2RGB",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR2RGBA",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_RGB2BGRA",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_RGBA2BGR",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_BGRA2RGB",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR2RGB",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_RGB2BGR",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_BGRA2RGBA",SWIG_From_int((int)(5))); + SWIG_Octave_SetConstant(module_ns,"CV_RGBA2BGRA",SWIG_From_int((int)(5))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR2GRAY",SWIG_From_int((int)(6))); + SWIG_Octave_SetConstant(module_ns,"CV_RGB2GRAY",SWIG_From_int((int)(7))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAY2BGR",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAY2RGB",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAY2BGRA",SWIG_From_int((int)(9))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAY2RGBA",SWIG_From_int((int)(9))); + SWIG_Octave_SetConstant(module_ns,"CV_BGRA2GRAY",SWIG_From_int((int)(10))); + SWIG_Octave_SetConstant(module_ns,"CV_RGBA2GRAY",SWIG_From_int((int)(11))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR2BGR565",SWIG_From_int((int)(12))); + SWIG_Octave_SetConstant(module_ns,"CV_RGB2BGR565",SWIG_From_int((int)(13))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR5652BGR",SWIG_From_int((int)(14))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR5652RGB",SWIG_From_int((int)(15))); + SWIG_Octave_SetConstant(module_ns,"CV_BGRA2BGR565",SWIG_From_int((int)(16))); + SWIG_Octave_SetConstant(module_ns,"CV_RGBA2BGR565",SWIG_From_int((int)(17))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR5652BGRA",SWIG_From_int((int)(18))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR5652RGBA",SWIG_From_int((int)(19))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAY2BGR565",SWIG_From_int((int)(20))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR5652GRAY",SWIG_From_int((int)(21))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR2BGR555",SWIG_From_int((int)(22))); + SWIG_Octave_SetConstant(module_ns,"CV_RGB2BGR555",SWIG_From_int((int)(23))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR5552BGR",SWIG_From_int((int)(24))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR5552RGB",SWIG_From_int((int)(25))); + SWIG_Octave_SetConstant(module_ns,"CV_BGRA2BGR555",SWIG_From_int((int)(26))); + SWIG_Octave_SetConstant(module_ns,"CV_RGBA2BGR555",SWIG_From_int((int)(27))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR5552BGRA",SWIG_From_int((int)(28))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR5552RGBA",SWIG_From_int((int)(29))); + SWIG_Octave_SetConstant(module_ns,"CV_GRAY2BGR555",SWIG_From_int((int)(30))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR5552GRAY",SWIG_From_int((int)(31))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR2XYZ",SWIG_From_int((int)(32))); + SWIG_Octave_SetConstant(module_ns,"CV_RGB2XYZ",SWIG_From_int((int)(33))); + SWIG_Octave_SetConstant(module_ns,"CV_XYZ2BGR",SWIG_From_int((int)(34))); + SWIG_Octave_SetConstant(module_ns,"CV_XYZ2RGB",SWIG_From_int((int)(35))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR2YCrCb",SWIG_From_int((int)(36))); + SWIG_Octave_SetConstant(module_ns,"CV_RGB2YCrCb",SWIG_From_int((int)(37))); + SWIG_Octave_SetConstant(module_ns,"CV_YCrCb2BGR",SWIG_From_int((int)(38))); + SWIG_Octave_SetConstant(module_ns,"CV_YCrCb2RGB",SWIG_From_int((int)(39))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR2HSV",SWIG_From_int((int)(40))); + SWIG_Octave_SetConstant(module_ns,"CV_RGB2HSV",SWIG_From_int((int)(41))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR2Lab",SWIG_From_int((int)(44))); + SWIG_Octave_SetConstant(module_ns,"CV_RGB2Lab",SWIG_From_int((int)(45))); + SWIG_Octave_SetConstant(module_ns,"CV_BayerBG2BGR",SWIG_From_int((int)(46))); + SWIG_Octave_SetConstant(module_ns,"CV_BayerGB2BGR",SWIG_From_int((int)(47))); + SWIG_Octave_SetConstant(module_ns,"CV_BayerRG2BGR",SWIG_From_int((int)(48))); + SWIG_Octave_SetConstant(module_ns,"CV_BayerGR2BGR",SWIG_From_int((int)(49))); + SWIG_Octave_SetConstant(module_ns,"CV_BayerBG2RGB",SWIG_From_int((int)(48))); + SWIG_Octave_SetConstant(module_ns,"CV_BayerGB2RGB",SWIG_From_int((int)(49))); + SWIG_Octave_SetConstant(module_ns,"CV_BayerRG2RGB",SWIG_From_int((int)(46))); + SWIG_Octave_SetConstant(module_ns,"CV_BayerGR2RGB",SWIG_From_int((int)(47))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR2Luv",SWIG_From_int((int)(50))); + SWIG_Octave_SetConstant(module_ns,"CV_RGB2Luv",SWIG_From_int((int)(51))); + SWIG_Octave_SetConstant(module_ns,"CV_BGR2HLS",SWIG_From_int((int)(52))); + SWIG_Octave_SetConstant(module_ns,"CV_RGB2HLS",SWIG_From_int((int)(53))); + SWIG_Octave_SetConstant(module_ns,"CV_HSV2BGR",SWIG_From_int((int)(54))); + SWIG_Octave_SetConstant(module_ns,"CV_HSV2RGB",SWIG_From_int((int)(55))); + SWIG_Octave_SetConstant(module_ns,"CV_Lab2BGR",SWIG_From_int((int)(56))); + SWIG_Octave_SetConstant(module_ns,"CV_Lab2RGB",SWIG_From_int((int)(57))); + SWIG_Octave_SetConstant(module_ns,"CV_Luv2BGR",SWIG_From_int((int)(58))); + SWIG_Octave_SetConstant(module_ns,"CV_Luv2RGB",SWIG_From_int((int)(59))); + SWIG_Octave_SetConstant(module_ns,"CV_HLS2BGR",SWIG_From_int((int)(60))); + SWIG_Octave_SetConstant(module_ns,"CV_HLS2RGB",SWIG_From_int((int)(61))); + SWIG_Octave_SetConstant(module_ns,"CV_COLORCVT_MAX",SWIG_From_int((int)(100))); + SWIG_Octave_SetConstant(module_ns,"CV_INTER_NN",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_INTER_LINEAR",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_INTER_CUBIC",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_INTER_AREA",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_WARP_FILL_OUTLIERS",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_WARP_INVERSE_MAP",SWIG_From_int((int)(16))); + SWIG_Octave_SetConstant(module_ns,"CV_SHAPE_RECT",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_SHAPE_CROSS",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_SHAPE_ELLIPSE",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_SHAPE_CUSTOM",SWIG_From_int((int)(100))); + SWIG_Octave_SetConstant(module_ns,"CV_MOP_OPEN",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_MOP_CLOSE",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_MOP_GRADIENT",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_MOP_TOPHAT",SWIG_From_int((int)(5))); + SWIG_Octave_SetConstant(module_ns,"CV_MOP_BLACKHAT",SWIG_From_int((int)(6))); + SWIG_Octave_SetConstant(module_ns,"CV_TM_SQDIFF",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_TM_SQDIFF_NORMED",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_TM_CCORR",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_TM_CCORR_NORMED",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_TM_CCOEFF",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_TM_CCOEFF_NORMED",SWIG_From_int((int)(5))); + SWIG_Octave_SetConstant(module_ns,"CV_LKFLOW_PYR_A_READY",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_LKFLOW_PYR_B_READY",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_LKFLOW_INITIAL_GUESSES",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_LKFLOW_GET_MIN_EIGENVALS",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_POLY_APPROX_DP",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_DOMINANT_IPAN",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_CONTOURS_MATCH_I1",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_CONTOURS_MATCH_I2",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_CONTOURS_MATCH_I3",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_CONTOUR_TREES_MATCH_I1",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_CLOCKWISE",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_COUNTER_CLOCKWISE",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_COMP_CORREL",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_COMP_CHISQR",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_COMP_INTERSECT",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_COMP_BHATTACHARYYA",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_VALUE",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_ARRAY",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_DIST_MASK_3",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_DIST_MASK_5",SWIG_From_int((int)(5))); + SWIG_Octave_SetConstant(module_ns,"CV_DIST_MASK_PRECISE",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_THRESH_BINARY",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_THRESH_BINARY_INV",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_THRESH_TRUNC",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_THRESH_TOZERO",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_THRESH_TOZERO_INV",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_THRESH_MASK",SWIG_From_int((int)(7))); + SWIG_Octave_SetConstant(module_ns,"CV_THRESH_OTSU",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_ADAPTIVE_THRESH_MEAN_C",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_ADAPTIVE_THRESH_GAUSSIAN_C",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_FLOODFILL_FIXED_RANGE",SWIG_From_int((int)((1 << 16)))); + SWIG_Octave_SetConstant(module_ns,"CV_FLOODFILL_MASK_ONLY",SWIG_From_int((int)((1 << 17)))); + SWIG_Octave_SetConstant(module_ns,"CV_CANNY_L2_GRADIENT",SWIG_From_int((int)((1 << 31)))); + SWIG_Octave_SetConstant(module_ns,"CV_HOUGH_STANDARD",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_HOUGH_PROBABILISTIC",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_HOUGH_MULTI_SCALE",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_HOUGH_GRADIENT",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_HAAR_DO_CANNY_PRUNING",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_HAAR_SCALE_IMAGE",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_HAAR_FIND_BIGGEST_OBJECT",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_HAAR_DO_ROUGH_SEARCH",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_LMEDS",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_RANSAC",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_CB_ADAPTIVE_THRESH",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_CB_NORMALIZE_IMAGE",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_CB_FILTER_QUADS",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_USE_INTRINSIC_GUESS",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_FIX_ASPECT_RATIO",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_FIX_PRINCIPAL_POINT",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_ZERO_TANGENT_DIST",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_FIX_FOCAL_LENGTH",SWIG_From_int((int)(16))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_FIX_K1",SWIG_From_int((int)(32))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_FIX_K2",SWIG_From_int((int)(64))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_FIX_K3",SWIG_From_int((int)(128))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_FIX_INTRINSIC",SWIG_From_int((int)(256))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_SAME_FOCAL_LENGTH",SWIG_From_int((int)(512))); + SWIG_Octave_SetConstant(module_ns,"CV_CALIB_ZERO_DISPARITY",SWIG_From_int((int)(1024))); + SWIG_Octave_SetConstant(module_ns,"CV_FM_7POINT",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_FM_8POINT",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_FM_LMEDS_ONLY",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_FM_RANSAC_ONLY",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_FM_LMEDS",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_FM_RANSAC",SWIG_From_int((int)(8))); + SWIG_Octave_SetConstant(module_ns,"CV_STEREO_BM_NORMALIZED_RESPONSE",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_STEREO_BM_BASIC",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_STEREO_BM_FISH_EYE",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_STEREO_BM_NARROW",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_RETR_EXTERNAL",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_RETR_LIST",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_RETR_CCOMP",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_RETR_TREE",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_CHAIN_CODE",SWIG_From_int((int)(0))); + SWIG_Octave_SetConstant(module_ns,"CV_CHAIN_APPROX_NONE",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_CHAIN_APPROX_SIMPLE",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_CHAIN_APPROX_TC89_L1",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_CHAIN_APPROX_TC89_KCOS",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_LINK_RUNS",SWIG_From_int((int)(5))); + SWIG_Octave_SetConstant(module_ns,"CV_SUBDIV2D_VIRTUAL_POINT_FLAG",SWIG_From_int((int)((1 << 30)))); + SWIG_Octave_SetConstant(module_ns,"CV_DIST_USER",SWIG_From_int((int)(-1))); + SWIG_Octave_SetConstant(module_ns,"CV_DIST_L1",SWIG_From_int((int)(1))); + SWIG_Octave_SetConstant(module_ns,"CV_DIST_L2",SWIG_From_int((int)(2))); + SWIG_Octave_SetConstant(module_ns,"CV_DIST_C",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_DIST_L12",SWIG_From_int((int)(4))); + SWIG_Octave_SetConstant(module_ns,"CV_DIST_FAIR",SWIG_From_int((int)(5))); + SWIG_Octave_SetConstant(module_ns,"CV_DIST_WELSCH",SWIG_From_int((int)(6))); + SWIG_Octave_SetConstant(module_ns,"CV_DIST_HUBER",SWIG_From_int((int)(7))); + SWIG_Octave_SetConstant(module_ns,"CV_HAAR_MAGIC_VAL",SWIG_From_int((int)(0x42500000))); + SWIG_Octave_SetConstant(module_ns,"CV_TYPE_NAME_HAAR",SWIG_FromCharPtr("opencv-haar-classifier")); + SWIG_Octave_SetConstant(module_ns,"CV_HAAR_FEATURE_MAX",SWIG_From_int((int)(3))); + SWIG_Octave_SetConstant(module_ns,"CV_PTLOC_ERROR",SWIG_From_int((int)(CV_PTLOC_ERROR))); + SWIG_Octave_SetConstant(module_ns,"CV_PTLOC_OUTSIDE_RECT",SWIG_From_int((int)(CV_PTLOC_OUTSIDE_RECT))); + SWIG_Octave_SetConstant(module_ns,"CV_PTLOC_INSIDE",SWIG_From_int((int)(CV_PTLOC_INSIDE))); + SWIG_Octave_SetConstant(module_ns,"CV_PTLOC_VERTEX",SWIG_From_int((int)(CV_PTLOC_VERTEX))); + SWIG_Octave_SetConstant(module_ns,"CV_PTLOC_ON_EDGE",SWIG_From_int((int)(CV_PTLOC_ON_EDGE))); + SWIG_Octave_SetConstant(module_ns,"CV_NEXT_AROUND_ORG",SWIG_From_int((int)(CV_NEXT_AROUND_ORG))); + SWIG_Octave_SetConstant(module_ns,"CV_NEXT_AROUND_DST",SWIG_From_int((int)(CV_NEXT_AROUND_DST))); + SWIG_Octave_SetConstant(module_ns,"CV_PREV_AROUND_ORG",SWIG_From_int((int)(CV_PREV_AROUND_ORG))); + SWIG_Octave_SetConstant(module_ns,"CV_PREV_AROUND_DST",SWIG_From_int((int)(CV_PREV_AROUND_DST))); + SWIG_Octave_SetConstant(module_ns,"CV_NEXT_AROUND_LEFT",SWIG_From_int((int)(CV_NEXT_AROUND_LEFT))); + SWIG_Octave_SetConstant(module_ns,"CV_NEXT_AROUND_RIGHT",SWIG_From_int((int)(CV_NEXT_AROUND_RIGHT))); + SWIG_Octave_SetConstant(module_ns,"CV_PREV_AROUND_LEFT",SWIG_From_int((int)(CV_PREV_AROUND_LEFT))); + SWIG_Octave_SetConstant(module_ns,"CV_PREV_AROUND_RIGHT",SWIG_From_int((int)(CV_PREV_AROUND_RIGHT))); + SWIG_Octave_SetConstant(module_ns,"CV_GAUSSIAN_5x5",SWIG_From_int((int)(CV_GAUSSIAN_5x5))); + + cvRedirectError(function_ptr_generator(), void_ptr_generator(), void_ptrptr_generator()); + +} +