opencv/interfaces/swig/python/cv.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_cv', [dirname(__file__)])
        except ImportError:
            import _cv
            return _cv
        if fp is not None:
            try:
                _mod = imp.load_module('_cv', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _cv = swig_import_helper()
    del swig_import_helper
else:
    import _cv
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


class CvRNG_Wrapper(_object):
    """Proxy of C++ CvRNG_Wrapper class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvRNG_Wrapper, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvRNG_Wrapper, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, CvRNG val) -> CvRNG_Wrapper"""
        this = _cv.new_CvRNG_Wrapper(*args)
        try: self.this.append(this)
        except: self.this = this
    def ptr(self):
        """ptr(self) -> CvRNG"""
        return _cv.CvRNG_Wrapper_ptr(self)

    def ref(self):
        """ref(self) -> CvRNG"""
        return _cv.CvRNG_Wrapper_ref(self)

    def __eq__(self, *args):
        """__eq__(self, CvRNG_Wrapper x) -> bool"""
        return _cv.CvRNG_Wrapper___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, CvRNG_Wrapper x) -> bool"""
        return _cv.CvRNG_Wrapper___ne__(self, *args)

    __swig_destroy__ = _cv.delete_CvRNG_Wrapper
    __del__ = lambda self : None;
CvRNG_Wrapper_swigregister = _cv.CvRNG_Wrapper_swigregister
CvRNG_Wrapper_swigregister(CvRNG_Wrapper)

class CvSubdiv2DEdge_Wrapper(_object):
    """Proxy of C++ CvSubdiv2DEdge_Wrapper class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSubdiv2DEdge_Wrapper, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSubdiv2DEdge_Wrapper, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, CvSubdiv2DEdge val) -> CvSubdiv2DEdge_Wrapper"""
        this = _cv.new_CvSubdiv2DEdge_Wrapper(*args)
        try: self.this.append(this)
        except: self.this = this
    def ptr(self):
        """ptr(self) -> CvSubdiv2DEdge"""
        return _cv.CvSubdiv2DEdge_Wrapper_ptr(self)

    def ref(self):
        """ref(self) -> CvSubdiv2DEdge"""
        return _cv.CvSubdiv2DEdge_Wrapper_ref(self)

    def __eq__(self, *args):
        """__eq__(self, CvSubdiv2DEdge_Wrapper x) -> bool"""
        return _cv.CvSubdiv2DEdge_Wrapper___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, CvSubdiv2DEdge_Wrapper x) -> bool"""
        return _cv.CvSubdiv2DEdge_Wrapper___ne__(self, *args)

    __swig_destroy__ = _cv.delete_CvSubdiv2DEdge_Wrapper
    __del__ = lambda self : None;
CvSubdiv2DEdge_Wrapper_swigregister = _cv.CvSubdiv2DEdge_Wrapper_swigregister
CvSubdiv2DEdge_Wrapper_swigregister(CvSubdiv2DEdge_Wrapper)

class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _cv.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(self) -> PyObject"""
        return _cv.SwigPyIterator_value(self)

    def incr(self, n = 1):
        """
        incr(self, size_t n = 1) -> SwigPyIterator
        incr(self) -> SwigPyIterator
        """
        return _cv.SwigPyIterator_incr(self, n)

    def decr(self, n = 1):
        """
        decr(self, size_t n = 1) -> SwigPyIterator
        decr(self) -> SwigPyIterator
        """
        return _cv.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(self, SwigPyIterator x) -> ptrdiff_t"""
        return _cv.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(self, SwigPyIterator x) -> bool"""
        return _cv.SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(self) -> SwigPyIterator"""
        return _cv.SwigPyIterator_copy(self)

    def next(self):
        """next(self) -> PyObject"""
        return _cv.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(self) -> PyObject"""
        return _cv.SwigPyIterator___next__(self)

    def previous(self):
        """previous(self) -> PyObject"""
        return _cv.SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(self, ptrdiff_t n) -> SwigPyIterator"""
        return _cv.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SwigPyIterator x) -> bool"""
        return _cv.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SwigPyIterator x) -> bool"""
        return _cv.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _cv.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _cv.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(self, ptrdiff_t n) -> SwigPyIterator"""
        return _cv.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(self, ptrdiff_t n) -> SwigPyIterator
        __sub__(self, SwigPyIterator x) -> ptrdiff_t
        """
        return _cv.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator_swigregister = _cv.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class FloatVector(_object):
    """Proxy of C++ std::vector<(float)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FloatVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _cv.FloatVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _cv.FloatVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _cv.FloatVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _cv.FloatVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _cv.FloatVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> FloatVector"""
        return _cv.FloatVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, FloatVector v)"""
        return _cv.FloatVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _cv.FloatVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _cv.FloatVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> FloatVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _cv.FloatVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, FloatVector v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _cv.FloatVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _cv.FloatVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _cv.FloatVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _cv.FloatVector_size(self)

    def clear(self):
        """clear(self)"""
        return _cv.FloatVector_clear(self)

    def swap(self, *args):
        """swap(self, FloatVector v)"""
        return _cv.FloatVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _cv.FloatVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _cv.FloatVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _cv.FloatVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _cv.FloatVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _cv.FloatVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _cv.FloatVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _cv.FloatVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> FloatVector
        __init__(self, FloatVector arg0) -> FloatVector
        __init__(self, size_type size) -> FloatVector
        __init__(self, size_type size, value_type value) -> FloatVector
        """
        this = _cv.new_FloatVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _cv.FloatVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _cv.FloatVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _cv.FloatVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _cv.FloatVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _cv.FloatVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _cv.FloatVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _cv.FloatVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _cv.FloatVector_capacity(self)

    __swig_destroy__ = _cv.delete_FloatVector
    __del__ = lambda self : None;
FloatVector_swigregister = _cv.FloatVector_swigregister
FloatVector_swigregister(FloatVector)

class CvPointVector(_object):
    """Proxy of C++ std::vector<(CvPoint)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvPointVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvPointVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _cv.CvPointVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _cv.CvPointVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _cv.CvPointVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _cv.CvPointVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _cv.CvPointVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> CvPointVector"""
        return _cv.CvPointVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, CvPointVector v)"""
        return _cv.CvPointVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _cv.CvPointVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _cv.CvPointVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> CvPointVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _cv.CvPointVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, CvPointVector v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _cv.CvPointVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _cv.CvPointVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _cv.CvPointVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _cv.CvPointVector_size(self)

    def clear(self):
        """clear(self)"""
        return _cv.CvPointVector_clear(self)

    def swap(self, *args):
        """swap(self, CvPointVector v)"""
        return _cv.CvPointVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _cv.CvPointVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _cv.CvPointVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _cv.CvPointVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _cv.CvPointVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _cv.CvPointVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _cv.CvPointVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _cv.CvPointVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> CvPointVector
        __init__(self, CvPointVector arg0) -> CvPointVector
        __init__(self, size_type size) -> CvPointVector
        __init__(self, size_type size, value_type value) -> CvPointVector
        """
        this = _cv.new_CvPointVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _cv.CvPointVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _cv.CvPointVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _cv.CvPointVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _cv.CvPointVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _cv.CvPointVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _cv.CvPointVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _cv.CvPointVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _cv.CvPointVector_capacity(self)

    __swig_destroy__ = _cv.delete_CvPointVector
    __del__ = lambda self : None;
CvPointVector_swigregister = _cv.CvPointVector_swigregister
CvPointVector_swigregister(CvPointVector)


def cvSegmentMotion(*args):
  """
    cvSegmentMotion(CvArr mhi, CvArr seg_mask, CvMemStorage storage, double timestamp, 
        double seg_thresh) -> CvSeq_CvConnectedComp
    """
  return _cv.cvSegmentMotion(*args)
def cvHoughCircles(*args):
	seq = cvHoughCirclesUntyped( *args )
	return CvSeq_float_3.cast(seq)

def cvPyrSegmentation(*args):
	seq = cvPyrSegmentationUntyped( *args )
	return CvSeq_CvConnectedComp.cast(seq)

def cvApproxChains(*args):
	seq = cvApproxChainsUntyped( *args )
	return CvSeq_CvPoint.cast(seq)

def cvContourFromContourTree(*args):
	seq = cvContourFromContourTreeUntyped( *args )
	return CvSeq_CvPoint.cast(seq)

def cvConvexityDefects(*args):
	seq = cvConvexityDefectsUntyped( *args )
	return CvSeq_CvConvexityDefect.cast(seq)

def cvFindContours( *args ):
	count, seq = cvFindContoursUntyped( *args )
	return count, CvSeq_CvPoint.cast(seq)

def cvHoughLines2( *args ):
	seq = cvHoughLinesUntyped( *args )
	type = CV_SEQ_ELTYPE(seq) 
	if type == CV_32SC4:
		return CvSeq_CvPoint_2.cast(seq)
	return CvSeq_float_2.cast(seq)

cvReleaseImage = _cv.delete_CvMat

cvReleaseMat = _cv.delete_CvMat

cvReleaseStructuringElement = _cv.delete_IplConvKernel

cvReleaseConDensation = _cv.delete_CvConDensation

cvReleaseKalman = _cv.delete_CvKalman

cvReleaseHist = _cv.delete_CvHistogram

cvReleaseHaarClassifierCascade = _cv.delete_CvHaarClassifierCascade

cvReleaseImageHeader = _cv.delete_CvMat

cvReleaseMatND = _cv.delete_CvMatND

cvReleaseSparseMat = _cv.delete_CvSparseMat

cvReleaseMemStorage = _cv.delete_CvMemStorage

cvReleaseGraphScanner = _cv.delete_CvGraphScanner


def cvFree(*args):
  """cvFree(void ptr)"""
  return _cv.cvFree(*args)

def CV_READ_CHAIN_POINT(*args):
  """CV_READ_CHAIN_POINT(CvPoint _pt, CvChainPtReader reader)"""
  return _cv.CV_READ_CHAIN_POINT(*args)

def CV_MAT_ELEM_PTR(*args):
  """CV_MAT_ELEM_PTR(CvMat mat, int row, int col) -> void"""
  return _cv.CV_MAT_ELEM_PTR(*args)

def CV_MAT_ELEM_PTR_FAST(*args):
  """CV_MAT_ELEM_PTR_FAST(CvMat mat, int row, int col, int pix_size) -> void"""
  return _cv.CV_MAT_ELEM_PTR_FAST(*args)

def CV_NODE_VAL(*args):
  """CV_NODE_VAL(CvSparseMat mat, CvSparseNode node) -> void"""
  return _cv.CV_NODE_VAL(*args)

def CV_NODE_IDX(*args):
  """CV_NODE_IDX(CvSparseMat mat, CvSparseNode node) -> int"""
  return _cv.CV_NODE_IDX(*args)

def CV_SUBDIV2D_NEXT_EDGE(*args):
  """CV_SUBDIV2D_NEXT_EDGE(CvSubdiv2DEdge edge) -> CvQuadEdge2D"""
  return _cv.CV_SUBDIV2D_NEXT_EDGE(*args)

def CV_SWAP(*args):
  """CV_SWAP(int a, int b, int t)"""
  return _cv.CV_SWAP(*args)

def CV_IMIN(*args):
  """CV_IMIN(int a, int b) -> int"""
  return _cv.CV_IMIN(*args)

def CV_IMAX(*args):
  """CV_IMAX(int a, int b) -> int"""
  return _cv.CV_IMAX(*args)

def CV_IABS(*args):
  """CV_IABS(int a) -> int"""
  return _cv.CV_IABS(*args)

def CV_CMP(*args):
  """CV_CMP(int a, int b)"""
  return _cv.CV_CMP(*args)

def CV_SIGN(*args):
  """CV_SIGN(int a)"""
  return _cv.CV_SIGN(*args)

def cvInvSqrt(*args):
  """cvInvSqrt(double value)"""
  return _cv.cvInvSqrt(*args)

def cvSqrt(*args):
  """cvSqrt(double value)"""
  return _cv.cvSqrt(*args)

def CV_IS_IMAGE_HDR(*args):
  """CV_IS_IMAGE_HDR(CvArr img) -> int"""
  return _cv.CV_IS_IMAGE_HDR(*args)

def CV_IS_IMAGE(*args):
  """CV_IS_IMAGE(CvArr img) -> int"""
  return _cv.CV_IS_IMAGE(*args)

def CV_MAT_DEPTH(*args):
  """CV_MAT_DEPTH(int flags) -> int"""
  return _cv.CV_MAT_DEPTH(*args)

def CV_MAKETYPE(*args):
  """CV_MAKETYPE(int depth, int cn) -> int"""
  return _cv.CV_MAKETYPE(*args)

def CV_8UC(*args):
  """CV_8UC(int n) -> int"""
  return _cv.CV_8UC(*args)

def CV_8SC(*args):
  """CV_8SC(int n) -> int"""
  return _cv.CV_8SC(*args)

def CV_16UC(*args):
  """CV_16UC(int n) -> int"""
  return _cv.CV_16UC(*args)

def CV_16SC(*args):
  """CV_16SC(int n) -> int"""
  return _cv.CV_16SC(*args)

def CV_32SC(*args):
  """CV_32SC(int n) -> int"""
  return _cv.CV_32SC(*args)

def CV_32FC(*args):
  """CV_32FC(int n) -> int"""
  return _cv.CV_32FC(*args)

def CV_64FC(*args):
  """CV_64FC(int n) -> int"""
  return _cv.CV_64FC(*args)

def CV_MAT_CN(*args):
  """CV_MAT_CN(int flags) -> int"""
  return _cv.CV_MAT_CN(*args)

def CV_MAT_TYPE(*args):
  """CV_MAT_TYPE(int flags) -> int"""
  return _cv.CV_MAT_TYPE(*args)

def CV_IS_MAT_CONT(*args):
  """CV_IS_MAT_CONT(int flags) -> int"""
  return _cv.CV_IS_MAT_CONT(*args)

def CV_IS_TEMP_MAT(*args):
  """CV_IS_TEMP_MAT(int flags) -> int"""
  return _cv.CV_IS_TEMP_MAT(*args)

def CV_IS_MAT_HDR(*args):
  """CV_IS_MAT_HDR(CvMat mat) -> int"""
  return _cv.CV_IS_MAT_HDR(*args)

def CV_IS_MAT(*args):
  """CV_IS_MAT(CvMat mat) -> int"""
  return _cv.CV_IS_MAT(*args)

def CV_IS_MASK_ARR(*args):
  """CV_IS_MASK_ARR(CvMat mat) -> int"""
  return _cv.CV_IS_MASK_ARR(*args)

def CV_ARE_TYPES_EQ(*args):
  """CV_ARE_TYPES_EQ(CvMat mat1, CvMat mat2) -> int"""
  return _cv.CV_ARE_TYPES_EQ(*args)

def CV_ARE_CNS_EQ(*args):
  """CV_ARE_CNS_EQ(CvMat mat1, CvMat mat2) -> int"""
  return _cv.CV_ARE_CNS_EQ(*args)

def CV_ARE_DEPTHS_EQ(*args):
  """CV_ARE_DEPTHS_EQ(CvMat mat1, CvMat mat2) -> int"""
  return _cv.CV_ARE_DEPTHS_EQ(*args)

def CV_ARE_SIZES_EQ(*args):
  """CV_ARE_SIZES_EQ(CvMat mat1, CvMat mat2) -> int"""
  return _cv.CV_ARE_SIZES_EQ(*args)

def CV_IS_MAT_CONST(*args):
  """CV_IS_MAT_CONST(CvMat mat) -> int"""
  return _cv.CV_IS_MAT_CONST(*args)

def CV_ELEM_SIZE1(*args):
  """CV_ELEM_SIZE1(int type) -> int"""
  return _cv.CV_ELEM_SIZE1(*args)

def CV_ELEM_SIZE(*args):
  """CV_ELEM_SIZE(int type) -> int"""
  return _cv.CV_ELEM_SIZE(*args)

def CV_IS_MATND_HDR(*args):
  """CV_IS_MATND_HDR(CvMat mat) -> int"""
  return _cv.CV_IS_MATND_HDR(*args)

def CV_IS_MATND(*args):
  """CV_IS_MATND(CvMat mat) -> int"""
  return _cv.CV_IS_MATND(*args)

def CV_IS_SPARSE_MAT_HDR(*args):
  """CV_IS_SPARSE_MAT_HDR(CvMat mat) -> int"""
  return _cv.CV_IS_SPARSE_MAT_HDR(*args)

def CV_IS_SPARSE_MAT(*args):
  """CV_IS_SPARSE_MAT(CvMat mat) -> int"""
  return _cv.CV_IS_SPARSE_MAT(*args)

def CV_IS_HIST(*args):
  """CV_IS_HIST(CvHistogram hist) -> int"""
  return _cv.CV_IS_HIST(*args)

def CV_IS_UNIFORM_HIST(*args):
  """CV_IS_UNIFORM_HIST(CvHistogram hist) -> int"""
  return _cv.CV_IS_UNIFORM_HIST(*args)

def CV_IS_SPARSE_HIST(*args):
  """CV_IS_SPARSE_HIST(CvHistogram hist) -> int"""
  return _cv.CV_IS_SPARSE_HIST(*args)

def CV_HIST_HAS_RANGES(*args):
  """CV_HIST_HAS_RANGES(CvHistogram hist) -> int"""
  return _cv.CV_HIST_HAS_RANGES(*args)

def CV_IS_STORAGE(*args):
  """CV_IS_STORAGE(CvMemStorage storage) -> int"""
  return _cv.CV_IS_STORAGE(*args)

def CV_IS_SET_ELEM(*args):
  """CV_IS_SET_ELEM(void ptr) -> int"""
  return _cv.CV_IS_SET_ELEM(*args)

def CV_IS_SEQ(*args):
  """CV_IS_SEQ(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ(*args)

def CV_IS_SET(*args):
  """CV_IS_SET(CvSet set) -> int"""
  return _cv.CV_IS_SET(*args)

def CV_SEQ_ELTYPE(*args):
  """CV_SEQ_ELTYPE(CvSeq seq) -> int"""
  return _cv.CV_SEQ_ELTYPE(*args)

def CV_SEQ_KIND(*args):
  """CV_SEQ_KIND(CvSeq seq) -> int"""
  return _cv.CV_SEQ_KIND(*args)

def CV_IS_SEQ_INDEX(*args):
  """CV_IS_SEQ_INDEX(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_INDEX(*args)

def CV_IS_SEQ_CURVE(*args):
  """CV_IS_SEQ_CURVE(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_CURVE(*args)

def CV_IS_SEQ_CLOSED(*args):
  """CV_IS_SEQ_CLOSED(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_CLOSED(*args)

def CV_IS_SEQ_CONVEX(*args):
  """CV_IS_SEQ_CONVEX(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_CONVEX(*args)

def CV_IS_SEQ_HOLE(*args):
  """CV_IS_SEQ_HOLE(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_HOLE(*args)

def CV_IS_SEQ_SIMPLE(*args):
  """CV_IS_SEQ_SIMPLE(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_SIMPLE(*args)

def CV_IS_SEQ_POINT_SET(*args):
  """CV_IS_SEQ_POINT_SET(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_POINT_SET(*args)

def CV_IS_SEQ_POINT_SUBSET(*args):
  """CV_IS_SEQ_POINT_SUBSET(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_POINT_SUBSET(*args)

def CV_IS_SEQ_POLYLINE(*args):
  """CV_IS_SEQ_POLYLINE(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_POLYLINE(*args)

def CV_IS_SEQ_POLYGON(*args):
  """CV_IS_SEQ_POLYGON(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_POLYGON(*args)

def CV_IS_SEQ_CHAIN(*args):
  """CV_IS_SEQ_CHAIN(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_CHAIN(*args)

def CV_IS_SEQ_CONTOUR(*args):
  """CV_IS_SEQ_CONTOUR(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_CONTOUR(*args)

def CV_IS_SEQ_CHAIN_CONTOUR(*args):
  """CV_IS_SEQ_CHAIN_CONTOUR(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_CHAIN_CONTOUR(*args)

def CV_IS_SEQ_POLYGON_TREE(*args):
  """CV_IS_SEQ_POLYGON_TREE(CvSeq seq) -> int"""
  return _cv.CV_IS_SEQ_POLYGON_TREE(*args)

def CV_IS_GRAPH(*args):
  """CV_IS_GRAPH(CvSeq seq) -> int"""
  return _cv.CV_IS_GRAPH(*args)

def CV_IS_GRAPH_ORIENTED(*args):
  """CV_IS_GRAPH_ORIENTED(CvSeq seq) -> int"""
  return _cv.CV_IS_GRAPH_ORIENTED(*args)

def CV_IS_SUBDIV2D(*args):
  """CV_IS_SUBDIV2D(CvSeq seq) -> int"""
  return _cv.CV_IS_SUBDIV2D(*args)

def CV_WRITE_SEQ_ELEM_VAR(*args):
  """CV_WRITE_SEQ_ELEM_VAR(void elem_ptr, CvSeqWriter writer)"""
  return _cv.CV_WRITE_SEQ_ELEM_VAR(*args)

def CV_WRITE_SEQ_ELEM(*args):
  """CV_WRITE_SEQ_ELEM(CvPoint elem, CvSeqWriter writer)"""
  return _cv.CV_WRITE_SEQ_ELEM(*args)

def CV_NEXT_SEQ_ELEM(*args):
  """CV_NEXT_SEQ_ELEM(int elem_size, CvSeqReader reader)"""
  return _cv.CV_NEXT_SEQ_ELEM(*args)

def CV_PREV_SEQ_ELEM(*args):
  """CV_PREV_SEQ_ELEM(int elem_size, CvSeqReader reader)"""
  return _cv.CV_PREV_SEQ_ELEM(*args)

def CV_READ_SEQ_ELEM(*args):
  """CV_READ_SEQ_ELEM(CvPoint elem, CvSeqReader reader)"""
  return _cv.CV_READ_SEQ_ELEM(*args)

def CV_REV_READ_SEQ_ELEM(*args):
  """CV_REV_READ_SEQ_ELEM(CvPoint elem, CvSeqReader reader)"""
  return _cv.CV_REV_READ_SEQ_ELEM(*args)

def CV_CURRENT_POINT(*args):
  """CV_CURRENT_POINT(CvSeqReader reader) -> CvPoint"""
  return _cv.CV_CURRENT_POINT(*args)

def CV_PREV_POINT(*args):
  """CV_PREV_POINT(CvSeqReader reader) -> CvPoint"""
  return _cv.CV_PREV_POINT(*args)

def CV_READ_EDGE(*args):
  """CV_READ_EDGE(CvPoint pt1, CvPoint pt2, CvSeqReader reader)"""
  return _cv.CV_READ_EDGE(*args)

def CV_NEXT_GRAPH_EDGE(*args):
  """CV_NEXT_GRAPH_EDGE(CvGraphEdge edge, CvGraphVtx vertex) -> CvGraphEdge"""
  return _cv.CV_NEXT_GRAPH_EDGE(*args)

def CV_NODE_TYPE(*args):
  """CV_NODE_TYPE(int flags) -> int"""
  return _cv.CV_NODE_TYPE(*args)

def CV_NODE_IS_INT(*args):
  """CV_NODE_IS_INT(int flags) -> int"""
  return _cv.CV_NODE_IS_INT(*args)

def CV_NODE_IS_REAL(*args):
  """CV_NODE_IS_REAL(int flags) -> int"""
  return _cv.CV_NODE_IS_REAL(*args)

def CV_NODE_IS_STRING(*args):
  """CV_NODE_IS_STRING(int flags) -> int"""
  return _cv.CV_NODE_IS_STRING(*args)

def CV_NODE_IS_SEQ(*args):
  """CV_NODE_IS_SEQ(int flags) -> int"""
  return _cv.CV_NODE_IS_SEQ(*args)

def CV_NODE_IS_MAP(*args):
  """CV_NODE_IS_MAP(int flags) -> int"""
  return _cv.CV_NODE_IS_MAP(*args)

def CV_NODE_IS_COLLECTION(*args):
  """CV_NODE_IS_COLLECTION(int flags) -> int"""
  return _cv.CV_NODE_IS_COLLECTION(*args)

def CV_NODE_IS_FLOW(*args):
  """CV_NODE_IS_FLOW(int flags) -> int"""
  return _cv.CV_NODE_IS_FLOW(*args)

def CV_NODE_IS_EMPTY(*args):
  """CV_NODE_IS_EMPTY(int flags) -> int"""
  return _cv.CV_NODE_IS_EMPTY(*args)

def CV_NODE_IS_USER(*args):
  """CV_NODE_IS_USER(int flags) -> int"""
  return _cv.CV_NODE_IS_USER(*args)

def CV_NODE_HAS_NAME(*args):
  """CV_NODE_HAS_NAME(int flags) -> int"""
  return _cv.CV_NODE_HAS_NAME(*args)

def CV_NODE_SEQ_IS_SIMPLE(*args):
  """CV_NODE_SEQ_IS_SIMPLE(CvSeq seq) -> int"""
  return _cv.CV_NODE_SEQ_IS_SIMPLE(*args)

def cvReshapeND(*args):
  """cvReshapeND(CvArr arr, int new_cn, int new_dims, int new_sizes)"""
  return _cv.cvReshapeND(*args)

def cvConvert(*args):
  """cvConvert(CvArr src, CvArr dst)"""
  return _cv.cvConvert(*args)

def cvAXPY(*args):
  """cvAXPY(CvArr A, double real_scalar, CvArr B, CvArr C)"""
  return _cv.cvAXPY(*args)

def cvAbs(*args):
  """cvAbs(CvArr src, CvArr dst)"""
  return _cv.cvAbs(*args)

def cvMatMulAdd(*args):
  """cvMatMulAdd(CvArr src1, CvArr src2, CvArr src3, CvArr dst)"""
  return _cv.cvMatMulAdd(*args)

def cvMatMul(*args):
  """cvMatMul(CvArr src1, CvArr src2, CvArr dst)"""
  return _cv.cvMatMul(*args)

def cvGetGraphVtx(*args):
  """cvGetGraphVtx(CvGraph graph, int idx)"""
  return _cv.cvGetGraphVtx(*args)

def cvGraphVtxIdx(*args):
  """cvGraphVtxIdx(CvGraph graph, CvGraphVtx vtx) -> int"""
  return _cv.cvGraphVtxIdx(*args)

def cvGraphEdgeIdx(*args):
  """cvGraphEdgeIdx(CvGraph graph, CvGraphEdge edge) -> int"""
  return _cv.cvGraphEdgeIdx(*args)

def cvGraphGetVtxCount(*args):
  """cvGraphGetVtxCount(CvGraph graph) -> int"""
  return _cv.cvGraphGetVtxCount(*args)

def cvGraphGetEdgeCount(*args):
  """cvGraphGetEdgeCount(CvGraph graph) -> int"""
  return _cv.cvGraphGetEdgeCount(*args)

def CV_IS_GRAPH_VERTEX_VISITED(*args):
  """CV_IS_GRAPH_VERTEX_VISITED(CvGraphVtx vtx) -> int"""
  return _cv.CV_IS_GRAPH_VERTEX_VISITED(*args)

def CV_IS_GRAPH_EDGE_VISITED(*args):
  """CV_IS_GRAPH_EDGE_VISITED(CvGraphEdge edge) -> int"""
  return _cv.CV_IS_GRAPH_EDGE_VISITED(*args)

def CV_RGB(*args):
  """CV_RGB(double r, double g, int b) -> CvScalar"""
  return _cv.CV_RGB(*args)

def CV_NEXT_LINE_POINT(*args):
  """CV_NEXT_LINE_POINT(CvLineIterator line_iterator)"""
  return _cv.CV_NEXT_LINE_POINT(*args)

def CV_INIT_3X3_DELTAS(*args):
  """CV_INIT_3X3_DELTAS(double deltas, int step, int nch)"""
  return _cv.CV_INIT_3X3_DELTAS(*args)

def CV_IS_HAAR_CLASSIFIER(*args):
  """CV_IS_HAAR_CLASSIFIER(void haar) -> int"""
  return _cv.CV_IS_HAAR_CLASSIFIER(*args)

def cvContourPerimeter(*args):
  """cvContourPerimeter(CvSeq contour) -> double"""
  return _cv.cvContourPerimeter(*args)

def cvCalcBackProject(*args):
  """cvCalcBackProject( image, CvArr dst, CvHistogram hist)"""
  return _cv.cvCalcBackProject(*args)

def cvCalcBackProjectPatch(*args):
  """
    cvCalcBackProjectPatch( image, CvArr dst, CvSize range, CvHistogram hist, 
        int method, double factor)
    """
  return _cv.cvCalcBackProjectPatch(*args)
sizeof_CvContour = _cv.sizeof_CvContour
sizeof_CvPoint = _cv.sizeof_CvPoint
sizeof_CvSeq = _cv.sizeof_CvSeq

def cvCreateImage(*args):
  """cvCreateImage(CvSize size, int depth, int channels) -> CvMat"""
  return _cv.cvCreateImage(*args)

def cvCloneImage(*args):
  """cvCloneImage(CvMat mat) -> CvMat"""
  return _cv.cvCloneImage(*args)
CV_AUTOSTEP = _cv.CV_AUTOSTEP
CV_MAX_ARR = _cv.CV_MAX_ARR
CV_NO_DEPTH_CHECK = _cv.CV_NO_DEPTH_CHECK
CV_NO_CN_CHECK = _cv.CV_NO_CN_CHECK
CV_NO_SIZE_CHECK = _cv.CV_NO_SIZE_CHECK
CV_CMP_EQ = _cv.CV_CMP_EQ
CV_CMP_GT = _cv.CV_CMP_GT
CV_CMP_GE = _cv.CV_CMP_GE
CV_CMP_LT = _cv.CV_CMP_LT
CV_CMP_LE = _cv.CV_CMP_LE
CV_CMP_NE = _cv.CV_CMP_NE
CV_CHECK_RANGE = _cv.CV_CHECK_RANGE
CV_CHECK_QUIET = _cv.CV_CHECK_QUIET
CV_RAND_UNI = _cv.CV_RAND_UNI
CV_RAND_NORMAL = _cv.CV_RAND_NORMAL
CV_SORT_EVERY_ROW = _cv.CV_SORT_EVERY_ROW
CV_SORT_EVERY_COLUMN = _cv.CV_SORT_EVERY_COLUMN
CV_SORT_ASCENDING = _cv.CV_SORT_ASCENDING
CV_SORT_DESCENDING = _cv.CV_SORT_DESCENDING
CV_GEMM_A_T = _cv.CV_GEMM_A_T
CV_GEMM_B_T = _cv.CV_GEMM_B_T
CV_GEMM_C_T = _cv.CV_GEMM_C_T
CV_SVD_MODIFY_A = _cv.CV_SVD_MODIFY_A
CV_SVD_U_T = _cv.CV_SVD_U_T
CV_SVD_V_T = _cv.CV_SVD_V_T
CV_LU = _cv.CV_LU
CV_SVD = _cv.CV_SVD
CV_SVD_SYM = _cv.CV_SVD_SYM
CV_CHOLESKY = _cv.CV_CHOLESKY
CV_QR = _cv.CV_QR
CV_NORMAL = _cv.CV_NORMAL
CV_COVAR_SCRAMBLED = _cv.CV_COVAR_SCRAMBLED
CV_COVAR_NORMAL = _cv.CV_COVAR_NORMAL
CV_COVAR_USE_AVG = _cv.CV_COVAR_USE_AVG
CV_COVAR_SCALE = _cv.CV_COVAR_SCALE
CV_COVAR_ROWS = _cv.CV_COVAR_ROWS
CV_COVAR_COLS = _cv.CV_COVAR_COLS
CV_PCA_DATA_AS_ROW = _cv.CV_PCA_DATA_AS_ROW
CV_PCA_DATA_AS_COL = _cv.CV_PCA_DATA_AS_COL
CV_PCA_USE_AVG = _cv.CV_PCA_USE_AVG
CV_C = _cv.CV_C
CV_L1 = _cv.CV_L1
CV_L2 = _cv.CV_L2
CV_NORM_MASK = _cv.CV_NORM_MASK
CV_RELATIVE = _cv.CV_RELATIVE
CV_DIFF = _cv.CV_DIFF
CV_MINMAX = _cv.CV_MINMAX
CV_DIFF_C = _cv.CV_DIFF_C
CV_DIFF_L1 = _cv.CV_DIFF_L1
CV_DIFF_L2 = _cv.CV_DIFF_L2
CV_RELATIVE_C = _cv.CV_RELATIVE_C
CV_RELATIVE_L1 = _cv.CV_RELATIVE_L1
CV_RELATIVE_L2 = _cv.CV_RELATIVE_L2
CV_REDUCE_SUM = _cv.CV_REDUCE_SUM
CV_REDUCE_AVG = _cv.CV_REDUCE_AVG
CV_REDUCE_MAX = _cv.CV_REDUCE_MAX
CV_REDUCE_MIN = _cv.CV_REDUCE_MIN
CV_DXT_FORWARD = _cv.CV_DXT_FORWARD
CV_DXT_INVERSE = _cv.CV_DXT_INVERSE
CV_DXT_SCALE = _cv.CV_DXT_SCALE
CV_DXT_INV_SCALE = _cv.CV_DXT_INV_SCALE
CV_DXT_INVERSE_SCALE = _cv.CV_DXT_INVERSE_SCALE
CV_DXT_ROWS = _cv.CV_DXT_ROWS
CV_DXT_MUL_CONJ = _cv.CV_DXT_MUL_CONJ
CV_FRONT = _cv.CV_FRONT
CV_BACK = _cv.CV_BACK
CV_GRAPH_VERTEX = _cv.CV_GRAPH_VERTEX
CV_GRAPH_TREE_EDGE = _cv.CV_GRAPH_TREE_EDGE
CV_GRAPH_BACK_EDGE = _cv.CV_GRAPH_BACK_EDGE
CV_GRAPH_FORWARD_EDGE = _cv.CV_GRAPH_FORWARD_EDGE
CV_GRAPH_CROSS_EDGE = _cv.CV_GRAPH_CROSS_EDGE
CV_GRAPH_ANY_EDGE = _cv.CV_GRAPH_ANY_EDGE
CV_GRAPH_NEW_TREE = _cv.CV_GRAPH_NEW_TREE
CV_GRAPH_BACKTRACKING = _cv.CV_GRAPH_BACKTRACKING
CV_GRAPH_OVER = _cv.CV_GRAPH_OVER
CV_GRAPH_ALL_ITEMS = _cv.CV_GRAPH_ALL_ITEMS
CV_GRAPH_ITEM_VISITED_FLAG = _cv.CV_GRAPH_ITEM_VISITED_FLAG
CV_GRAPH_SEARCH_TREE_NODE_FLAG = _cv.CV_GRAPH_SEARCH_TREE_NODE_FLAG
CV_GRAPH_FORWARD_EDGE_FLAG = _cv.CV_GRAPH_FORWARD_EDGE_FLAG
CV_FILLED = _cv.CV_FILLED
CV_AA = _cv.CV_AA
CV_FONT_HERSHEY_SIMPLEX = _cv.CV_FONT_HERSHEY_SIMPLEX
CV_FONT_HERSHEY_PLAIN = _cv.CV_FONT_HERSHEY_PLAIN
CV_FONT_HERSHEY_DUPLEX = _cv.CV_FONT_HERSHEY_DUPLEX
CV_FONT_HERSHEY_COMPLEX = _cv.CV_FONT_HERSHEY_COMPLEX
CV_FONT_HERSHEY_TRIPLEX = _cv.CV_FONT_HERSHEY_TRIPLEX
CV_FONT_HERSHEY_COMPLEX_SMALL = _cv.CV_FONT_HERSHEY_COMPLEX_SMALL
CV_FONT_HERSHEY_SCRIPT_SIMPLEX = _cv.CV_FONT_HERSHEY_SCRIPT_SIMPLEX
CV_FONT_HERSHEY_SCRIPT_COMPLEX = _cv.CV_FONT_HERSHEY_SCRIPT_COMPLEX
CV_FONT_ITALIC = _cv.CV_FONT_ITALIC
CV_FONT_VECTOR0 = _cv.CV_FONT_VECTOR0
CV_KMEANS_USE_INITIAL_LABELS = _cv.CV_KMEANS_USE_INITIAL_LABELS
CV_ErrModeLeaf = _cv.CV_ErrModeLeaf
CV_ErrModeParent = _cv.CV_ErrModeParent
CV_ErrModeSilent = _cv.CV_ErrModeSilent
CV_MAJOR_VERSION = _cv.CV_MAJOR_VERSION
CV_MINOR_VERSION = _cv.CV_MINOR_VERSION
CV_SUBMINOR_VERSION = _cv.CV_SUBMINOR_VERSION
CV_PI = _cv.CV_PI
CV_LOG2 = _cv.CV_LOG2
IPL_DEPTH_SIGN = _cv.IPL_DEPTH_SIGN
IPL_DEPTH_1U = _cv.IPL_DEPTH_1U
IPL_DEPTH_8U = _cv.IPL_DEPTH_8U
IPL_DEPTH_16U = _cv.IPL_DEPTH_16U
IPL_DEPTH_32F = _cv.IPL_DEPTH_32F
IPL_DEPTH_8S = _cv.IPL_DEPTH_8S
IPL_DEPTH_16S = _cv.IPL_DEPTH_16S
IPL_DEPTH_32S = _cv.IPL_DEPTH_32S
IPL_DATA_ORDER_PIXEL = _cv.IPL_DATA_ORDER_PIXEL
IPL_DATA_ORDER_PLANE = _cv.IPL_DATA_ORDER_PLANE
IPL_ORIGIN_TL = _cv.IPL_ORIGIN_TL
IPL_ORIGIN_BL = _cv.IPL_ORIGIN_BL
IPL_ALIGN_4BYTES = _cv.IPL_ALIGN_4BYTES
IPL_ALIGN_8BYTES = _cv.IPL_ALIGN_8BYTES
IPL_ALIGN_16BYTES = _cv.IPL_ALIGN_16BYTES
IPL_ALIGN_32BYTES = _cv.IPL_ALIGN_32BYTES
IPL_ALIGN_DWORD = _cv.IPL_ALIGN_DWORD
IPL_ALIGN_QWORD = _cv.IPL_ALIGN_QWORD
IPL_BORDER_CONSTANT = _cv.IPL_BORDER_CONSTANT
IPL_BORDER_REPLICATE = _cv.IPL_BORDER_REPLICATE
IPL_BORDER_REFLECT = _cv.IPL_BORDER_REFLECT
IPL_BORDER_WRAP = _cv.IPL_BORDER_WRAP
IPL_IMAGE_HEADER = _cv.IPL_IMAGE_HEADER
IPL_IMAGE_DATA = _cv.IPL_IMAGE_DATA
IPL_IMAGE_ROI = _cv.IPL_IMAGE_ROI
IPL_BORDER_REFLECT_101 = _cv.IPL_BORDER_REFLECT_101
CV_TYPE_NAME_IMAGE = _cv.CV_TYPE_NAME_IMAGE
IPL_DEPTH_64F = _cv.IPL_DEPTH_64F
CV_CN_MAX = _cv.CV_CN_MAX
CV_CN_SHIFT = _cv.CV_CN_SHIFT
CV_DEPTH_MAX = _cv.CV_DEPTH_MAX
CV_8U = _cv.CV_8U
CV_8S = _cv.CV_8S
CV_16U = _cv.CV_16U
CV_16S = _cv.CV_16S
CV_32S = _cv.CV_32S
CV_32F = _cv.CV_32F
CV_64F = _cv.CV_64F
CV_USRTYPE1 = _cv.CV_USRTYPE1
CV_MAT_DEPTH_MASK = _cv.CV_MAT_DEPTH_MASK
CV_8UC1 = _cv.CV_8UC1
CV_8UC2 = _cv.CV_8UC2
CV_8UC3 = _cv.CV_8UC3
CV_8UC4 = _cv.CV_8UC4
CV_8SC1 = _cv.CV_8SC1
CV_8SC2 = _cv.CV_8SC2
CV_8SC3 = _cv.CV_8SC3
CV_8SC4 = _cv.CV_8SC4
CV_16UC1 = _cv.CV_16UC1
CV_16UC2 = _cv.CV_16UC2
CV_16UC3 = _cv.CV_16UC3
CV_16UC4 = _cv.CV_16UC4
CV_16SC1 = _cv.CV_16SC1
CV_16SC2 = _cv.CV_16SC2
CV_16SC3 = _cv.CV_16SC3
CV_16SC4 = _cv.CV_16SC4
CV_32SC1 = _cv.CV_32SC1
CV_32SC2 = _cv.CV_32SC2
CV_32SC3 = _cv.CV_32SC3
CV_32SC4 = _cv.CV_32SC4
CV_32FC1 = _cv.CV_32FC1
CV_32FC2 = _cv.CV_32FC2
CV_32FC3 = _cv.CV_32FC3
CV_32FC4 = _cv.CV_32FC4
CV_64FC1 = _cv.CV_64FC1
CV_64FC2 = _cv.CV_64FC2
CV_64FC3 = _cv.CV_64FC3
CV_64FC4 = _cv.CV_64FC4
CV_AUTO_STEP = _cv.CV_AUTO_STEP
CV_MAT_CN_MASK = _cv.CV_MAT_CN_MASK
CV_MAT_TYPE_MASK = _cv.CV_MAT_TYPE_MASK
CV_MAT_CONT_FLAG_SHIFT = _cv.CV_MAT_CONT_FLAG_SHIFT
CV_MAT_CONT_FLAG = _cv.CV_MAT_CONT_FLAG
CV_MAT_TEMP_FLAG_SHIFT = _cv.CV_MAT_TEMP_FLAG_SHIFT
CV_MAT_TEMP_FLAG = _cv.CV_MAT_TEMP_FLAG
CV_MAGIC_MASK = _cv.CV_MAGIC_MASK
CV_MAT_MAGIC_VAL = _cv.CV_MAT_MAGIC_VAL
CV_TYPE_NAME_MAT = _cv.CV_TYPE_NAME_MAT
CV_MATND_MAGIC_VAL = _cv.CV_MATND_MAGIC_VAL
CV_TYPE_NAME_MATND = _cv.CV_TYPE_NAME_MATND
CV_MAX_DIM = _cv.CV_MAX_DIM
CV_MAX_DIM_HEAP = _cv.CV_MAX_DIM_HEAP
CV_SPARSE_MAT_MAGIC_VAL = _cv.CV_SPARSE_MAT_MAGIC_VAL
CV_TYPE_NAME_SPARSE_MAT = _cv.CV_TYPE_NAME_SPARSE_MAT
CV_HIST_MAGIC_VAL = _cv.CV_HIST_MAGIC_VAL
CV_HIST_UNIFORM_FLAG = _cv.CV_HIST_UNIFORM_FLAG
CV_HIST_RANGES_FLAG = _cv.CV_HIST_RANGES_FLAG
CV_HIST_ARRAY = _cv.CV_HIST_ARRAY
CV_HIST_SPARSE = _cv.CV_HIST_SPARSE
CV_HIST_TREE = _cv.CV_HIST_TREE
CV_HIST_UNIFORM = _cv.CV_HIST_UNIFORM
CV_TERMCRIT_ITER = _cv.CV_TERMCRIT_ITER
CV_TERMCRIT_NUMBER = _cv.CV_TERMCRIT_NUMBER
CV_TERMCRIT_EPS = _cv.CV_TERMCRIT_EPS
CV_WHOLE_SEQ_END_INDEX = _cv.CV_WHOLE_SEQ_END_INDEX
CV_STORAGE_MAGIC_VAL = _cv.CV_STORAGE_MAGIC_VAL
CV_TYPE_NAME_SEQ = _cv.CV_TYPE_NAME_SEQ
CV_TYPE_NAME_SEQ_TREE = _cv.CV_TYPE_NAME_SEQ_TREE
CV_SET_ELEM_IDX_MASK = _cv.CV_SET_ELEM_IDX_MASK
CV_TYPE_NAME_GRAPH = _cv.CV_TYPE_NAME_GRAPH
CV_SEQ_MAGIC_VAL = _cv.CV_SEQ_MAGIC_VAL
CV_SET_MAGIC_VAL = _cv.CV_SET_MAGIC_VAL
CV_SEQ_ELTYPE_BITS = _cv.CV_SEQ_ELTYPE_BITS
CV_SEQ_ELTYPE_MASK = _cv.CV_SEQ_ELTYPE_MASK
CV_SEQ_ELTYPE_POINT = _cv.CV_SEQ_ELTYPE_POINT
CV_SEQ_ELTYPE_CODE = _cv.CV_SEQ_ELTYPE_CODE
CV_SEQ_ELTYPE_GENERIC = _cv.CV_SEQ_ELTYPE_GENERIC
CV_SEQ_ELTYPE_PTR = _cv.CV_SEQ_ELTYPE_PTR
CV_SEQ_ELTYPE_PPOINT = _cv.CV_SEQ_ELTYPE_PPOINT
CV_SEQ_ELTYPE_INDEX = _cv.CV_SEQ_ELTYPE_INDEX
CV_SEQ_ELTYPE_GRAPH_EDGE = _cv.CV_SEQ_ELTYPE_GRAPH_EDGE
CV_SEQ_ELTYPE_GRAPH_VERTEX = _cv.CV_SEQ_ELTYPE_GRAPH_VERTEX
CV_SEQ_ELTYPE_TRIAN_ATR = _cv.CV_SEQ_ELTYPE_TRIAN_ATR
CV_SEQ_ELTYPE_CONNECTED_COMP = _cv.CV_SEQ_ELTYPE_CONNECTED_COMP
CV_SEQ_ELTYPE_POINT3D = _cv.CV_SEQ_ELTYPE_POINT3D
CV_SEQ_KIND_BITS = _cv.CV_SEQ_KIND_BITS
CV_SEQ_KIND_MASK = _cv.CV_SEQ_KIND_MASK
CV_SEQ_KIND_GENERIC = _cv.CV_SEQ_KIND_GENERIC
CV_SEQ_KIND_CURVE = _cv.CV_SEQ_KIND_CURVE
CV_SEQ_KIND_BIN_TREE = _cv.CV_SEQ_KIND_BIN_TREE
CV_SEQ_KIND_GRAPH = _cv.CV_SEQ_KIND_GRAPH
CV_SEQ_KIND_SUBDIV2D = _cv.CV_SEQ_KIND_SUBDIV2D
CV_SEQ_FLAG_SHIFT = _cv.CV_SEQ_FLAG_SHIFT
CV_SEQ_FLAG_CLOSED = _cv.CV_SEQ_FLAG_CLOSED
CV_SEQ_FLAG_SIMPLE = _cv.CV_SEQ_FLAG_SIMPLE
CV_SEQ_FLAG_CONVEX = _cv.CV_SEQ_FLAG_CONVEX
CV_SEQ_FLAG_HOLE = _cv.CV_SEQ_FLAG_HOLE
CV_GRAPH_FLAG_ORIENTED = _cv.CV_GRAPH_FLAG_ORIENTED
CV_GRAPH = _cv.CV_GRAPH
CV_ORIENTED_GRAPH = _cv.CV_ORIENTED_GRAPH
CV_SEQ_POINT_SET = _cv.CV_SEQ_POINT_SET
CV_SEQ_POINT3D_SET = _cv.CV_SEQ_POINT3D_SET
CV_SEQ_POLYLINE = _cv.CV_SEQ_POLYLINE
CV_SEQ_POLYGON = _cv.CV_SEQ_POLYGON
CV_SEQ_CONTOUR = _cv.CV_SEQ_CONTOUR
CV_SEQ_SIMPLE_POLYGON = _cv.CV_SEQ_SIMPLE_POLYGON
CV_SEQ_CHAIN = _cv.CV_SEQ_CHAIN
CV_SEQ_CHAIN_CONTOUR = _cv.CV_SEQ_CHAIN_CONTOUR
CV_SEQ_POLYGON_TREE = _cv.CV_SEQ_POLYGON_TREE
CV_SEQ_CONNECTED_COMP = _cv.CV_SEQ_CONNECTED_COMP
CV_SEQ_INDEX = _cv.CV_SEQ_INDEX
CV_STORAGE_READ = _cv.CV_STORAGE_READ
CV_STORAGE_WRITE = _cv.CV_STORAGE_WRITE
CV_STORAGE_WRITE_TEXT = _cv.CV_STORAGE_WRITE_TEXT
CV_STORAGE_WRITE_BINARY = _cv.CV_STORAGE_WRITE_BINARY
CV_STORAGE_APPEND = _cv.CV_STORAGE_APPEND
CV_NODE_NONE = _cv.CV_NODE_NONE
CV_NODE_INT = _cv.CV_NODE_INT
CV_NODE_INTEGER = _cv.CV_NODE_INTEGER
CV_NODE_REAL = _cv.CV_NODE_REAL
CV_NODE_FLOAT = _cv.CV_NODE_FLOAT
CV_NODE_STR = _cv.CV_NODE_STR
CV_NODE_STRING = _cv.CV_NODE_STRING
CV_NODE_REF = _cv.CV_NODE_REF
CV_NODE_SEQ = _cv.CV_NODE_SEQ
CV_NODE_MAP = _cv.CV_NODE_MAP
CV_NODE_TYPE_MASK = _cv.CV_NODE_TYPE_MASK
CV_NODE_FLOW = _cv.CV_NODE_FLOW
CV_NODE_USER = _cv.CV_NODE_USER
CV_NODE_EMPTY = _cv.CV_NODE_EMPTY
CV_NODE_NAMED = _cv.CV_NODE_NAMED
CV_NODE_SEQ_SIMPLE = _cv.CV_NODE_SEQ_SIMPLE
CV_StsOk = _cv.CV_StsOk
CV_StsBackTrace = _cv.CV_StsBackTrace
CV_StsError = _cv.CV_StsError
CV_StsInternal = _cv.CV_StsInternal
CV_StsNoMem = _cv.CV_StsNoMem
CV_StsBadArg = _cv.CV_StsBadArg
CV_StsBadFunc = _cv.CV_StsBadFunc
CV_StsNoConv = _cv.CV_StsNoConv
CV_StsAutoTrace = _cv.CV_StsAutoTrace
CV_HeaderIsNull = _cv.CV_HeaderIsNull
CV_BadImageSize = _cv.CV_BadImageSize
CV_BadOffset = _cv.CV_BadOffset
CV_BadDataPtr = _cv.CV_BadDataPtr
CV_BadStep = _cv.CV_BadStep
CV_BadModelOrChSeq = _cv.CV_BadModelOrChSeq
CV_BadNumChannels = _cv.CV_BadNumChannels
CV_BadNumChannel1U = _cv.CV_BadNumChannel1U
CV_BadDepth = _cv.CV_BadDepth
CV_BadAlphaChannel = _cv.CV_BadAlphaChannel
CV_BadOrder = _cv.CV_BadOrder
CV_BadOrigin = _cv.CV_BadOrigin
CV_BadAlign = _cv.CV_BadAlign
CV_BadCallBack = _cv.CV_BadCallBack
CV_BadTileSize = _cv.CV_BadTileSize
CV_BadCOI = _cv.CV_BadCOI
CV_BadROISize = _cv.CV_BadROISize
CV_MaskIsTiled = _cv.CV_MaskIsTiled
CV_StsNullPtr = _cv.CV_StsNullPtr
CV_StsVecLengthErr = _cv.CV_StsVecLengthErr
CV_StsFilterStructContentErr = _cv.CV_StsFilterStructContentErr
CV_StsKernelStructContentErr = _cv.CV_StsKernelStructContentErr
CV_StsFilterOffsetErr = _cv.CV_StsFilterOffsetErr
CV_StsBadSize = _cv.CV_StsBadSize
CV_StsDivByZero = _cv.CV_StsDivByZero
CV_StsInplaceNotSupported = _cv.CV_StsInplaceNotSupported
CV_StsObjectNotFound = _cv.CV_StsObjectNotFound
CV_StsUnmatchedFormats = _cv.CV_StsUnmatchedFormats
CV_StsBadFlag = _cv.CV_StsBadFlag
CV_StsBadPoint = _cv.CV_StsBadPoint
CV_StsBadMask = _cv.CV_StsBadMask
CV_StsUnmatchedSizes = _cv.CV_StsUnmatchedSizes
CV_StsUnsupportedFormat = _cv.CV_StsUnsupportedFormat
CV_StsOutOfRange = _cv.CV_StsOutOfRange
CV_StsParseError = _cv.CV_StsParseError
CV_StsNotImplemented = _cv.CV_StsNotImplemented
CV_StsBadMemBlock = _cv.CV_StsBadMemBlock
CV_StsAssert = _cv.CV_StsAssert
CV_BLUR_NO_SCALE = _cv.CV_BLUR_NO_SCALE
CV_BLUR = _cv.CV_BLUR
CV_GAUSSIAN = _cv.CV_GAUSSIAN
CV_MEDIAN = _cv.CV_MEDIAN
CV_BILATERAL = _cv.CV_BILATERAL
CV_INPAINT_NS = _cv.CV_INPAINT_NS
CV_INPAINT_TELEA = _cv.CV_INPAINT_TELEA
CV_SCHARR = _cv.CV_SCHARR
CV_MAX_SOBEL_KSIZE = _cv.CV_MAX_SOBEL_KSIZE
CV_BGR2BGRA = _cv.CV_BGR2BGRA
CV_RGB2RGBA = _cv.CV_RGB2RGBA
CV_BGRA2BGR = _cv.CV_BGRA2BGR
CV_RGBA2RGB = _cv.CV_RGBA2RGB
CV_BGR2RGBA = _cv.CV_BGR2RGBA
CV_RGB2BGRA = _cv.CV_RGB2BGRA
CV_RGBA2BGR = _cv.CV_RGBA2BGR
CV_BGRA2RGB = _cv.CV_BGRA2RGB
CV_BGR2RGB = _cv.CV_BGR2RGB
CV_RGB2BGR = _cv.CV_RGB2BGR
CV_BGRA2RGBA = _cv.CV_BGRA2RGBA
CV_RGBA2BGRA = _cv.CV_RGBA2BGRA
CV_BGR2GRAY = _cv.CV_BGR2GRAY
CV_RGB2GRAY = _cv.CV_RGB2GRAY
CV_GRAY2BGR = _cv.CV_GRAY2BGR
CV_GRAY2RGB = _cv.CV_GRAY2RGB
CV_GRAY2BGRA = _cv.CV_GRAY2BGRA
CV_GRAY2RGBA = _cv.CV_GRAY2RGBA
CV_BGRA2GRAY = _cv.CV_BGRA2GRAY
CV_RGBA2GRAY = _cv.CV_RGBA2GRAY
CV_BGR2BGR565 = _cv.CV_BGR2BGR565
CV_RGB2BGR565 = _cv.CV_RGB2BGR565
CV_BGR5652BGR = _cv.CV_BGR5652BGR
CV_BGR5652RGB = _cv.CV_BGR5652RGB
CV_BGRA2BGR565 = _cv.CV_BGRA2BGR565
CV_RGBA2BGR565 = _cv.CV_RGBA2BGR565
CV_BGR5652BGRA = _cv.CV_BGR5652BGRA
CV_BGR5652RGBA = _cv.CV_BGR5652RGBA
CV_GRAY2BGR565 = _cv.CV_GRAY2BGR565
CV_BGR5652GRAY = _cv.CV_BGR5652GRAY
CV_BGR2BGR555 = _cv.CV_BGR2BGR555
CV_RGB2BGR555 = _cv.CV_RGB2BGR555
CV_BGR5552BGR = _cv.CV_BGR5552BGR
CV_BGR5552RGB = _cv.CV_BGR5552RGB
CV_BGRA2BGR555 = _cv.CV_BGRA2BGR555
CV_RGBA2BGR555 = _cv.CV_RGBA2BGR555
CV_BGR5552BGRA = _cv.CV_BGR5552BGRA
CV_BGR5552RGBA = _cv.CV_BGR5552RGBA
CV_GRAY2BGR555 = _cv.CV_GRAY2BGR555
CV_BGR5552GRAY = _cv.CV_BGR5552GRAY
CV_BGR2XYZ = _cv.CV_BGR2XYZ
CV_RGB2XYZ = _cv.CV_RGB2XYZ
CV_XYZ2BGR = _cv.CV_XYZ2BGR
CV_XYZ2RGB = _cv.CV_XYZ2RGB
CV_BGR2YCrCb = _cv.CV_BGR2YCrCb
CV_RGB2YCrCb = _cv.CV_RGB2YCrCb
CV_YCrCb2BGR = _cv.CV_YCrCb2BGR
CV_YCrCb2RGB = _cv.CV_YCrCb2RGB
CV_BGR2HSV = _cv.CV_BGR2HSV
CV_RGB2HSV = _cv.CV_RGB2HSV
CV_BGR2Lab = _cv.CV_BGR2Lab
CV_RGB2Lab = _cv.CV_RGB2Lab
CV_BayerBG2BGR = _cv.CV_BayerBG2BGR
CV_BayerGB2BGR = _cv.CV_BayerGB2BGR
CV_BayerRG2BGR = _cv.CV_BayerRG2BGR
CV_BayerGR2BGR = _cv.CV_BayerGR2BGR
CV_BayerBG2RGB = _cv.CV_BayerBG2RGB
CV_BayerGB2RGB = _cv.CV_BayerGB2RGB
CV_BayerRG2RGB = _cv.CV_BayerRG2RGB
CV_BayerGR2RGB = _cv.CV_BayerGR2RGB
CV_BGR2Luv = _cv.CV_BGR2Luv
CV_RGB2Luv = _cv.CV_RGB2Luv
CV_BGR2HLS = _cv.CV_BGR2HLS
CV_RGB2HLS = _cv.CV_RGB2HLS
CV_HSV2BGR = _cv.CV_HSV2BGR
CV_HSV2RGB = _cv.CV_HSV2RGB
CV_Lab2BGR = _cv.CV_Lab2BGR
CV_Lab2RGB = _cv.CV_Lab2RGB
CV_Luv2BGR = _cv.CV_Luv2BGR
CV_Luv2RGB = _cv.CV_Luv2RGB
CV_HLS2BGR = _cv.CV_HLS2BGR
CV_HLS2RGB = _cv.CV_HLS2RGB
CV_COLORCVT_MAX = _cv.CV_COLORCVT_MAX
CV_INTER_NN = _cv.CV_INTER_NN
CV_INTER_LINEAR = _cv.CV_INTER_LINEAR
CV_INTER_CUBIC = _cv.CV_INTER_CUBIC
CV_INTER_AREA = _cv.CV_INTER_AREA
CV_WARP_FILL_OUTLIERS = _cv.CV_WARP_FILL_OUTLIERS
CV_WARP_INVERSE_MAP = _cv.CV_WARP_INVERSE_MAP
CV_SHAPE_RECT = _cv.CV_SHAPE_RECT
CV_SHAPE_CROSS = _cv.CV_SHAPE_CROSS
CV_SHAPE_ELLIPSE = _cv.CV_SHAPE_ELLIPSE
CV_SHAPE_CUSTOM = _cv.CV_SHAPE_CUSTOM
CV_MOP_OPEN = _cv.CV_MOP_OPEN
CV_MOP_CLOSE = _cv.CV_MOP_CLOSE
CV_MOP_GRADIENT = _cv.CV_MOP_GRADIENT
CV_MOP_TOPHAT = _cv.CV_MOP_TOPHAT
CV_MOP_BLACKHAT = _cv.CV_MOP_BLACKHAT
CV_TM_SQDIFF = _cv.CV_TM_SQDIFF
CV_TM_SQDIFF_NORMED = _cv.CV_TM_SQDIFF_NORMED
CV_TM_CCORR = _cv.CV_TM_CCORR
CV_TM_CCORR_NORMED = _cv.CV_TM_CCORR_NORMED
CV_TM_CCOEFF = _cv.CV_TM_CCOEFF
CV_TM_CCOEFF_NORMED = _cv.CV_TM_CCOEFF_NORMED
CV_LKFLOW_PYR_A_READY = _cv.CV_LKFLOW_PYR_A_READY
CV_LKFLOW_PYR_B_READY = _cv.CV_LKFLOW_PYR_B_READY
CV_LKFLOW_INITIAL_GUESSES = _cv.CV_LKFLOW_INITIAL_GUESSES
CV_LKFLOW_GET_MIN_EIGENVALS = _cv.CV_LKFLOW_GET_MIN_EIGENVALS
CV_POLY_APPROX_DP = _cv.CV_POLY_APPROX_DP
CV_DOMINANT_IPAN = _cv.CV_DOMINANT_IPAN
CV_CONTOURS_MATCH_I1 = _cv.CV_CONTOURS_MATCH_I1
CV_CONTOURS_MATCH_I2 = _cv.CV_CONTOURS_MATCH_I2
CV_CONTOURS_MATCH_I3 = _cv.CV_CONTOURS_MATCH_I3
CV_CONTOUR_TREES_MATCH_I1 = _cv.CV_CONTOUR_TREES_MATCH_I1
CV_CLOCKWISE = _cv.CV_CLOCKWISE
CV_COUNTER_CLOCKWISE = _cv.CV_COUNTER_CLOCKWISE
CV_COMP_CORREL = _cv.CV_COMP_CORREL
CV_COMP_CHISQR = _cv.CV_COMP_CHISQR
CV_COMP_INTERSECT = _cv.CV_COMP_INTERSECT
CV_COMP_BHATTACHARYYA = _cv.CV_COMP_BHATTACHARYYA
CV_VALUE = _cv.CV_VALUE
CV_ARRAY = _cv.CV_ARRAY
CV_DIST_MASK_3 = _cv.CV_DIST_MASK_3
CV_DIST_MASK_5 = _cv.CV_DIST_MASK_5
CV_DIST_MASK_PRECISE = _cv.CV_DIST_MASK_PRECISE
CV_THRESH_BINARY = _cv.CV_THRESH_BINARY
CV_THRESH_BINARY_INV = _cv.CV_THRESH_BINARY_INV
CV_THRESH_TRUNC = _cv.CV_THRESH_TRUNC
CV_THRESH_TOZERO = _cv.CV_THRESH_TOZERO
CV_THRESH_TOZERO_INV = _cv.CV_THRESH_TOZERO_INV
CV_THRESH_MASK = _cv.CV_THRESH_MASK
CV_THRESH_OTSU = _cv.CV_THRESH_OTSU
CV_ADAPTIVE_THRESH_MEAN_C = _cv.CV_ADAPTIVE_THRESH_MEAN_C
CV_ADAPTIVE_THRESH_GAUSSIAN_C = _cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C
CV_FLOODFILL_FIXED_RANGE = _cv.CV_FLOODFILL_FIXED_RANGE
CV_FLOODFILL_MASK_ONLY = _cv.CV_FLOODFILL_MASK_ONLY
CV_CANNY_L2_GRADIENT = _cv.CV_CANNY_L2_GRADIENT
CV_HOUGH_STANDARD = _cv.CV_HOUGH_STANDARD
CV_HOUGH_PROBABILISTIC = _cv.CV_HOUGH_PROBABILISTIC
CV_HOUGH_MULTI_SCALE = _cv.CV_HOUGH_MULTI_SCALE
CV_HOUGH_GRADIENT = _cv.CV_HOUGH_GRADIENT
CV_HAAR_DO_CANNY_PRUNING = _cv.CV_HAAR_DO_CANNY_PRUNING
CV_HAAR_SCALE_IMAGE = _cv.CV_HAAR_SCALE_IMAGE
CV_HAAR_FIND_BIGGEST_OBJECT = _cv.CV_HAAR_FIND_BIGGEST_OBJECT
CV_HAAR_DO_ROUGH_SEARCH = _cv.CV_HAAR_DO_ROUGH_SEARCH
CV_LMEDS = _cv.CV_LMEDS
CV_RANSAC = _cv.CV_RANSAC
CV_CALIB_CB_ADAPTIVE_THRESH = _cv.CV_CALIB_CB_ADAPTIVE_THRESH
CV_CALIB_CB_NORMALIZE_IMAGE = _cv.CV_CALIB_CB_NORMALIZE_IMAGE
CV_CALIB_CB_FILTER_QUADS = _cv.CV_CALIB_CB_FILTER_QUADS
CV_CALIB_USE_INTRINSIC_GUESS = _cv.CV_CALIB_USE_INTRINSIC_GUESS
CV_CALIB_FIX_ASPECT_RATIO = _cv.CV_CALIB_FIX_ASPECT_RATIO
CV_CALIB_FIX_PRINCIPAL_POINT = _cv.CV_CALIB_FIX_PRINCIPAL_POINT
CV_CALIB_ZERO_TANGENT_DIST = _cv.CV_CALIB_ZERO_TANGENT_DIST
CV_CALIB_FIX_FOCAL_LENGTH = _cv.CV_CALIB_FIX_FOCAL_LENGTH
CV_CALIB_FIX_K1 = _cv.CV_CALIB_FIX_K1
CV_CALIB_FIX_K2 = _cv.CV_CALIB_FIX_K2
CV_CALIB_FIX_K3 = _cv.CV_CALIB_FIX_K3
CV_CALIB_FIX_INTRINSIC = _cv.CV_CALIB_FIX_INTRINSIC
CV_CALIB_SAME_FOCAL_LENGTH = _cv.CV_CALIB_SAME_FOCAL_LENGTH
CV_CALIB_ZERO_DISPARITY = _cv.CV_CALIB_ZERO_DISPARITY
CV_FM_7POINT = _cv.CV_FM_7POINT
CV_FM_8POINT = _cv.CV_FM_8POINT
CV_FM_LMEDS_ONLY = _cv.CV_FM_LMEDS_ONLY
CV_FM_RANSAC_ONLY = _cv.CV_FM_RANSAC_ONLY
CV_FM_LMEDS = _cv.CV_FM_LMEDS
CV_FM_RANSAC = _cv.CV_FM_RANSAC
CV_STEREO_BM_NORMALIZED_RESPONSE = _cv.CV_STEREO_BM_NORMALIZED_RESPONSE
CV_STEREO_BM_BASIC = _cv.CV_STEREO_BM_BASIC
CV_STEREO_BM_FISH_EYE = _cv.CV_STEREO_BM_FISH_EYE
CV_STEREO_BM_NARROW = _cv.CV_STEREO_BM_NARROW
CV_RETR_EXTERNAL = _cv.CV_RETR_EXTERNAL
CV_RETR_LIST = _cv.CV_RETR_LIST
CV_RETR_CCOMP = _cv.CV_RETR_CCOMP
CV_RETR_TREE = _cv.CV_RETR_TREE
CV_CHAIN_CODE = _cv.CV_CHAIN_CODE
CV_CHAIN_APPROX_NONE = _cv.CV_CHAIN_APPROX_NONE
CV_CHAIN_APPROX_SIMPLE = _cv.CV_CHAIN_APPROX_SIMPLE
CV_CHAIN_APPROX_TC89_L1 = _cv.CV_CHAIN_APPROX_TC89_L1
CV_CHAIN_APPROX_TC89_KCOS = _cv.CV_CHAIN_APPROX_TC89_KCOS
CV_LINK_RUNS = _cv.CV_LINK_RUNS
CV_SUBDIV2D_VIRTUAL_POINT_FLAG = _cv.CV_SUBDIV2D_VIRTUAL_POINT_FLAG
CV_DIST_USER = _cv.CV_DIST_USER
CV_DIST_L1 = _cv.CV_DIST_L1
CV_DIST_L2 = _cv.CV_DIST_L2
CV_DIST_C = _cv.CV_DIST_C
CV_DIST_L12 = _cv.CV_DIST_L12
CV_DIST_FAIR = _cv.CV_DIST_FAIR
CV_DIST_WELSCH = _cv.CV_DIST_WELSCH
CV_DIST_HUBER = _cv.CV_DIST_HUBER
CV_HAAR_MAGIC_VAL = _cv.CV_HAAR_MAGIC_VAL
CV_TYPE_NAME_HAAR = _cv.CV_TYPE_NAME_HAAR
CV_HAAR_FEATURE_MAX = _cv.CV_HAAR_FEATURE_MAX
class Cv32suf(_object):
    """Proxy of C++ Cv32suf class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cv32suf, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Cv32suf, name)
    __repr__ = _swig_repr
    __swig_setmethods__["i"] = _cv.Cv32suf_i_set
    __swig_getmethods__["i"] = _cv.Cv32suf_i_get
    if _newclass:i = _swig_property(_cv.Cv32suf_i_get, _cv.Cv32suf_i_set)
    __swig_setmethods__["u"] = _cv.Cv32suf_u_set
    __swig_getmethods__["u"] = _cv.Cv32suf_u_get
    if _newclass:u = _swig_property(_cv.Cv32suf_u_get, _cv.Cv32suf_u_set)
    __swig_setmethods__["f"] = _cv.Cv32suf_f_set
    __swig_getmethods__["f"] = _cv.Cv32suf_f_get
    if _newclass:f = _swig_property(_cv.Cv32suf_f_get, _cv.Cv32suf_f_set)
    def __init__(self): 
        """__init__(self) -> Cv32suf"""
        this = _cv.new_Cv32suf()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_Cv32suf
    __del__ = lambda self : None;
Cv32suf_swigregister = _cv.Cv32suf_swigregister
Cv32suf_swigregister(Cv32suf)

def cvCvtSeqToArray(*args):
  """
    cvCvtSeqToArray(CvSeq seq, CvArr elements, CvSlice slice = CV_WHOLE_SEQ) -> CvArr
    cvCvtSeqToArray(CvSeq seq, CvArr elements) -> CvArr
    """
  return _cv.cvCvtSeqToArray(*args)

def cvHaarDetectObjects(*args):
  """
    cvHaarDetectObjects(CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage, 
        double scale_factor = 1.1, int min_neighbors = 3, 
        int flags = 0, CvSize min_size = cvSize(0,0)) -> CvSeq_CvRect
    cvHaarDetectObjects(CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage, 
        double scale_factor = 1.1, int min_neighbors = 3, 
        int flags = 0) -> CvSeq_CvRect
    cvHaarDetectObjects(CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage, 
        double scale_factor = 1.1, int min_neighbors = 3) -> CvSeq_CvRect
    cvHaarDetectObjects(CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage, 
        double scale_factor = 1.1) -> CvSeq_CvRect
    cvHaarDetectObjects(CvArr image, CvHaarClassifierCascade cascade, CvMemStorage storage) -> CvSeq_CvRect
    """
  return _cv.cvHaarDetectObjects(*args)

def cvApproxPoly(*args):
  """
    cvApproxPoly(void src_seq, int header_size, CvMemStorage storage, 
        int method, double parameter, int parameter2 = 0) -> CvSeq_CvPoint
    cvApproxPoly(void src_seq, int header_size, CvMemStorage storage, 
        int method, double parameter) -> CvSeq_CvPoint
    """
  return _cv.cvApproxPoly(*args)

def cvConvexHull2(*args):
  """
    cvConvexHull2(CvArr points, int orientation = CV_CLOCKWISE, int return_points = 0) -> CvMat
    cvConvexHull2(CvArr points, int orientation = CV_CLOCKWISE) -> CvMat
    cvConvexHull2(CvArr points) -> CvMat
    """
  return _cv.cvConvexHull2(*args)

def cvSnakeImage(*args):
  """
    cvSnakeImage(CvMat image, CvPointVector points, FloatVector alpha, 
        FloatVector beta, FloatVector gamma, CvSize win, 
        CvTermCriteria criteria, int calc_gradient = 1) -> CvPointVector
    cvSnakeImage(CvMat image, CvPointVector points, FloatVector alpha, 
        FloatVector beta, FloatVector gamma, CvSize win, 
        CvTermCriteria criteria) -> CvPointVector
    """
  return _cv.cvSnakeImage(*args)

class Cv64suf(_object):
    """Proxy of C++ Cv64suf class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cv64suf, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Cv64suf, name)
    __repr__ = _swig_repr
    __swig_setmethods__["i"] = _cv.Cv64suf_i_set
    __swig_getmethods__["i"] = _cv.Cv64suf_i_get
    if _newclass:i = _swig_property(_cv.Cv64suf_i_get, _cv.Cv64suf_i_set)
    __swig_setmethods__["u"] = _cv.Cv64suf_u_set
    __swig_getmethods__["u"] = _cv.Cv64suf_u_get
    if _newclass:u = _swig_property(_cv.Cv64suf_u_get, _cv.Cv64suf_u_set)
    __swig_setmethods__["f"] = _cv.Cv64suf_f_set
    __swig_getmethods__["f"] = _cv.Cv64suf_f_get
    if _newclass:f = _swig_property(_cv.Cv64suf_f_get, _cv.Cv64suf_f_set)
    def __init__(self): 
        """__init__(self) -> Cv64suf"""
        this = _cv.new_Cv64suf()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_Cv64suf
    __del__ = lambda self : None;
Cv64suf_swigregister = _cv.Cv64suf_swigregister
Cv64suf_swigregister(Cv64suf)


def cvRound(*args):
  """cvRound(double value) -> int"""
  return _cv.cvRound(*args)

def cvFloor(*args):
  """cvFloor(double value) -> int"""
  return _cv.cvFloor(*args)

def cvCeil(*args):
  """cvCeil(double value) -> int"""
  return _cv.cvCeil(*args)

def cvIsNaN(*args):
  """cvIsNaN(double value) -> int"""
  return _cv.cvIsNaN(*args)

def cvIsInf(*args):
  """cvIsInf(double value) -> int"""
  return _cv.cvIsInf(*args)

def cvRandInt(*args):
  """cvRandInt(CvRNG rng) -> unsigned int"""
  return _cv.cvRandInt(*args)

def cvRandReal(*args):
  """cvRandReal(CvRNG rng) -> double"""
  return _cv.cvRandReal(*args)
class IplImage(_object):
    """Proxy of C++ IplImage class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IplImage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IplImage, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["ID"] = _cv.IplImage_ID_set
    __swig_getmethods__["ID"] = _cv.IplImage_ID_get
    if _newclass:ID = _swig_property(_cv.IplImage_ID_get, _cv.IplImage_ID_set)
    __swig_setmethods__["nChannels"] = _cv.IplImage_nChannels_set
    __swig_getmethods__["nChannels"] = _cv.IplImage_nChannels_get
    if _newclass:nChannels = _swig_property(_cv.IplImage_nChannels_get, _cv.IplImage_nChannels_set)
    __swig_setmethods__["depth"] = _cv.IplImage_depth_set
    __swig_getmethods__["depth"] = _cv.IplImage_depth_get
    if _newclass:depth = _swig_property(_cv.IplImage_depth_get, _cv.IplImage_depth_set)
    __swig_setmethods__["dataOrder"] = _cv.IplImage_dataOrder_set
    __swig_getmethods__["dataOrder"] = _cv.IplImage_dataOrder_get
    if _newclass:dataOrder = _swig_property(_cv.IplImage_dataOrder_get, _cv.IplImage_dataOrder_set)
    __swig_setmethods__["origin"] = _cv.IplImage_origin_set
    __swig_getmethods__["origin"] = _cv.IplImage_origin_get
    if _newclass:origin = _swig_property(_cv.IplImage_origin_get, _cv.IplImage_origin_set)
    __swig_setmethods__["align"] = _cv.IplImage_align_set
    __swig_getmethods__["align"] = _cv.IplImage_align_get
    if _newclass:align = _swig_property(_cv.IplImage_align_get, _cv.IplImage_align_set)
    __swig_setmethods__["width"] = _cv.IplImage_width_set
    __swig_getmethods__["width"] = _cv.IplImage_width_get
    if _newclass:width = _swig_property(_cv.IplImage_width_get, _cv.IplImage_width_set)
    __swig_setmethods__["height"] = _cv.IplImage_height_set
    __swig_getmethods__["height"] = _cv.IplImage_height_get
    if _newclass:height = _swig_property(_cv.IplImage_height_get, _cv.IplImage_height_set)
    __swig_setmethods__["roi"] = _cv.IplImage_roi_set
    __swig_getmethods__["roi"] = _cv.IplImage_roi_get
    if _newclass:roi = _swig_property(_cv.IplImage_roi_get, _cv.IplImage_roi_set)
    __swig_setmethods__["imageSize"] = _cv.IplImage_imageSize_set
    __swig_getmethods__["imageSize"] = _cv.IplImage_imageSize_get
    if _newclass:imageSize = _swig_property(_cv.IplImage_imageSize_get, _cv.IplImage_imageSize_set)
    __swig_setmethods__["widthStep"] = _cv.IplImage_widthStep_set
    __swig_getmethods__["widthStep"] = _cv.IplImage_widthStep_get
    if _newclass:widthStep = _swig_property(_cv.IplImage_widthStep_get, _cv.IplImage_widthStep_set)
    __swig_destroy__ = _cv.delete_IplImage
    __del__ = lambda self : None;
    def __add__(self, *args):
        """
        __add__(self, CvArr src)
        __add__(self, CvScalar val)
        """
        return _cv.IplImage___add__(self, *args)

    def __iadd__(self, *args):
        """
        __iadd__(self, CvArr src)
        __iadd__(self, CvScalar val)
        """
        return _cv.IplImage___iadd__(self, *args)

    def __xor__(self, *args):
        """
        __xor__(self, CvArr src)
        __xor__(self, CvScalar val)
        """
        return _cv.IplImage___xor__(self, *args)

    def __ixor__(self, *args):
        """
        __ixor__(self, CvArr src)
        __ixor__(self, CvScalar val)
        """
        return _cv.IplImage___ixor__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(self, CvArr src)
        __sub__(self, CvScalar val)
        """
        return _cv.IplImage___sub__(self, *args)

    def __isub__(self, *args):
        """
        __isub__(self, CvArr src)
        __isub__(self, CvScalar val)
        """
        return _cv.IplImage___isub__(self, *args)

    def __or__(self, *args):
        """
        __or__(self, CvArr src)
        __or__(self, CvScalar val)
        """
        return _cv.IplImage___or__(self, *args)

    def __ior__(self, *args):
        """
        __ior__(self, CvArr src)
        __ior__(self, CvScalar val)
        """
        return _cv.IplImage___ior__(self, *args)

    def __and__(self, *args):
        """
        __and__(self, CvArr src)
        __and__(self, CvScalar val)
        """
        return _cv.IplImage___and__(self, *args)

    def __iand__(self, *args):
        """
        __iand__(self, CvArr src)
        __iand__(self, CvScalar val)
        """
        return _cv.IplImage___iand__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, CvArr src)
        __ge__(self, double val)
        """
        return _cv.IplImage___ge__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, CvArr src)
        __eq__(self, double val)
        """
        return _cv.IplImage___eq__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, CvArr src)
        __le__(self, double val)
        """
        return _cv.IplImage___le__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, CvArr src)
        __ne__(self, double val)
        """
        return _cv.IplImage___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, CvArr src)
        __lt__(self, double val)
        """
        return _cv.IplImage___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, CvArr src)
        __gt__(self, double val)
        """
        return _cv.IplImage___gt__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(self, CvArr src)
        __mul__(self, double val)
        """
        return _cv.IplImage___mul__(self, *args)

    def __imul__(self, *args):
        """
        __imul__(self, CvArr src)
        __imul__(self, double val)
        """
        return _cv.IplImage___imul__(self, *args)

    def __div__(self, *args):
        """
        __div__(self, CvArr src)
        __div__(self, double val)
        """
        return _cv.IplImage___div__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, CvArr src)
        __idiv__(self, double val)
        """
        return _cv.IplImage___idiv__(self, *args)

    def __rdiv__(self, *args):
        """__rdiv__(self, CvArr arg)"""
        return _cv.IplImage___rdiv__(self, *args)

    def __radd__(self, *args):
        """
        __radd__(self, CvArr arg)
        __radd__(self, CvScalar arg)
        __radd__(self, double arg)
        """
        return _cv.IplImage___radd__(self, *args)

    def __rsub__(self, *args):
        """
        __rsub__(self, CvArr arg)
        __rsub__(self, CvScalar arg)
        __rsub__(self, double arg)
        """
        return _cv.IplImage___rsub__(self, *args)

    def __rmul__(self, *args):
        """
        __rmul__(self, CvArr arg)
        __rmul__(self, double arg)
        """
        return _cv.IplImage___rmul__(self, *args)

    def __ror__(self, *args):
        """
        __ror__(self, CvScalar arg)
        __ror__(self, double arg)
        """
        return _cv.IplImage___ror__(self, *args)

    def __rand__(self, *args):
        """
        __rand__(self, CvScalar arg)
        __rand__(self, double arg)
        """
        return _cv.IplImage___rand__(self, *args)

    def __rxor__(self, *args):
        """
        __rxor__(self, CvScalar arg)
        __rxor__(self, double arg)
        """
        return _cv.IplImage___rxor__(self, *args)

    def __req__(self, *args):
        """__req__(self, double arg)"""
        return _cv.IplImage___req__(self, *args)

    def __rgt__(self, *args):
        """__rgt__(self, double arg)"""
        return _cv.IplImage___rgt__(self, *args)

    def __rge__(self, *args):
        """__rge__(self, double arg)"""
        return _cv.IplImage___rge__(self, *args)

    def __rlt__(self, *args):
        """__rlt__(self, double arg)"""
        return _cv.IplImage___rlt__(self, *args)

    def __rle__(self, *args):
        """__rle__(self, double arg)"""
        return _cv.IplImage___rle__(self, *args)

    def __rne__(self, *args):
        """__rne__(self, double arg)"""
        return _cv.IplImage___rne__(self, *args)

    def __pow__(self, *args):
        """__pow__(self, double arg)"""
        return _cv.IplImage___pow__(self, *args)

    def __str__(self):
        """__str__(self) -> char"""
        return _cv.IplImage___str__(self)

    def __setitem__(self, *args):
        """
        __setitem__(self, PyObject object, double val)
        __setitem__(self, PyObject object, CvPoint val)
        __setitem__(self, PyObject object, CvPoint2D32f val)
        __setitem__(self, PyObject object, CvScalar val)
        __setitem__(self, PyObject object, CvArr arr)
        """
        return _cv.IplImage___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, PyObject object) -> PyObject"""
        return _cv.IplImage___getitem__(self, *args)

IplImage_swigregister = _cv.IplImage_swigregister
IplImage_swigregister(IplImage)

def cvRNG(*args):
  """
    cvRNG(int64 seed = -1) -> CvRNG
    cvRNG() -> CvRNG
    """
  return _cv.cvRNG(*args)

class IplROI(_object):
    """Proxy of C++ IplROI class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IplROI, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IplROI, name)
    __repr__ = _swig_repr
    __swig_setmethods__["coi"] = _cv.IplROI_coi_set
    __swig_getmethods__["coi"] = _cv.IplROI_coi_get
    if _newclass:coi = _swig_property(_cv.IplROI_coi_get, _cv.IplROI_coi_set)
    __swig_setmethods__["xOffset"] = _cv.IplROI_xOffset_set
    __swig_getmethods__["xOffset"] = _cv.IplROI_xOffset_get
    if _newclass:xOffset = _swig_property(_cv.IplROI_xOffset_get, _cv.IplROI_xOffset_set)
    __swig_setmethods__["yOffset"] = _cv.IplROI_yOffset_set
    __swig_getmethods__["yOffset"] = _cv.IplROI_yOffset_get
    if _newclass:yOffset = _swig_property(_cv.IplROI_yOffset_get, _cv.IplROI_yOffset_set)
    __swig_setmethods__["width"] = _cv.IplROI_width_set
    __swig_getmethods__["width"] = _cv.IplROI_width_get
    if _newclass:width = _swig_property(_cv.IplROI_width_get, _cv.IplROI_width_set)
    __swig_setmethods__["height"] = _cv.IplROI_height_set
    __swig_getmethods__["height"] = _cv.IplROI_height_get
    if _newclass:height = _swig_property(_cv.IplROI_height_get, _cv.IplROI_height_set)
    def __init__(self): 
        """__init__(self) -> IplROI"""
        this = _cv.new_IplROI()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_IplROI
    __del__ = lambda self : None;
IplROI_swigregister = _cv.IplROI_swigregister
IplROI_swigregister(IplROI)

class IplConvKernel(_object):
    """Proxy of C++ IplConvKernel class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IplConvKernel, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IplConvKernel, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["nCols"] = _cv.IplConvKernel_nCols_set
    __swig_getmethods__["nCols"] = _cv.IplConvKernel_nCols_get
    if _newclass:nCols = _swig_property(_cv.IplConvKernel_nCols_get, _cv.IplConvKernel_nCols_set)
    __swig_setmethods__["nRows"] = _cv.IplConvKernel_nRows_set
    __swig_getmethods__["nRows"] = _cv.IplConvKernel_nRows_get
    if _newclass:nRows = _swig_property(_cv.IplConvKernel_nRows_get, _cv.IplConvKernel_nRows_set)
    __swig_setmethods__["anchorX"] = _cv.IplConvKernel_anchorX_set
    __swig_getmethods__["anchorX"] = _cv.IplConvKernel_anchorX_get
    if _newclass:anchorX = _swig_property(_cv.IplConvKernel_anchorX_get, _cv.IplConvKernel_anchorX_set)
    __swig_setmethods__["anchorY"] = _cv.IplConvKernel_anchorY_set
    __swig_getmethods__["anchorY"] = _cv.IplConvKernel_anchorY_get
    if _newclass:anchorY = _swig_property(_cv.IplConvKernel_anchorY_get, _cv.IplConvKernel_anchorY_set)
    __swig_setmethods__["values"] = _cv.IplConvKernel_values_set
    __swig_getmethods__["values"] = _cv.IplConvKernel_values_get
    if _newclass:values = _swig_property(_cv.IplConvKernel_values_get, _cv.IplConvKernel_values_set)
    __swig_setmethods__["nShiftR"] = _cv.IplConvKernel_nShiftR_set
    __swig_getmethods__["nShiftR"] = _cv.IplConvKernel_nShiftR_get
    if _newclass:nShiftR = _swig_property(_cv.IplConvKernel_nShiftR_get, _cv.IplConvKernel_nShiftR_set)
    __swig_destroy__ = _cv.delete_IplConvKernel
    __del__ = lambda self : None;
IplConvKernel_swigregister = _cv.IplConvKernel_swigregister
IplConvKernel_swigregister(IplConvKernel)

class IplConvKernelFP(_object):
    """Proxy of C++ IplConvKernelFP class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IplConvKernelFP, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IplConvKernelFP, name)
    __repr__ = _swig_repr
    __swig_setmethods__["nCols"] = _cv.IplConvKernelFP_nCols_set
    __swig_getmethods__["nCols"] = _cv.IplConvKernelFP_nCols_get
    if _newclass:nCols = _swig_property(_cv.IplConvKernelFP_nCols_get, _cv.IplConvKernelFP_nCols_set)
    __swig_setmethods__["nRows"] = _cv.IplConvKernelFP_nRows_set
    __swig_getmethods__["nRows"] = _cv.IplConvKernelFP_nRows_get
    if _newclass:nRows = _swig_property(_cv.IplConvKernelFP_nRows_get, _cv.IplConvKernelFP_nRows_set)
    __swig_setmethods__["anchorX"] = _cv.IplConvKernelFP_anchorX_set
    __swig_getmethods__["anchorX"] = _cv.IplConvKernelFP_anchorX_get
    if _newclass:anchorX = _swig_property(_cv.IplConvKernelFP_anchorX_get, _cv.IplConvKernelFP_anchorX_set)
    __swig_setmethods__["anchorY"] = _cv.IplConvKernelFP_anchorY_set
    __swig_getmethods__["anchorY"] = _cv.IplConvKernelFP_anchorY_get
    if _newclass:anchorY = _swig_property(_cv.IplConvKernelFP_anchorY_get, _cv.IplConvKernelFP_anchorY_set)
    __swig_setmethods__["values"] = _cv.IplConvKernelFP_values_set
    __swig_getmethods__["values"] = _cv.IplConvKernelFP_values_get
    if _newclass:values = _swig_property(_cv.IplConvKernelFP_values_get, _cv.IplConvKernelFP_values_set)
    def __init__(self): 
        """__init__(self) -> IplConvKernelFP"""
        this = _cv.new_IplConvKernelFP()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_IplConvKernelFP
    __del__ = lambda self : None;
IplConvKernelFP_swigregister = _cv.IplConvKernelFP_swigregister
IplConvKernelFP_swigregister(IplConvKernelFP)

class CvMat(_object):
    """Proxy of C++ CvMat class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvMat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvMat, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _cv.CvMat_type_set
    __swig_getmethods__["type"] = _cv.CvMat_type_get
    if _newclass:type = _swig_property(_cv.CvMat_type_get, _cv.CvMat_type_set)
    __swig_setmethods__["step"] = _cv.CvMat_step_set
    __swig_getmethods__["step"] = _cv.CvMat_step_get
    if _newclass:step = _swig_property(_cv.CvMat_step_get, _cv.CvMat_step_set)
    __swig_setmethods__["refcount"] = _cv.CvMat_refcount_set
    __swig_getmethods__["refcount"] = _cv.CvMat_refcount_get
    if _newclass:refcount = _swig_property(_cv.CvMat_refcount_get, _cv.CvMat_refcount_set)
    __swig_setmethods__["hdr_refcount"] = _cv.CvMat_hdr_refcount_set
    __swig_getmethods__["hdr_refcount"] = _cv.CvMat_hdr_refcount_get
    if _newclass:hdr_refcount = _swig_property(_cv.CvMat_hdr_refcount_get, _cv.CvMat_hdr_refcount_set)
    __swig_getmethods__["data"] = _cv.CvMat_data_get
    if _newclass:data = _swig_property(_cv.CvMat_data_get)
    __swig_destroy__ = _cv.delete_CvMat
    __del__ = lambda self : None;
    __swig_setmethods__["depth"] = _cv.CvMat_depth_set
    __swig_getmethods__["depth"] = _cv.CvMat_depth_get
    if _newclass:depth = _swig_property(_cv.CvMat_depth_get, _cv.CvMat_depth_set)
    __swig_setmethods__["nChannels"] = _cv.CvMat_nChannels_set
    __swig_getmethods__["nChannels"] = _cv.CvMat_nChannels_get
    if _newclass:nChannels = _swig_property(_cv.CvMat_nChannels_get, _cv.CvMat_nChannels_set)
    __swig_setmethods__["dataOrder"] = _cv.CvMat_dataOrder_set
    __swig_getmethods__["dataOrder"] = _cv.CvMat_dataOrder_get
    if _newclass:dataOrder = _swig_property(_cv.CvMat_dataOrder_get, _cv.CvMat_dataOrder_set)
    __swig_setmethods__["origin"] = _cv.CvMat_origin_set
    __swig_getmethods__["origin"] = _cv.CvMat_origin_get
    if _newclass:origin = _swig_property(_cv.CvMat_origin_get, _cv.CvMat_origin_set)
    __swig_setmethods__["width"] = _cv.CvMat_width_set
    __swig_getmethods__["width"] = _cv.CvMat_width_get
    if _newclass:width = _swig_property(_cv.CvMat_width_get, _cv.CvMat_width_set)
    __swig_setmethods__["height"] = _cv.CvMat_height_set
    __swig_getmethods__["height"] = _cv.CvMat_height_get
    if _newclass:height = _swig_property(_cv.CvMat_height_get, _cv.CvMat_height_set)
    __swig_setmethods__["imageSize"] = _cv.CvMat_imageSize_set
    __swig_getmethods__["imageSize"] = _cv.CvMat_imageSize_get
    if _newclass:imageSize = _swig_property(_cv.CvMat_imageSize_get, _cv.CvMat_imageSize_set)
    __swig_setmethods__["widthStep"] = _cv.CvMat_widthStep_set
    __swig_getmethods__["widthStep"] = _cv.CvMat_widthStep_get
    if _newclass:widthStep = _swig_property(_cv.CvMat_widthStep_get, _cv.CvMat_widthStep_set)
    __swig_setmethods__["rows"] = _cv.CvMat_rows_set
    __swig_getmethods__["rows"] = _cv.CvMat_rows_get
    if _newclass:rows = _swig_property(_cv.CvMat_rows_get, _cv.CvMat_rows_set)
    __swig_setmethods__["cols"] = _cv.CvMat_cols_set
    __swig_getmethods__["cols"] = _cv.CvMat_cols_get
    if _newclass:cols = _swig_property(_cv.CvMat_cols_get, _cv.CvMat_cols_set)
    def __add__(self, *args):
        """
        __add__(self, CvArr src) -> CvMat
        __add__(self, CvScalar val) -> CvMat
        """
        return _cv.CvMat___add__(self, *args)

    def __iadd__(self, *args):
        """
        __iadd__(self, CvArr src) -> CvMat
        __iadd__(self, CvScalar val) -> CvMat
        """
        return _cv.CvMat___iadd__(self, *args)

    def __xor__(self, *args):
        """
        __xor__(self, CvArr src) -> CvMat
        __xor__(self, CvScalar val) -> CvMat
        """
        return _cv.CvMat___xor__(self, *args)

    def __ixor__(self, *args):
        """
        __ixor__(self, CvArr src) -> CvMat
        __ixor__(self, CvScalar val) -> CvMat
        """
        return _cv.CvMat___ixor__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(self, CvArr src) -> CvMat
        __sub__(self, CvScalar val) -> CvMat
        """
        return _cv.CvMat___sub__(self, *args)

    def __isub__(self, *args):
        """
        __isub__(self, CvArr src) -> CvMat
        __isub__(self, CvScalar val) -> CvMat
        """
        return _cv.CvMat___isub__(self, *args)

    def __or__(self, *args):
        """
        __or__(self, CvArr src) -> CvMat
        __or__(self, CvScalar val) -> CvMat
        """
        return _cv.CvMat___or__(self, *args)

    def __ior__(self, *args):
        """
        __ior__(self, CvArr src) -> CvMat
        __ior__(self, CvScalar val) -> CvMat
        """
        return _cv.CvMat___ior__(self, *args)

    def __and__(self, *args):
        """
        __and__(self, CvArr src) -> CvMat
        __and__(self, CvScalar val) -> CvMat
        """
        return _cv.CvMat___and__(self, *args)

    def __iand__(self, *args):
        """
        __iand__(self, CvArr src) -> CvMat
        __iand__(self, CvScalar val) -> CvMat
        """
        return _cv.CvMat___iand__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(self, CvArr src) -> CvMat
        __ge__(self, double val) -> CvMat
        """
        return _cv.CvMat___ge__(self, *args)

    def __eq__(self, *args):
        """
        __eq__(self, CvArr src) -> CvMat
        __eq__(self, double val) -> CvMat
        """
        return _cv.CvMat___eq__(self, *args)

    def __le__(self, *args):
        """
        __le__(self, CvArr src) -> CvMat
        __le__(self, double val) -> CvMat
        """
        return _cv.CvMat___le__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(self, CvArr src) -> CvMat
        __ne__(self, double val) -> CvMat
        """
        return _cv.CvMat___ne__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(self, CvArr src) -> CvMat
        __lt__(self, double val) -> CvMat
        """
        return _cv.CvMat___lt__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(self, CvArr src) -> CvMat
        __gt__(self, double val) -> CvMat
        """
        return _cv.CvMat___gt__(self, *args)

    def __mul__(self, *args):
        """
        __mul__(self, CvArr src) -> CvMat
        __mul__(self, double val) -> CvMat
        """
        return _cv.CvMat___mul__(self, *args)

    def __imul__(self, *args):
        """
        __imul__(self, CvArr src) -> CvMat
        __imul__(self, double val) -> CvMat
        """
        return _cv.CvMat___imul__(self, *args)

    def __div__(self, *args):
        """
        __div__(self, CvArr src) -> CvMat
        __div__(self, double val) -> CvMat
        """
        return _cv.CvMat___div__(self, *args)

    def __idiv__(self, *args):
        """
        __idiv__(self, CvArr src) -> CvMat
        __idiv__(self, double val) -> CvMat
        """
        return _cv.CvMat___idiv__(self, *args)

    def __radd__(self, *args):
        """
        __radd__(self, CvArr arg) -> CvMat
        __radd__(self, CvScalar arg) -> CvMat
        __radd__(self, double arg) -> CvMat
        """
        return _cv.CvMat___radd__(self, *args)

    def __rsub__(self, *args):
        """
        __rsub__(self, CvArr arg) -> CvMat
        __rsub__(self, CvScalar arg) -> CvMat
        __rsub__(self, double arg) -> CvMat
        """
        return _cv.CvMat___rsub__(self, *args)

    def __rmul__(self, *args):
        """
        __rmul__(self, CvArr arg) -> CvMat
        __rmul__(self, double arg) -> CvMat
        """
        return _cv.CvMat___rmul__(self, *args)

    def __ror__(self, *args):
        """
        __ror__(self, CvScalar arg) -> CvMat
        __ror__(self, double arg) -> CvMat
        """
        return _cv.CvMat___ror__(self, *args)

    def __rand__(self, *args):
        """
        __rand__(self, CvScalar arg) -> CvMat
        __rand__(self, double arg) -> CvMat
        """
        return _cv.CvMat___rand__(self, *args)

    def __rxor__(self, *args):
        """
        __rxor__(self, CvScalar arg) -> CvMat
        __rxor__(self, double arg) -> CvMat
        """
        return _cv.CvMat___rxor__(self, *args)

    def __req__(self, *args):
        """__req__(self, double arg) -> CvMat"""
        return _cv.CvMat___req__(self, *args)

    def __rgt__(self, *args):
        """__rgt__(self, double arg) -> CvMat"""
        return _cv.CvMat___rgt__(self, *args)

    def __rge__(self, *args):
        """__rge__(self, double arg) -> CvMat"""
        return _cv.CvMat___rge__(self, *args)

    def __rlt__(self, *args):
        """__rlt__(self, double arg) -> CvMat"""
        return _cv.CvMat___rlt__(self, *args)

    def __rle__(self, *args):
        """__rle__(self, double arg) -> CvMat"""
        return _cv.CvMat___rle__(self, *args)

    def __rne__(self, *args):
        """__rne__(self, double arg) -> CvMat"""
        return _cv.CvMat___rne__(self, *args)

    def __rdiv__(self, *args):
        """
        __rdiv__(self, CvArr arg) -> CvMat
        __rdiv__(self, double arg) -> CvMat
        """
        return _cv.CvMat___rdiv__(self, *args)

    def __pow__(self, *args):
        """__pow__(self, double arg) -> CvMat"""
        return _cv.CvMat___pow__(self, *args)

    def __str__(self):
        """__str__(self) -> char"""
        return _cv.CvMat___str__(self)

    def __setitem__(self, *args):
        """
        __setitem__(self, PyObject object, double val)
        __setitem__(self, PyObject object, CvPoint val)
        __setitem__(self, PyObject object, CvPoint2D32f val)
        __setitem__(self, PyObject object, CvScalar val)
        __setitem__(self, PyObject object, CvArr arr)
        """
        return _cv.CvMat___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, PyObject object) -> PyObject"""
        return _cv.CvMat___getitem__(self, *args)

    def __invert__(self):
        """__invert__(self) -> CvMat"""
        return _cv.CvMat___invert__(self)

    def __iter__(self):
       	"""
       	generator function iterating through rows in matrix or elements in vector
       	"""
    	if self.rows==1:
    		return self.colrange()
    	return self.rowrange()

    def rowrange(self):
        """
        generator function iterating along rows in matrix
        """
    	for i in range(self.rows):
    		yield self[i]

    def colrange(self):
        """
        generator function iterating along columns in matrix
        """
    	for i in range(self.cols):
    		yield self[:,i]

    # if arg is None, python still calls our operator overloads
    # but we want
    # if mat != None
    # if mat == None
    # to do the right thing -- so redefine __ne__ and __eq__

    def __eq__(self, arg):
        """
    	__eq__(self, None)
    	__eq__(self, CvArr src)
    	__eq__(self, double val)
        """

    	if not arg:
    		return False 
    	return _cv.CvMat___eq__(self, arg)
    def __ne__(self, arg):
        """
    	__ne__(self, None)
    	__ne__(self, CvArr src)
    	__ne__(self, double val)
        """

    	if not arg:
    		return True
    	return _cv.CvMat___ne__(self, arg)

    def __get_array_interface__ (self):
      """Compose numpy array interface
      
      Via the numpy array interface, OpenCV data structures can be directly passed to numpy
      methods without copying / converting. This tremendously speeds up mixing code from
      OpenCV and numpy.
      
      See: http://numpy.scipy.org/array_interface.shtml
      
      @author Mark Asbach <asbach@ient.rwth-aachen.de>
      @date   2009-01-07
      """
      
      if   self.depth == IPL_DEPTH_8U:
        typestr = '|u1'
        bytes_per_pixel = 1
      elif self.depth == IPL_DEPTH_8S:
        typestr = '|i1'
        bytes_per_pixel = 1
      elif self.depth == IPL_DEPTH_16U:
        typestr = '|u2'
        bytes_per_pixel = 2
      elif self.depth == IPL_DEPTH_16S:
        typestr = '|i2'
        bytes_per_pixel = 2
      elif self.depth == IPL_DEPTH_32S:
        typestr = '|i4'
        bytes_per_pixel = 4
      elif self.depth == IPL_DEPTH_32F:
        typestr = '|f4'
        bytes_per_pixel = 4
      elif self.depth == IPL_DEPTH_64F:
        typestr = '|f8'
        bytes_per_pixel = 8
      else:
        raise TypeError("unknown resp. unhandled OpenCV image/matrix format")
      
      if self.nChannels == 1:
        # monochrome image, matrix with a single channel
        return {'shape':  (self.height, self.width), 
               'typestr': typestr, 
               'version': 3,
               
               'data':    (int (self.data.ptr), False),
               'strides': (int (self.widthStep), int (bytes_per_pixel))}
      else:
        # color image, image with alpha, matrix with multiple channels
        return {'shape':  (self.height, self.width, self.nChannels), 
               'typestr': typestr, 
               'version': 3,
               
               'data':    (int (self.data.ptr), False),
               'strides': (int (self.widthStep), int (self.nChannels * bytes_per_pixel), int (bytes_per_pixel))}

    __array_interface__ = property (__get_array_interface__, doc = "numpy array interface description")


    __swig_setmethods__["imageData"] = _cv.CvMat_imageData_set
    __swig_getmethods__["imageData"] = _cv.CvMat_imageData_get
    if _newclass:imageData = _swig_property(_cv.CvMat_imageData_get, _cv.CvMat_imageData_set)
CvMat_swigregister = _cv.CvMat_swigregister
CvMat_swigregister(CvMat)

class CvMat_data(_object):
    """Proxy of C++ CvMat_data class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvMat_data, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvMat_data, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ptr"] = _cv.CvMat_data_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvMat_data_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvMat_data_ptr_get, _cv.CvMat_data_ptr_set)
    __swig_setmethods__["s"] = _cv.CvMat_data_s_set
    __swig_getmethods__["s"] = _cv.CvMat_data_s_get
    if _newclass:s = _swig_property(_cv.CvMat_data_s_get, _cv.CvMat_data_s_set)
    __swig_setmethods__["i"] = _cv.CvMat_data_i_set
    __swig_getmethods__["i"] = _cv.CvMat_data_i_get
    if _newclass:i = _swig_property(_cv.CvMat_data_i_get, _cv.CvMat_data_i_set)
    __swig_setmethods__["fl"] = _cv.CvMat_data_fl_set
    __swig_getmethods__["fl"] = _cv.CvMat_data_fl_get
    if _newclass:fl = _swig_property(_cv.CvMat_data_fl_get, _cv.CvMat_data_fl_set)
    __swig_setmethods__["db"] = _cv.CvMat_data_db_set
    __swig_getmethods__["db"] = _cv.CvMat_data_db_get
    if _newclass:db = _swig_property(_cv.CvMat_data_db_get, _cv.CvMat_data_db_set)
    def __init__(self): 
        """__init__(self) -> CvMat_data"""
        this = _cv.new_CvMat_data()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvMat_data
    __del__ = lambda self : None;
CvMat_data_swigregister = _cv.CvMat_data_swigregister
CvMat_data_swigregister(CvMat_data)


def cvmGet(*args):
  """cvmGet(CvMat mat, int row, int col) -> double"""
  return _cv.cvmGet(*args)

def cvmSet(*args):
  """cvmSet(CvMat mat, int row, int col, double value)"""
  return _cv.cvmSet(*args)

def cvIplDepth(*args):
  """cvIplDepth(int type) -> int"""
  return _cv.cvIplDepth(*args)
class CvMatND(_object):
    """Proxy of C++ CvMatND class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvMatND, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvMatND, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _cv.CvMatND_type_set
    __swig_getmethods__["type"] = _cv.CvMatND_type_get
    if _newclass:type = _swig_property(_cv.CvMatND_type_get, _cv.CvMatND_type_set)
    __swig_setmethods__["dims"] = _cv.CvMatND_dims_set
    __swig_getmethods__["dims"] = _cv.CvMatND_dims_get
    if _newclass:dims = _swig_property(_cv.CvMatND_dims_get, _cv.CvMatND_dims_set)
    __swig_setmethods__["refcount"] = _cv.CvMatND_refcount_set
    __swig_getmethods__["refcount"] = _cv.CvMatND_refcount_get
    if _newclass:refcount = _swig_property(_cv.CvMatND_refcount_get, _cv.CvMatND_refcount_set)
    __swig_setmethods__["hdr_refcount"] = _cv.CvMatND_hdr_refcount_set
    __swig_getmethods__["hdr_refcount"] = _cv.CvMatND_hdr_refcount_get
    if _newclass:hdr_refcount = _swig_property(_cv.CvMatND_hdr_refcount_get, _cv.CvMatND_hdr_refcount_set)
    __swig_getmethods__["dim"] = _cv.CvMatND_dim_get
    if _newclass:dim = _swig_property(_cv.CvMatND_dim_get)
    __swig_getmethods__["data"] = _cv.CvMatND_data_get
    if _newclass:data = _swig_property(_cv.CvMatND_data_get)
    __swig_destroy__ = _cv.delete_CvMatND
    __del__ = lambda self : None;
CvMatND_swigregister = _cv.CvMatND_swigregister
CvMatND_swigregister(CvMatND)

def cvMat(*args):
  """
    cvMat(int rows, int cols, int type, void data = None) -> CvMat
    cvMat(int rows, int cols, int type) -> CvMat
    """
  return _cv.cvMat(*args)

class CvMatND_dim(_object):
    """Proxy of C++ CvMatND_dim class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvMatND_dim, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvMatND_dim, name)
    __repr__ = _swig_repr
    __swig_setmethods__["size"] = _cv.CvMatND_dim_size_set
    __swig_getmethods__["size"] = _cv.CvMatND_dim_size_get
    if _newclass:size = _swig_property(_cv.CvMatND_dim_size_get, _cv.CvMatND_dim_size_set)
    __swig_setmethods__["step"] = _cv.CvMatND_dim_step_set
    __swig_getmethods__["step"] = _cv.CvMatND_dim_step_get
    if _newclass:step = _swig_property(_cv.CvMatND_dim_step_get, _cv.CvMatND_dim_step_set)
    def __init__(self): 
        """__init__(self) -> CvMatND_dim"""
        this = _cv.new_CvMatND_dim()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvMatND_dim
    __del__ = lambda self : None;
CvMatND_dim_swigregister = _cv.CvMatND_dim_swigregister
CvMatND_dim_swigregister(CvMatND_dim)

class CvMatND_data(_object):
    """Proxy of C++ CvMatND_data class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvMatND_data, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvMatND_data, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ptr"] = _cv.CvMatND_data_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvMatND_data_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvMatND_data_ptr_get, _cv.CvMatND_data_ptr_set)
    __swig_setmethods__["fl"] = _cv.CvMatND_data_fl_set
    __swig_getmethods__["fl"] = _cv.CvMatND_data_fl_get
    if _newclass:fl = _swig_property(_cv.CvMatND_data_fl_get, _cv.CvMatND_data_fl_set)
    __swig_setmethods__["db"] = _cv.CvMatND_data_db_set
    __swig_getmethods__["db"] = _cv.CvMatND_data_db_get
    if _newclass:db = _swig_property(_cv.CvMatND_data_db_get, _cv.CvMatND_data_db_set)
    __swig_setmethods__["i"] = _cv.CvMatND_data_i_set
    __swig_getmethods__["i"] = _cv.CvMatND_data_i_get
    if _newclass:i = _swig_property(_cv.CvMatND_data_i_get, _cv.CvMatND_data_i_set)
    __swig_setmethods__["s"] = _cv.CvMatND_data_s_set
    __swig_getmethods__["s"] = _cv.CvMatND_data_s_get
    if _newclass:s = _swig_property(_cv.CvMatND_data_s_get, _cv.CvMatND_data_s_set)
    def __init__(self): 
        """__init__(self) -> CvMatND_data"""
        this = _cv.new_CvMatND_data()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvMatND_data
    __del__ = lambda self : None;
CvMatND_data_swigregister = _cv.CvMatND_data_swigregister
CvMatND_data_swigregister(CvMatND_data)

class CvSparseMat(_object):
    """Proxy of C++ CvSparseMat class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSparseMat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSparseMat, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _cv.CvSparseMat_type_set
    __swig_getmethods__["type"] = _cv.CvSparseMat_type_get
    if _newclass:type = _swig_property(_cv.CvSparseMat_type_get, _cv.CvSparseMat_type_set)
    __swig_setmethods__["dims"] = _cv.CvSparseMat_dims_set
    __swig_getmethods__["dims"] = _cv.CvSparseMat_dims_get
    if _newclass:dims = _swig_property(_cv.CvSparseMat_dims_get, _cv.CvSparseMat_dims_set)
    __swig_setmethods__["refcount"] = _cv.CvSparseMat_refcount_set
    __swig_getmethods__["refcount"] = _cv.CvSparseMat_refcount_get
    if _newclass:refcount = _swig_property(_cv.CvSparseMat_refcount_get, _cv.CvSparseMat_refcount_set)
    __swig_setmethods__["hdr_refcount"] = _cv.CvSparseMat_hdr_refcount_set
    __swig_getmethods__["hdr_refcount"] = _cv.CvSparseMat_hdr_refcount_get
    if _newclass:hdr_refcount = _swig_property(_cv.CvSparseMat_hdr_refcount_get, _cv.CvSparseMat_hdr_refcount_set)
    __swig_setmethods__["heap"] = _cv.CvSparseMat_heap_set
    __swig_getmethods__["heap"] = _cv.CvSparseMat_heap_get
    if _newclass:heap = _swig_property(_cv.CvSparseMat_heap_get, _cv.CvSparseMat_heap_set)
    __swig_setmethods__["hashtable"] = _cv.CvSparseMat_hashtable_set
    __swig_getmethods__["hashtable"] = _cv.CvSparseMat_hashtable_get
    if _newclass:hashtable = _swig_property(_cv.CvSparseMat_hashtable_get, _cv.CvSparseMat_hashtable_set)
    __swig_setmethods__["hashsize"] = _cv.CvSparseMat_hashsize_set
    __swig_getmethods__["hashsize"] = _cv.CvSparseMat_hashsize_get
    if _newclass:hashsize = _swig_property(_cv.CvSparseMat_hashsize_get, _cv.CvSparseMat_hashsize_set)
    __swig_setmethods__["valoffset"] = _cv.CvSparseMat_valoffset_set
    __swig_getmethods__["valoffset"] = _cv.CvSparseMat_valoffset_get
    if _newclass:valoffset = _swig_property(_cv.CvSparseMat_valoffset_get, _cv.CvSparseMat_valoffset_set)
    __swig_setmethods__["idxoffset"] = _cv.CvSparseMat_idxoffset_set
    __swig_getmethods__["idxoffset"] = _cv.CvSparseMat_idxoffset_get
    if _newclass:idxoffset = _swig_property(_cv.CvSparseMat_idxoffset_get, _cv.CvSparseMat_idxoffset_set)
    __swig_setmethods__["size"] = _cv.CvSparseMat_size_set
    __swig_getmethods__["size"] = _cv.CvSparseMat_size_get
    if _newclass:size = _swig_property(_cv.CvSparseMat_size_get, _cv.CvSparseMat_size_set)
    __swig_destroy__ = _cv.delete_CvSparseMat
    __del__ = lambda self : None;
CvSparseMat_swigregister = _cv.CvSparseMat_swigregister
CvSparseMat_swigregister(CvSparseMat)

class CvSparseNode(_object):
    """Proxy of C++ CvSparseNode class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSparseNode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSparseNode, name)
    __repr__ = _swig_repr
    __swig_setmethods__["hashval"] = _cv.CvSparseNode_hashval_set
    __swig_getmethods__["hashval"] = _cv.CvSparseNode_hashval_get
    if _newclass:hashval = _swig_property(_cv.CvSparseNode_hashval_get, _cv.CvSparseNode_hashval_set)
    __swig_setmethods__["next"] = _cv.CvSparseNode_next_set
    __swig_getmethods__["next"] = _cv.CvSparseNode_next_get
    if _newclass:next = _swig_property(_cv.CvSparseNode_next_get, _cv.CvSparseNode_next_set)
    def __init__(self): 
        """__init__(self) -> CvSparseNode"""
        this = _cv.new_CvSparseNode()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSparseNode
    __del__ = lambda self : None;
CvSparseNode_swigregister = _cv.CvSparseNode_swigregister
CvSparseNode_swigregister(CvSparseNode)

class CvSparseMatIterator(_object):
    """Proxy of C++ CvSparseMatIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSparseMatIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSparseMatIterator, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mat"] = _cv.CvSparseMatIterator_mat_set
    __swig_getmethods__["mat"] = _cv.CvSparseMatIterator_mat_get
    if _newclass:mat = _swig_property(_cv.CvSparseMatIterator_mat_get, _cv.CvSparseMatIterator_mat_set)
    __swig_setmethods__["node"] = _cv.CvSparseMatIterator_node_set
    __swig_getmethods__["node"] = _cv.CvSparseMatIterator_node_get
    if _newclass:node = _swig_property(_cv.CvSparseMatIterator_node_get, _cv.CvSparseMatIterator_node_set)
    __swig_setmethods__["curidx"] = _cv.CvSparseMatIterator_curidx_set
    __swig_getmethods__["curidx"] = _cv.CvSparseMatIterator_curidx_get
    if _newclass:curidx = _swig_property(_cv.CvSparseMatIterator_curidx_get, _cv.CvSparseMatIterator_curidx_set)
    def __init__(self): 
        """__init__(self) -> CvSparseMatIterator"""
        this = _cv.new_CvSparseMatIterator()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSparseMatIterator
    __del__ = lambda self : None;
CvSparseMatIterator_swigregister = _cv.CvSparseMatIterator_swigregister
CvSparseMatIterator_swigregister(CvSparseMatIterator)

class CvHistogram(_object):
    """Proxy of C++ CvHistogram class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvHistogram, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvHistogram, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _cv.CvHistogram_type_set
    __swig_getmethods__["type"] = _cv.CvHistogram_type_get
    if _newclass:type = _swig_property(_cv.CvHistogram_type_get, _cv.CvHistogram_type_set)
    __swig_setmethods__["bins"] = _cv.CvHistogram_bins_set
    __swig_getmethods__["bins"] = _cv.CvHistogram_bins_get
    if _newclass:bins = _swig_property(_cv.CvHistogram_bins_get, _cv.CvHistogram_bins_set)
    __swig_setmethods__["thresh"] = _cv.CvHistogram_thresh_set
    __swig_getmethods__["thresh"] = _cv.CvHistogram_thresh_get
    if _newclass:thresh = _swig_property(_cv.CvHistogram_thresh_get, _cv.CvHistogram_thresh_set)
    __swig_setmethods__["thresh2"] = _cv.CvHistogram_thresh2_set
    __swig_getmethods__["thresh2"] = _cv.CvHistogram_thresh2_get
    if _newclass:thresh2 = _swig_property(_cv.CvHistogram_thresh2_get, _cv.CvHistogram_thresh2_set)
    __swig_setmethods__["mat"] = _cv.CvHistogram_mat_set
    __swig_getmethods__["mat"] = _cv.CvHistogram_mat_get
    if _newclass:mat = _swig_property(_cv.CvHistogram_mat_get, _cv.CvHistogram_mat_set)
    __swig_destroy__ = _cv.delete_CvHistogram
    __del__ = lambda self : None;
CvHistogram_swigregister = _cv.CvHistogram_swigregister
CvHistogram_swigregister(CvHistogram)

class CvRect(_object):
    """Proxy of C++ CvRect class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvRect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvRect, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _cv.CvRect_x_set
    __swig_getmethods__["x"] = _cv.CvRect_x_get
    if _newclass:x = _swig_property(_cv.CvRect_x_get, _cv.CvRect_x_set)
    __swig_setmethods__["y"] = _cv.CvRect_y_set
    __swig_getmethods__["y"] = _cv.CvRect_y_get
    if _newclass:y = _swig_property(_cv.CvRect_y_get, _cv.CvRect_y_set)
    __swig_setmethods__["width"] = _cv.CvRect_width_set
    __swig_getmethods__["width"] = _cv.CvRect_width_get
    if _newclass:width = _swig_property(_cv.CvRect_width_get, _cv.CvRect_width_set)
    __swig_setmethods__["height"] = _cv.CvRect_height_set
    __swig_getmethods__["height"] = _cv.CvRect_height_get
    if _newclass:height = _swig_property(_cv.CvRect_height_get, _cv.CvRect_height_set)
    def __init__(self): 
        """__init__(self) -> CvRect"""
        this = _cv.new_CvRect()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvRect
    __del__ = lambda self : None;
CvRect_swigregister = _cv.CvRect_swigregister
CvRect_swigregister(CvRect)


def cvRect(*args):
  """cvRect(int x, int y, int width, int height) -> CvRect"""
  return _cv.cvRect(*args)

def cvRectToROI(*args):
  """cvRectToROI(CvRect rect, int coi)"""
  return _cv.cvRectToROI(*args)

def cvROIToRect(*args):
  """cvROIToRect( roi) -> CvRect"""
  return _cv.cvROIToRect(*args)
class CvTermCriteria(_object):
    """Proxy of C++ CvTermCriteria class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvTermCriteria, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvTermCriteria, name)
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _cv.CvTermCriteria_type_set
    __swig_getmethods__["type"] = _cv.CvTermCriteria_type_get
    if _newclass:type = _swig_property(_cv.CvTermCriteria_type_get, _cv.CvTermCriteria_type_set)
    __swig_setmethods__["max_iter"] = _cv.CvTermCriteria_max_iter_set
    __swig_getmethods__["max_iter"] = _cv.CvTermCriteria_max_iter_get
    if _newclass:max_iter = _swig_property(_cv.CvTermCriteria_max_iter_get, _cv.CvTermCriteria_max_iter_set)
    __swig_setmethods__["epsilon"] = _cv.CvTermCriteria_epsilon_set
    __swig_getmethods__["epsilon"] = _cv.CvTermCriteria_epsilon_get
    if _newclass:epsilon = _swig_property(_cv.CvTermCriteria_epsilon_get, _cv.CvTermCriteria_epsilon_set)
    def __init__(self): 
        """__init__(self) -> CvTermCriteria"""
        this = _cv.new_CvTermCriteria()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvTermCriteria
    __del__ = lambda self : None;
CvTermCriteria_swigregister = _cv.CvTermCriteria_swigregister
CvTermCriteria_swigregister(CvTermCriteria)


def cvTermCriteria(*args):
  """cvTermCriteria(int type, int max_iter, double epsilon) -> CvTermCriteria"""
  return _cv.cvTermCriteria(*args)
class CvPoint(_object):
    """Proxy of C++ CvPoint class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvPoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvPoint, name)
    __swig_setmethods__["x"] = _cv.CvPoint_x_set
    __swig_getmethods__["x"] = _cv.CvPoint_x_get
    if _newclass:x = _swig_property(_cv.CvPoint_x_get, _cv.CvPoint_x_set)
    __swig_setmethods__["y"] = _cv.CvPoint_y_set
    __swig_getmethods__["y"] = _cv.CvPoint_y_get
    if _newclass:y = _swig_property(_cv.CvPoint_y_get, _cv.CvPoint_y_set)
    def __str__(self):
        """__str__(self) -> char"""
        return _cv.CvPoint___str__(self)

    def __repr__(self):
        """__repr__(self) -> char"""
        return _cv.CvPoint___repr__(self)

    def __init__(self): 
        """__init__(self) -> CvPoint"""
        this = _cv.new_CvPoint()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvPoint
    __del__ = lambda self : None;
CvPoint_swigregister = _cv.CvPoint_swigregister
CvPoint_swigregister(CvPoint)


def cvPoint(*args):
  """cvPoint(int x, int y) -> CvPoint"""
  return _cv.cvPoint(*args)
class CvPoint2D32f(_object):
    """Proxy of C++ CvPoint2D32f class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvPoint2D32f, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvPoint2D32f, name)
    __swig_setmethods__["x"] = _cv.CvPoint2D32f_x_set
    __swig_getmethods__["x"] = _cv.CvPoint2D32f_x_get
    if _newclass:x = _swig_property(_cv.CvPoint2D32f_x_get, _cv.CvPoint2D32f_x_set)
    __swig_setmethods__["y"] = _cv.CvPoint2D32f_y_set
    __swig_getmethods__["y"] = _cv.CvPoint2D32f_y_get
    if _newclass:y = _swig_property(_cv.CvPoint2D32f_y_get, _cv.CvPoint2D32f_y_set)
    def __str__(self):
        """__str__(self) -> char"""
        return _cv.CvPoint2D32f___str__(self)

    def __repr__(self):
        """__repr__(self) -> char"""
        return _cv.CvPoint2D32f___repr__(self)

    def __init__(self): 
        """__init__(self) -> CvPoint2D32f"""
        this = _cv.new_CvPoint2D32f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvPoint2D32f
    __del__ = lambda self : None;
CvPoint2D32f_swigregister = _cv.CvPoint2D32f_swigregister
CvPoint2D32f_swigregister(CvPoint2D32f)


def cvPoint2D32f(*args):
  """cvPoint2D32f(double x, double y) -> CvPoint2D32f"""
  return _cv.cvPoint2D32f(*args)

def cvPointTo32f(*args):
  """cvPointTo32f(CvPoint point) -> CvPoint2D32f"""
  return _cv.cvPointTo32f(*args)

def cvPointFrom32f(*args):
  """cvPointFrom32f(CvPoint2D32f point) -> CvPoint"""
  return _cv.cvPointFrom32f(*args)
class CvPoint3D32f(_object):
    """Proxy of C++ CvPoint3D32f class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvPoint3D32f, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvPoint3D32f, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _cv.CvPoint3D32f_x_set
    __swig_getmethods__["x"] = _cv.CvPoint3D32f_x_get
    if _newclass:x = _swig_property(_cv.CvPoint3D32f_x_get, _cv.CvPoint3D32f_x_set)
    __swig_setmethods__["y"] = _cv.CvPoint3D32f_y_set
    __swig_getmethods__["y"] = _cv.CvPoint3D32f_y_get
    if _newclass:y = _swig_property(_cv.CvPoint3D32f_y_get, _cv.CvPoint3D32f_y_set)
    __swig_setmethods__["z"] = _cv.CvPoint3D32f_z_set
    __swig_getmethods__["z"] = _cv.CvPoint3D32f_z_get
    if _newclass:z = _swig_property(_cv.CvPoint3D32f_z_get, _cv.CvPoint3D32f_z_set)
    def __init__(self): 
        """__init__(self) -> CvPoint3D32f"""
        this = _cv.new_CvPoint3D32f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvPoint3D32f
    __del__ = lambda self : None;
CvPoint3D32f_swigregister = _cv.CvPoint3D32f_swigregister
CvPoint3D32f_swigregister(CvPoint3D32f)


def cvPoint3D32f(*args):
  """cvPoint3D32f(double x, double y, double z) -> CvPoint3D32f"""
  return _cv.cvPoint3D32f(*args)
class CvPoint2D64f(_object):
    """Proxy of C++ CvPoint2D64f class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvPoint2D64f, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvPoint2D64f, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _cv.CvPoint2D64f_x_set
    __swig_getmethods__["x"] = _cv.CvPoint2D64f_x_get
    if _newclass:x = _swig_property(_cv.CvPoint2D64f_x_get, _cv.CvPoint2D64f_x_set)
    __swig_setmethods__["y"] = _cv.CvPoint2D64f_y_set
    __swig_getmethods__["y"] = _cv.CvPoint2D64f_y_get
    if _newclass:y = _swig_property(_cv.CvPoint2D64f_y_get, _cv.CvPoint2D64f_y_set)
    def __init__(self): 
        """__init__(self) -> CvPoint2D64f"""
        this = _cv.new_CvPoint2D64f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvPoint2D64f
    __del__ = lambda self : None;
CvPoint2D64f_swigregister = _cv.CvPoint2D64f_swigregister
CvPoint2D64f_swigregister(CvPoint2D64f)


def cvPoint2D64f(*args):
  """cvPoint2D64f(double x, double y) -> CvPoint2D64f"""
  return _cv.cvPoint2D64f(*args)
class CvPoint3D64f(_object):
    """Proxy of C++ CvPoint3D64f class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvPoint3D64f, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvPoint3D64f, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _cv.CvPoint3D64f_x_set
    __swig_getmethods__["x"] = _cv.CvPoint3D64f_x_get
    if _newclass:x = _swig_property(_cv.CvPoint3D64f_x_get, _cv.CvPoint3D64f_x_set)
    __swig_setmethods__["y"] = _cv.CvPoint3D64f_y_set
    __swig_getmethods__["y"] = _cv.CvPoint3D64f_y_get
    if _newclass:y = _swig_property(_cv.CvPoint3D64f_y_get, _cv.CvPoint3D64f_y_set)
    __swig_setmethods__["z"] = _cv.CvPoint3D64f_z_set
    __swig_getmethods__["z"] = _cv.CvPoint3D64f_z_get
    if _newclass:z = _swig_property(_cv.CvPoint3D64f_z_get, _cv.CvPoint3D64f_z_set)
    def __init__(self): 
        """__init__(self) -> CvPoint3D64f"""
        this = _cv.new_CvPoint3D64f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvPoint3D64f
    __del__ = lambda self : None;
CvPoint3D64f_swigregister = _cv.CvPoint3D64f_swigregister
CvPoint3D64f_swigregister(CvPoint3D64f)


def cvPoint3D64f(*args):
  """cvPoint3D64f(double x, double y, double z) -> CvPoint3D64f"""
  return _cv.cvPoint3D64f(*args)
class CvSize(_object):
    """Proxy of C++ CvSize class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSize, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSize, name)
    __repr__ = _swig_repr
    __swig_setmethods__["width"] = _cv.CvSize_width_set
    __swig_getmethods__["width"] = _cv.CvSize_width_get
    if _newclass:width = _swig_property(_cv.CvSize_width_get, _cv.CvSize_width_set)
    __swig_setmethods__["height"] = _cv.CvSize_height_set
    __swig_getmethods__["height"] = _cv.CvSize_height_get
    if _newclass:height = _swig_property(_cv.CvSize_height_get, _cv.CvSize_height_set)
    def __init__(self): 
        """__init__(self) -> CvSize"""
        this = _cv.new_CvSize()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSize
    __del__ = lambda self : None;
CvSize_swigregister = _cv.CvSize_swigregister
CvSize_swigregister(CvSize)


def cvSize(*args):
  """cvSize(int width, int height) -> CvSize"""
  return _cv.cvSize(*args)
class CvSize2D32f(_object):
    """Proxy of C++ CvSize2D32f class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSize2D32f, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSize2D32f, name)
    __repr__ = _swig_repr
    __swig_setmethods__["width"] = _cv.CvSize2D32f_width_set
    __swig_getmethods__["width"] = _cv.CvSize2D32f_width_get
    if _newclass:width = _swig_property(_cv.CvSize2D32f_width_get, _cv.CvSize2D32f_width_set)
    __swig_setmethods__["height"] = _cv.CvSize2D32f_height_set
    __swig_getmethods__["height"] = _cv.CvSize2D32f_height_get
    if _newclass:height = _swig_property(_cv.CvSize2D32f_height_get, _cv.CvSize2D32f_height_set)
    def __init__(self): 
        """__init__(self) -> CvSize2D32f"""
        this = _cv.new_CvSize2D32f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSize2D32f
    __del__ = lambda self : None;
CvSize2D32f_swigregister = _cv.CvSize2D32f_swigregister
CvSize2D32f_swigregister(CvSize2D32f)


def cvSize2D32f(*args):
  """cvSize2D32f(double width, double height) -> CvSize2D32f"""
  return _cv.cvSize2D32f(*args)
class CvBox2D(_object):
    """Proxy of C++ CvBox2D class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvBox2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvBox2D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["center"] = _cv.CvBox2D_center_set
    __swig_getmethods__["center"] = _cv.CvBox2D_center_get
    if _newclass:center = _swig_property(_cv.CvBox2D_center_get, _cv.CvBox2D_center_set)
    __swig_setmethods__["size"] = _cv.CvBox2D_size_set
    __swig_getmethods__["size"] = _cv.CvBox2D_size_get
    if _newclass:size = _swig_property(_cv.CvBox2D_size_get, _cv.CvBox2D_size_set)
    __swig_setmethods__["angle"] = _cv.CvBox2D_angle_set
    __swig_getmethods__["angle"] = _cv.CvBox2D_angle_get
    if _newclass:angle = _swig_property(_cv.CvBox2D_angle_get, _cv.CvBox2D_angle_set)
    def __init__(self): 
        """__init__(self) -> CvBox2D"""
        this = _cv.new_CvBox2D()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvBox2D
    __del__ = lambda self : None;
CvBox2D_swigregister = _cv.CvBox2D_swigregister
CvBox2D_swigregister(CvBox2D)

class CvLineIterator(_object):
    """Proxy of C++ CvLineIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvLineIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvLineIterator, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ptr"] = _cv.CvLineIterator_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvLineIterator_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvLineIterator_ptr_get, _cv.CvLineIterator_ptr_set)
    __swig_setmethods__["err"] = _cv.CvLineIterator_err_set
    __swig_getmethods__["err"] = _cv.CvLineIterator_err_get
    if _newclass:err = _swig_property(_cv.CvLineIterator_err_get, _cv.CvLineIterator_err_set)
    __swig_setmethods__["plus_delta"] = _cv.CvLineIterator_plus_delta_set
    __swig_getmethods__["plus_delta"] = _cv.CvLineIterator_plus_delta_get
    if _newclass:plus_delta = _swig_property(_cv.CvLineIterator_plus_delta_get, _cv.CvLineIterator_plus_delta_set)
    __swig_setmethods__["minus_delta"] = _cv.CvLineIterator_minus_delta_set
    __swig_getmethods__["minus_delta"] = _cv.CvLineIterator_minus_delta_get
    if _newclass:minus_delta = _swig_property(_cv.CvLineIterator_minus_delta_get, _cv.CvLineIterator_minus_delta_set)
    __swig_setmethods__["plus_step"] = _cv.CvLineIterator_plus_step_set
    __swig_getmethods__["plus_step"] = _cv.CvLineIterator_plus_step_get
    if _newclass:plus_step = _swig_property(_cv.CvLineIterator_plus_step_get, _cv.CvLineIterator_plus_step_set)
    __swig_setmethods__["minus_step"] = _cv.CvLineIterator_minus_step_set
    __swig_getmethods__["minus_step"] = _cv.CvLineIterator_minus_step_get
    if _newclass:minus_step = _swig_property(_cv.CvLineIterator_minus_step_get, _cv.CvLineIterator_minus_step_set)
    def __init__(self): 
        """__init__(self) -> CvLineIterator"""
        this = _cv.new_CvLineIterator()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvLineIterator
    __del__ = lambda self : None;
CvLineIterator_swigregister = _cv.CvLineIterator_swigregister
CvLineIterator_swigregister(CvLineIterator)

class CvSlice(_object):
    """Proxy of C++ CvSlice class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSlice, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSlice, name)
    __repr__ = _swig_repr
    __swig_setmethods__["start_index"] = _cv.CvSlice_start_index_set
    __swig_getmethods__["start_index"] = _cv.CvSlice_start_index_get
    if _newclass:start_index = _swig_property(_cv.CvSlice_start_index_get, _cv.CvSlice_start_index_set)
    __swig_setmethods__["end_index"] = _cv.CvSlice_end_index_set
    __swig_getmethods__["end_index"] = _cv.CvSlice_end_index_get
    if _newclass:end_index = _swig_property(_cv.CvSlice_end_index_get, _cv.CvSlice_end_index_set)
    def __init__(self): 
        """__init__(self) -> CvSlice"""
        this = _cv.new_CvSlice()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSlice
    __del__ = lambda self : None;
CvSlice_swigregister = _cv.CvSlice_swigregister
CvSlice_swigregister(CvSlice)


def cvSlice(*args):
  """cvSlice(int start, int end) -> CvSlice"""
  return _cv.cvSlice(*args)
class CvScalar(_object):
    """Proxy of C++ CvScalar class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvScalar, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvScalar, name)
    __swig_setmethods__["val"] = _cv.CvScalar_val_set
    __swig_getmethods__["val"] = _cv.CvScalar_val_get
    if _newclass:val = _swig_property(_cv.CvScalar_val_get, _cv.CvScalar_val_set)
    def __str__(self):
        """__str__(self) -> char"""
        return _cv.CvScalar___str__(self)

    def __repr__(self):
        """__repr__(self) -> char"""
        return _cv.CvScalar___repr__(self)

    def __getitem__(self, *args):
        """__getitem__(self, int index) -> double"""
        return _cv.CvScalar___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int index, double value)"""
        return _cv.CvScalar___setitem__(self, *args)

    def __init__(self): 
        """__init__(self) -> CvScalar"""
        this = _cv.new_CvScalar()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvScalar
    __del__ = lambda self : None;
CvScalar_swigregister = _cv.CvScalar_swigregister
CvScalar_swigregister(CvScalar)


def cvRealScalar(*args):
  """cvRealScalar(double val0) -> CvScalar"""
  return _cv.cvRealScalar(*args)

def cvScalarAll(*args):
  """cvScalarAll(double val0123) -> CvScalar"""
  return _cv.cvScalarAll(*args)
class CvMemBlock(_object):
    """Proxy of C++ CvMemBlock class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvMemBlock, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvMemBlock, name)
    __repr__ = _swig_repr
    __swig_setmethods__["prev"] = _cv.CvMemBlock_prev_set
    __swig_getmethods__["prev"] = _cv.CvMemBlock_prev_get
    if _newclass:prev = _swig_property(_cv.CvMemBlock_prev_get, _cv.CvMemBlock_prev_set)
    __swig_setmethods__["next"] = _cv.CvMemBlock_next_set
    __swig_getmethods__["next"] = _cv.CvMemBlock_next_get
    if _newclass:next = _swig_property(_cv.CvMemBlock_next_get, _cv.CvMemBlock_next_set)
    def __init__(self): 
        """__init__(self) -> CvMemBlock"""
        this = _cv.new_CvMemBlock()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvMemBlock
    __del__ = lambda self : None;
CvMemBlock_swigregister = _cv.CvMemBlock_swigregister
CvMemBlock_swigregister(CvMemBlock)

def cvScalar(*args):
  """
    cvScalar(double val0, double val1 = 0, double val2 = 0, double val3 = 0) -> CvScalar
    cvScalar(double val0, double val1 = 0, double val2 = 0) -> CvScalar
    cvScalar(double val0, double val1 = 0) -> CvScalar
    cvScalar(double val0) -> CvScalar
    """
  return _cv.cvScalar(*args)

class CvMemStorage(_object):
    """Proxy of C++ CvMemStorage class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvMemStorage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvMemStorage, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["signature"] = _cv.CvMemStorage_signature_set
    __swig_getmethods__["signature"] = _cv.CvMemStorage_signature_get
    if _newclass:signature = _swig_property(_cv.CvMemStorage_signature_get, _cv.CvMemStorage_signature_set)
    __swig_setmethods__["bottom"] = _cv.CvMemStorage_bottom_set
    __swig_getmethods__["bottom"] = _cv.CvMemStorage_bottom_get
    if _newclass:bottom = _swig_property(_cv.CvMemStorage_bottom_get, _cv.CvMemStorage_bottom_set)
    __swig_setmethods__["top"] = _cv.CvMemStorage_top_set
    __swig_getmethods__["top"] = _cv.CvMemStorage_top_get
    if _newclass:top = _swig_property(_cv.CvMemStorage_top_get, _cv.CvMemStorage_top_set)
    __swig_setmethods__["parent"] = _cv.CvMemStorage_parent_set
    __swig_getmethods__["parent"] = _cv.CvMemStorage_parent_get
    if _newclass:parent = _swig_property(_cv.CvMemStorage_parent_get, _cv.CvMemStorage_parent_set)
    __swig_setmethods__["block_size"] = _cv.CvMemStorage_block_size_set
    __swig_getmethods__["block_size"] = _cv.CvMemStorage_block_size_get
    if _newclass:block_size = _swig_property(_cv.CvMemStorage_block_size_get, _cv.CvMemStorage_block_size_set)
    __swig_setmethods__["free_space"] = _cv.CvMemStorage_free_space_set
    __swig_getmethods__["free_space"] = _cv.CvMemStorage_free_space_get
    if _newclass:free_space = _swig_property(_cv.CvMemStorage_free_space_get, _cv.CvMemStorage_free_space_set)
    __swig_destroy__ = _cv.delete_CvMemStorage
    __del__ = lambda self : None;
CvMemStorage_swigregister = _cv.CvMemStorage_swigregister
CvMemStorage_swigregister(CvMemStorage)

class CvMemStoragePos(_object):
    """Proxy of C++ CvMemStoragePos class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvMemStoragePos, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvMemStoragePos, name)
    __repr__ = _swig_repr
    __swig_setmethods__["top"] = _cv.CvMemStoragePos_top_set
    __swig_getmethods__["top"] = _cv.CvMemStoragePos_top_get
    if _newclass:top = _swig_property(_cv.CvMemStoragePos_top_get, _cv.CvMemStoragePos_top_set)
    __swig_setmethods__["free_space"] = _cv.CvMemStoragePos_free_space_set
    __swig_getmethods__["free_space"] = _cv.CvMemStoragePos_free_space_get
    if _newclass:free_space = _swig_property(_cv.CvMemStoragePos_free_space_get, _cv.CvMemStoragePos_free_space_set)
    def __init__(self): 
        """__init__(self) -> CvMemStoragePos"""
        this = _cv.new_CvMemStoragePos()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvMemStoragePos
    __del__ = lambda self : None;
CvMemStoragePos_swigregister = _cv.CvMemStoragePos_swigregister
CvMemStoragePos_swigregister(CvMemStoragePos)

class CvSeqBlock(_object):
    """Proxy of C++ CvSeqBlock class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSeqBlock, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSeqBlock, name)
    __repr__ = _swig_repr
    __swig_setmethods__["prev"] = _cv.CvSeqBlock_prev_set
    __swig_getmethods__["prev"] = _cv.CvSeqBlock_prev_get
    if _newclass:prev = _swig_property(_cv.CvSeqBlock_prev_get, _cv.CvSeqBlock_prev_set)
    __swig_setmethods__["next"] = _cv.CvSeqBlock_next_set
    __swig_getmethods__["next"] = _cv.CvSeqBlock_next_get
    if _newclass:next = _swig_property(_cv.CvSeqBlock_next_get, _cv.CvSeqBlock_next_set)
    __swig_setmethods__["start_index"] = _cv.CvSeqBlock_start_index_set
    __swig_getmethods__["start_index"] = _cv.CvSeqBlock_start_index_get
    if _newclass:start_index = _swig_property(_cv.CvSeqBlock_start_index_get, _cv.CvSeqBlock_start_index_set)
    __swig_setmethods__["count"] = _cv.CvSeqBlock_count_set
    __swig_getmethods__["count"] = _cv.CvSeqBlock_count_get
    if _newclass:count = _swig_property(_cv.CvSeqBlock_count_get, _cv.CvSeqBlock_count_set)
    __swig_setmethods__["data"] = _cv.CvSeqBlock_data_set
    __swig_getmethods__["data"] = _cv.CvSeqBlock_data_get
    if _newclass:data = _swig_property(_cv.CvSeqBlock_data_get, _cv.CvSeqBlock_data_set)
    def __init__(self): 
        """__init__(self) -> CvSeqBlock"""
        this = _cv.new_CvSeqBlock()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSeqBlock
    __del__ = lambda self : None;
CvSeqBlock_swigregister = _cv.CvSeqBlock_swigregister
CvSeqBlock_swigregister(CvSeqBlock)

class CvSeq(_object):
    """Proxy of C++ CvSeq class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSeq, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSeq, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvSeq_flags_set
    __swig_getmethods__["flags"] = _cv.CvSeq_flags_get
    if _newclass:flags = _swig_property(_cv.CvSeq_flags_get, _cv.CvSeq_flags_set)
    __swig_setmethods__["header_size"] = _cv.CvSeq_header_size_set
    __swig_getmethods__["header_size"] = _cv.CvSeq_header_size_get
    if _newclass:header_size = _swig_property(_cv.CvSeq_header_size_get, _cv.CvSeq_header_size_set)
    __swig_setmethods__["h_prev"] = _cv.CvSeq_h_prev_set
    __swig_getmethods__["h_prev"] = _cv.CvSeq_h_prev_get
    if _newclass:h_prev = _swig_property(_cv.CvSeq_h_prev_get, _cv.CvSeq_h_prev_set)
    __swig_setmethods__["h_next"] = _cv.CvSeq_h_next_set
    __swig_getmethods__["h_next"] = _cv.CvSeq_h_next_get
    if _newclass:h_next = _swig_property(_cv.CvSeq_h_next_get, _cv.CvSeq_h_next_set)
    __swig_setmethods__["v_prev"] = _cv.CvSeq_v_prev_set
    __swig_getmethods__["v_prev"] = _cv.CvSeq_v_prev_get
    if _newclass:v_prev = _swig_property(_cv.CvSeq_v_prev_get, _cv.CvSeq_v_prev_set)
    __swig_setmethods__["v_next"] = _cv.CvSeq_v_next_set
    __swig_getmethods__["v_next"] = _cv.CvSeq_v_next_get
    if _newclass:v_next = _swig_property(_cv.CvSeq_v_next_get, _cv.CvSeq_v_next_set)
    __swig_setmethods__["total"] = _cv.CvSeq_total_set
    __swig_getmethods__["total"] = _cv.CvSeq_total_get
    if _newclass:total = _swig_property(_cv.CvSeq_total_get, _cv.CvSeq_total_set)
    __swig_setmethods__["elem_size"] = _cv.CvSeq_elem_size_set
    __swig_getmethods__["elem_size"] = _cv.CvSeq_elem_size_get
    if _newclass:elem_size = _swig_property(_cv.CvSeq_elem_size_get, _cv.CvSeq_elem_size_set)
    __swig_setmethods__["block_max"] = _cv.CvSeq_block_max_set
    __swig_getmethods__["block_max"] = _cv.CvSeq_block_max_get
    if _newclass:block_max = _swig_property(_cv.CvSeq_block_max_get, _cv.CvSeq_block_max_set)
    __swig_setmethods__["ptr"] = _cv.CvSeq_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvSeq_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvSeq_ptr_get, _cv.CvSeq_ptr_set)
    __swig_setmethods__["delta_elems"] = _cv.CvSeq_delta_elems_set
    __swig_getmethods__["delta_elems"] = _cv.CvSeq_delta_elems_get
    if _newclass:delta_elems = _swig_property(_cv.CvSeq_delta_elems_get, _cv.CvSeq_delta_elems_set)
    __swig_setmethods__["storage"] = _cv.CvSeq_storage_set
    __swig_getmethods__["storage"] = _cv.CvSeq_storage_get
    if _newclass:storage = _swig_property(_cv.CvSeq_storage_get, _cv.CvSeq_storage_set)
    __swig_setmethods__["free_blocks"] = _cv.CvSeq_free_blocks_set
    __swig_getmethods__["free_blocks"] = _cv.CvSeq_free_blocks_get
    if _newclass:free_blocks = _swig_property(_cv.CvSeq_free_blocks_get, _cv.CvSeq_free_blocks_set)
    __swig_setmethods__["first"] = _cv.CvSeq_first_set
    __swig_getmethods__["first"] = _cv.CvSeq_first_get
    if _newclass:first = _swig_property(_cv.CvSeq_first_get, _cv.CvSeq_first_set)
    def __iter__(self):
    	"""
    	generator function iterating elements in the sequence
    	"""
    	for i in range(self.total):
    		yield self[i]

    def vrange(self):
    	"""
    	generator function iterating along v_next
    	"""
    	s = self
    	t = type(self)
    	while s:
    		yield s
    		s = t.cast(s.v_next)

    def hrange(self):
    	"""
    	generator function iterating along h_next
    	"""
    	s = self
    	t = type(self)
    	while s:
    		yield s
    		s = t.cast(s.h_next)

    def __init__(self): 
        """__init__(self) -> CvSeq"""
        this = _cv.new_CvSeq()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSeq
    __del__ = lambda self : None;
CvSeq_swigregister = _cv.CvSeq_swigregister
CvSeq_swigregister(CvSeq)

class CvSetElem(_object):
    """Proxy of C++ CvSetElem class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSetElem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSetElem, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvSetElem_flags_set
    __swig_getmethods__["flags"] = _cv.CvSetElem_flags_get
    if _newclass:flags = _swig_property(_cv.CvSetElem_flags_get, _cv.CvSetElem_flags_set)
    __swig_setmethods__["next_free"] = _cv.CvSetElem_next_free_set
    __swig_getmethods__["next_free"] = _cv.CvSetElem_next_free_get
    if _newclass:next_free = _swig_property(_cv.CvSetElem_next_free_get, _cv.CvSetElem_next_free_set)
    def __init__(self): 
        """__init__(self) -> CvSetElem"""
        this = _cv.new_CvSetElem()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSetElem
    __del__ = lambda self : None;
CvSetElem_swigregister = _cv.CvSetElem_swigregister
CvSetElem_swigregister(CvSetElem)

class CvSet(_object):
    """Proxy of C++ CvSet class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSet, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvSet_flags_set
    __swig_getmethods__["flags"] = _cv.CvSet_flags_get
    if _newclass:flags = _swig_property(_cv.CvSet_flags_get, _cv.CvSet_flags_set)
    __swig_setmethods__["header_size"] = _cv.CvSet_header_size_set
    __swig_getmethods__["header_size"] = _cv.CvSet_header_size_get
    if _newclass:header_size = _swig_property(_cv.CvSet_header_size_get, _cv.CvSet_header_size_set)
    __swig_setmethods__["h_prev"] = _cv.CvSet_h_prev_set
    __swig_getmethods__["h_prev"] = _cv.CvSet_h_prev_get
    if _newclass:h_prev = _swig_property(_cv.CvSet_h_prev_get, _cv.CvSet_h_prev_set)
    __swig_setmethods__["h_next"] = _cv.CvSet_h_next_set
    __swig_getmethods__["h_next"] = _cv.CvSet_h_next_get
    if _newclass:h_next = _swig_property(_cv.CvSet_h_next_get, _cv.CvSet_h_next_set)
    __swig_setmethods__["v_prev"] = _cv.CvSet_v_prev_set
    __swig_getmethods__["v_prev"] = _cv.CvSet_v_prev_get
    if _newclass:v_prev = _swig_property(_cv.CvSet_v_prev_get, _cv.CvSet_v_prev_set)
    __swig_setmethods__["v_next"] = _cv.CvSet_v_next_set
    __swig_getmethods__["v_next"] = _cv.CvSet_v_next_get
    if _newclass:v_next = _swig_property(_cv.CvSet_v_next_get, _cv.CvSet_v_next_set)
    __swig_setmethods__["total"] = _cv.CvSet_total_set
    __swig_getmethods__["total"] = _cv.CvSet_total_get
    if _newclass:total = _swig_property(_cv.CvSet_total_get, _cv.CvSet_total_set)
    __swig_setmethods__["elem_size"] = _cv.CvSet_elem_size_set
    __swig_getmethods__["elem_size"] = _cv.CvSet_elem_size_get
    if _newclass:elem_size = _swig_property(_cv.CvSet_elem_size_get, _cv.CvSet_elem_size_set)
    __swig_setmethods__["block_max"] = _cv.CvSet_block_max_set
    __swig_getmethods__["block_max"] = _cv.CvSet_block_max_get
    if _newclass:block_max = _swig_property(_cv.CvSet_block_max_get, _cv.CvSet_block_max_set)
    __swig_setmethods__["ptr"] = _cv.CvSet_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvSet_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvSet_ptr_get, _cv.CvSet_ptr_set)
    __swig_setmethods__["delta_elems"] = _cv.CvSet_delta_elems_set
    __swig_getmethods__["delta_elems"] = _cv.CvSet_delta_elems_get
    if _newclass:delta_elems = _swig_property(_cv.CvSet_delta_elems_get, _cv.CvSet_delta_elems_set)
    __swig_setmethods__["storage"] = _cv.CvSet_storage_set
    __swig_getmethods__["storage"] = _cv.CvSet_storage_get
    if _newclass:storage = _swig_property(_cv.CvSet_storage_get, _cv.CvSet_storage_set)
    __swig_setmethods__["free_blocks"] = _cv.CvSet_free_blocks_set
    __swig_getmethods__["free_blocks"] = _cv.CvSet_free_blocks_get
    if _newclass:free_blocks = _swig_property(_cv.CvSet_free_blocks_get, _cv.CvSet_free_blocks_set)
    __swig_setmethods__["first"] = _cv.CvSet_first_set
    __swig_getmethods__["first"] = _cv.CvSet_first_get
    if _newclass:first = _swig_property(_cv.CvSet_first_get, _cv.CvSet_first_set)
    __swig_setmethods__["free_elems"] = _cv.CvSet_free_elems_set
    __swig_getmethods__["free_elems"] = _cv.CvSet_free_elems_get
    if _newclass:free_elems = _swig_property(_cv.CvSet_free_elems_get, _cv.CvSet_free_elems_set)
    __swig_setmethods__["active_count"] = _cv.CvSet_active_count_set
    __swig_getmethods__["active_count"] = _cv.CvSet_active_count_get
    if _newclass:active_count = _swig_property(_cv.CvSet_active_count_get, _cv.CvSet_active_count_set)
    def __init__(self): 
        """__init__(self) -> CvSet"""
        this = _cv.new_CvSet()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSet
    __del__ = lambda self : None;
CvSet_swigregister = _cv.CvSet_swigregister
CvSet_swigregister(CvSet)

class CvGraphEdge(_object):
    """Proxy of C++ CvGraphEdge class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvGraphEdge, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvGraphEdge, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvGraphEdge_flags_set
    __swig_getmethods__["flags"] = _cv.CvGraphEdge_flags_get
    if _newclass:flags = _swig_property(_cv.CvGraphEdge_flags_get, _cv.CvGraphEdge_flags_set)
    __swig_setmethods__["weight"] = _cv.CvGraphEdge_weight_set
    __swig_getmethods__["weight"] = _cv.CvGraphEdge_weight_get
    if _newclass:weight = _swig_property(_cv.CvGraphEdge_weight_get, _cv.CvGraphEdge_weight_set)
    __swig_setmethods__["next"] = _cv.CvGraphEdge_next_set
    __swig_getmethods__["next"] = _cv.CvGraphEdge_next_get
    if _newclass:next = _swig_property(_cv.CvGraphEdge_next_get, _cv.CvGraphEdge_next_set)
    __swig_setmethods__["vtx"] = _cv.CvGraphEdge_vtx_set
    __swig_getmethods__["vtx"] = _cv.CvGraphEdge_vtx_get
    if _newclass:vtx = _swig_property(_cv.CvGraphEdge_vtx_get, _cv.CvGraphEdge_vtx_set)
    def __init__(self): 
        """__init__(self) -> CvGraphEdge"""
        this = _cv.new_CvGraphEdge()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvGraphEdge
    __del__ = lambda self : None;
CvGraphEdge_swigregister = _cv.CvGraphEdge_swigregister
CvGraphEdge_swigregister(CvGraphEdge)

class CvGraphVtx(_object):
    """Proxy of C++ CvGraphVtx class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvGraphVtx, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvGraphVtx, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvGraphVtx_flags_set
    __swig_getmethods__["flags"] = _cv.CvGraphVtx_flags_get
    if _newclass:flags = _swig_property(_cv.CvGraphVtx_flags_get, _cv.CvGraphVtx_flags_set)
    __swig_setmethods__["first"] = _cv.CvGraphVtx_first_set
    __swig_getmethods__["first"] = _cv.CvGraphVtx_first_get
    if _newclass:first = _swig_property(_cv.CvGraphVtx_first_get, _cv.CvGraphVtx_first_set)
    def __init__(self): 
        """__init__(self) -> CvGraphVtx"""
        this = _cv.new_CvGraphVtx()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvGraphVtx
    __del__ = lambda self : None;
CvGraphVtx_swigregister = _cv.CvGraphVtx_swigregister
CvGraphVtx_swigregister(CvGraphVtx)

class CvGraphVtx2D(_object):
    """Proxy of C++ CvGraphVtx2D class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvGraphVtx2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvGraphVtx2D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvGraphVtx2D_flags_set
    __swig_getmethods__["flags"] = _cv.CvGraphVtx2D_flags_get
    if _newclass:flags = _swig_property(_cv.CvGraphVtx2D_flags_get, _cv.CvGraphVtx2D_flags_set)
    __swig_setmethods__["first"] = _cv.CvGraphVtx2D_first_set
    __swig_getmethods__["first"] = _cv.CvGraphVtx2D_first_get
    if _newclass:first = _swig_property(_cv.CvGraphVtx2D_first_get, _cv.CvGraphVtx2D_first_set)
    __swig_setmethods__["ptr"] = _cv.CvGraphVtx2D_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvGraphVtx2D_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvGraphVtx2D_ptr_get, _cv.CvGraphVtx2D_ptr_set)
    def __init__(self): 
        """__init__(self) -> CvGraphVtx2D"""
        this = _cv.new_CvGraphVtx2D()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvGraphVtx2D
    __del__ = lambda self : None;
CvGraphVtx2D_swigregister = _cv.CvGraphVtx2D_swigregister
CvGraphVtx2D_swigregister(CvGraphVtx2D)

class CvGraph(_object):
    """Proxy of C++ CvGraph class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvGraph, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvGraph, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvGraph_flags_set
    __swig_getmethods__["flags"] = _cv.CvGraph_flags_get
    if _newclass:flags = _swig_property(_cv.CvGraph_flags_get, _cv.CvGraph_flags_set)
    __swig_setmethods__["header_size"] = _cv.CvGraph_header_size_set
    __swig_getmethods__["header_size"] = _cv.CvGraph_header_size_get
    if _newclass:header_size = _swig_property(_cv.CvGraph_header_size_get, _cv.CvGraph_header_size_set)
    __swig_setmethods__["h_prev"] = _cv.CvGraph_h_prev_set
    __swig_getmethods__["h_prev"] = _cv.CvGraph_h_prev_get
    if _newclass:h_prev = _swig_property(_cv.CvGraph_h_prev_get, _cv.CvGraph_h_prev_set)
    __swig_setmethods__["h_next"] = _cv.CvGraph_h_next_set
    __swig_getmethods__["h_next"] = _cv.CvGraph_h_next_get
    if _newclass:h_next = _swig_property(_cv.CvGraph_h_next_get, _cv.CvGraph_h_next_set)
    __swig_setmethods__["v_prev"] = _cv.CvGraph_v_prev_set
    __swig_getmethods__["v_prev"] = _cv.CvGraph_v_prev_get
    if _newclass:v_prev = _swig_property(_cv.CvGraph_v_prev_get, _cv.CvGraph_v_prev_set)
    __swig_setmethods__["v_next"] = _cv.CvGraph_v_next_set
    __swig_getmethods__["v_next"] = _cv.CvGraph_v_next_get
    if _newclass:v_next = _swig_property(_cv.CvGraph_v_next_get, _cv.CvGraph_v_next_set)
    __swig_setmethods__["total"] = _cv.CvGraph_total_set
    __swig_getmethods__["total"] = _cv.CvGraph_total_get
    if _newclass:total = _swig_property(_cv.CvGraph_total_get, _cv.CvGraph_total_set)
    __swig_setmethods__["elem_size"] = _cv.CvGraph_elem_size_set
    __swig_getmethods__["elem_size"] = _cv.CvGraph_elem_size_get
    if _newclass:elem_size = _swig_property(_cv.CvGraph_elem_size_get, _cv.CvGraph_elem_size_set)
    __swig_setmethods__["block_max"] = _cv.CvGraph_block_max_set
    __swig_getmethods__["block_max"] = _cv.CvGraph_block_max_get
    if _newclass:block_max = _swig_property(_cv.CvGraph_block_max_get, _cv.CvGraph_block_max_set)
    __swig_setmethods__["ptr"] = _cv.CvGraph_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvGraph_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvGraph_ptr_get, _cv.CvGraph_ptr_set)
    __swig_setmethods__["delta_elems"] = _cv.CvGraph_delta_elems_set
    __swig_getmethods__["delta_elems"] = _cv.CvGraph_delta_elems_get
    if _newclass:delta_elems = _swig_property(_cv.CvGraph_delta_elems_get, _cv.CvGraph_delta_elems_set)
    __swig_setmethods__["storage"] = _cv.CvGraph_storage_set
    __swig_getmethods__["storage"] = _cv.CvGraph_storage_get
    if _newclass:storage = _swig_property(_cv.CvGraph_storage_get, _cv.CvGraph_storage_set)
    __swig_setmethods__["free_blocks"] = _cv.CvGraph_free_blocks_set
    __swig_getmethods__["free_blocks"] = _cv.CvGraph_free_blocks_get
    if _newclass:free_blocks = _swig_property(_cv.CvGraph_free_blocks_get, _cv.CvGraph_free_blocks_set)
    __swig_setmethods__["first"] = _cv.CvGraph_first_set
    __swig_getmethods__["first"] = _cv.CvGraph_first_get
    if _newclass:first = _swig_property(_cv.CvGraph_first_get, _cv.CvGraph_first_set)
    __swig_setmethods__["free_elems"] = _cv.CvGraph_free_elems_set
    __swig_getmethods__["free_elems"] = _cv.CvGraph_free_elems_get
    if _newclass:free_elems = _swig_property(_cv.CvGraph_free_elems_get, _cv.CvGraph_free_elems_set)
    __swig_setmethods__["active_count"] = _cv.CvGraph_active_count_set
    __swig_getmethods__["active_count"] = _cv.CvGraph_active_count_get
    if _newclass:active_count = _swig_property(_cv.CvGraph_active_count_get, _cv.CvGraph_active_count_set)
    __swig_setmethods__["edges"] = _cv.CvGraph_edges_set
    __swig_getmethods__["edges"] = _cv.CvGraph_edges_get
    if _newclass:edges = _swig_property(_cv.CvGraph_edges_get, _cv.CvGraph_edges_set)
    def __init__(self): 
        """__init__(self) -> CvGraph"""
        this = _cv.new_CvGraph()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvGraph
    __del__ = lambda self : None;
CvGraph_swigregister = _cv.CvGraph_swigregister
CvGraph_swigregister(CvGraph)

class CvChain(_object):
    """Proxy of C++ CvChain class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvChain, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvChain, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvChain_flags_set
    __swig_getmethods__["flags"] = _cv.CvChain_flags_get
    if _newclass:flags = _swig_property(_cv.CvChain_flags_get, _cv.CvChain_flags_set)
    __swig_setmethods__["header_size"] = _cv.CvChain_header_size_set
    __swig_getmethods__["header_size"] = _cv.CvChain_header_size_get
    if _newclass:header_size = _swig_property(_cv.CvChain_header_size_get, _cv.CvChain_header_size_set)
    __swig_setmethods__["h_prev"] = _cv.CvChain_h_prev_set
    __swig_getmethods__["h_prev"] = _cv.CvChain_h_prev_get
    if _newclass:h_prev = _swig_property(_cv.CvChain_h_prev_get, _cv.CvChain_h_prev_set)
    __swig_setmethods__["h_next"] = _cv.CvChain_h_next_set
    __swig_getmethods__["h_next"] = _cv.CvChain_h_next_get
    if _newclass:h_next = _swig_property(_cv.CvChain_h_next_get, _cv.CvChain_h_next_set)
    __swig_setmethods__["v_prev"] = _cv.CvChain_v_prev_set
    __swig_getmethods__["v_prev"] = _cv.CvChain_v_prev_get
    if _newclass:v_prev = _swig_property(_cv.CvChain_v_prev_get, _cv.CvChain_v_prev_set)
    __swig_setmethods__["v_next"] = _cv.CvChain_v_next_set
    __swig_getmethods__["v_next"] = _cv.CvChain_v_next_get
    if _newclass:v_next = _swig_property(_cv.CvChain_v_next_get, _cv.CvChain_v_next_set)
    __swig_setmethods__["total"] = _cv.CvChain_total_set
    __swig_getmethods__["total"] = _cv.CvChain_total_get
    if _newclass:total = _swig_property(_cv.CvChain_total_get, _cv.CvChain_total_set)
    __swig_setmethods__["elem_size"] = _cv.CvChain_elem_size_set
    __swig_getmethods__["elem_size"] = _cv.CvChain_elem_size_get
    if _newclass:elem_size = _swig_property(_cv.CvChain_elem_size_get, _cv.CvChain_elem_size_set)
    __swig_setmethods__["block_max"] = _cv.CvChain_block_max_set
    __swig_getmethods__["block_max"] = _cv.CvChain_block_max_get
    if _newclass:block_max = _swig_property(_cv.CvChain_block_max_get, _cv.CvChain_block_max_set)
    __swig_setmethods__["ptr"] = _cv.CvChain_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvChain_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvChain_ptr_get, _cv.CvChain_ptr_set)
    __swig_setmethods__["delta_elems"] = _cv.CvChain_delta_elems_set
    __swig_getmethods__["delta_elems"] = _cv.CvChain_delta_elems_get
    if _newclass:delta_elems = _swig_property(_cv.CvChain_delta_elems_get, _cv.CvChain_delta_elems_set)
    __swig_setmethods__["storage"] = _cv.CvChain_storage_set
    __swig_getmethods__["storage"] = _cv.CvChain_storage_get
    if _newclass:storage = _swig_property(_cv.CvChain_storage_get, _cv.CvChain_storage_set)
    __swig_setmethods__["free_blocks"] = _cv.CvChain_free_blocks_set
    __swig_getmethods__["free_blocks"] = _cv.CvChain_free_blocks_get
    if _newclass:free_blocks = _swig_property(_cv.CvChain_free_blocks_get, _cv.CvChain_free_blocks_set)
    __swig_setmethods__["first"] = _cv.CvChain_first_set
    __swig_getmethods__["first"] = _cv.CvChain_first_get
    if _newclass:first = _swig_property(_cv.CvChain_first_get, _cv.CvChain_first_set)
    __swig_setmethods__["origin"] = _cv.CvChain_origin_set
    __swig_getmethods__["origin"] = _cv.CvChain_origin_get
    if _newclass:origin = _swig_property(_cv.CvChain_origin_get, _cv.CvChain_origin_set)
    def __init__(self): 
        """__init__(self) -> CvChain"""
        this = _cv.new_CvChain()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvChain
    __del__ = lambda self : None;
CvChain_swigregister = _cv.CvChain_swigregister
CvChain_swigregister(CvChain)

class CvContour(_object):
    """Proxy of C++ CvContour class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvContour, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvContour, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvContour_flags_set
    __swig_getmethods__["flags"] = _cv.CvContour_flags_get
    if _newclass:flags = _swig_property(_cv.CvContour_flags_get, _cv.CvContour_flags_set)
    __swig_setmethods__["header_size"] = _cv.CvContour_header_size_set
    __swig_getmethods__["header_size"] = _cv.CvContour_header_size_get
    if _newclass:header_size = _swig_property(_cv.CvContour_header_size_get, _cv.CvContour_header_size_set)
    __swig_setmethods__["h_prev"] = _cv.CvContour_h_prev_set
    __swig_getmethods__["h_prev"] = _cv.CvContour_h_prev_get
    if _newclass:h_prev = _swig_property(_cv.CvContour_h_prev_get, _cv.CvContour_h_prev_set)
    __swig_setmethods__["h_next"] = _cv.CvContour_h_next_set
    __swig_getmethods__["h_next"] = _cv.CvContour_h_next_get
    if _newclass:h_next = _swig_property(_cv.CvContour_h_next_get, _cv.CvContour_h_next_set)
    __swig_setmethods__["v_prev"] = _cv.CvContour_v_prev_set
    __swig_getmethods__["v_prev"] = _cv.CvContour_v_prev_get
    if _newclass:v_prev = _swig_property(_cv.CvContour_v_prev_get, _cv.CvContour_v_prev_set)
    __swig_setmethods__["v_next"] = _cv.CvContour_v_next_set
    __swig_getmethods__["v_next"] = _cv.CvContour_v_next_get
    if _newclass:v_next = _swig_property(_cv.CvContour_v_next_get, _cv.CvContour_v_next_set)
    __swig_setmethods__["total"] = _cv.CvContour_total_set
    __swig_getmethods__["total"] = _cv.CvContour_total_get
    if _newclass:total = _swig_property(_cv.CvContour_total_get, _cv.CvContour_total_set)
    __swig_setmethods__["elem_size"] = _cv.CvContour_elem_size_set
    __swig_getmethods__["elem_size"] = _cv.CvContour_elem_size_get
    if _newclass:elem_size = _swig_property(_cv.CvContour_elem_size_get, _cv.CvContour_elem_size_set)
    __swig_setmethods__["block_max"] = _cv.CvContour_block_max_set
    __swig_getmethods__["block_max"] = _cv.CvContour_block_max_get
    if _newclass:block_max = _swig_property(_cv.CvContour_block_max_get, _cv.CvContour_block_max_set)
    __swig_setmethods__["ptr"] = _cv.CvContour_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvContour_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvContour_ptr_get, _cv.CvContour_ptr_set)
    __swig_setmethods__["delta_elems"] = _cv.CvContour_delta_elems_set
    __swig_getmethods__["delta_elems"] = _cv.CvContour_delta_elems_get
    if _newclass:delta_elems = _swig_property(_cv.CvContour_delta_elems_get, _cv.CvContour_delta_elems_set)
    __swig_setmethods__["storage"] = _cv.CvContour_storage_set
    __swig_getmethods__["storage"] = _cv.CvContour_storage_get
    if _newclass:storage = _swig_property(_cv.CvContour_storage_get, _cv.CvContour_storage_set)
    __swig_setmethods__["free_blocks"] = _cv.CvContour_free_blocks_set
    __swig_getmethods__["free_blocks"] = _cv.CvContour_free_blocks_get
    if _newclass:free_blocks = _swig_property(_cv.CvContour_free_blocks_get, _cv.CvContour_free_blocks_set)
    __swig_setmethods__["first"] = _cv.CvContour_first_set
    __swig_getmethods__["first"] = _cv.CvContour_first_get
    if _newclass:first = _swig_property(_cv.CvContour_first_get, _cv.CvContour_first_set)
    __swig_setmethods__["rect"] = _cv.CvContour_rect_set
    __swig_getmethods__["rect"] = _cv.CvContour_rect_get
    if _newclass:rect = _swig_property(_cv.CvContour_rect_get, _cv.CvContour_rect_set)
    __swig_setmethods__["color"] = _cv.CvContour_color_set
    __swig_getmethods__["color"] = _cv.CvContour_color_get
    if _newclass:color = _swig_property(_cv.CvContour_color_get, _cv.CvContour_color_set)
    __swig_setmethods__["reserved"] = _cv.CvContour_reserved_set
    __swig_getmethods__["reserved"] = _cv.CvContour_reserved_get
    if _newclass:reserved = _swig_property(_cv.CvContour_reserved_get, _cv.CvContour_reserved_set)
    def __init__(self): 
        """__init__(self) -> CvContour"""
        this = _cv.new_CvContour()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvContour
    __del__ = lambda self : None;
CvContour_swigregister = _cv.CvContour_swigregister
CvContour_swigregister(CvContour)

class CvSeqWriter(_object):
    """Proxy of C++ CvSeqWriter class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSeqWriter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSeqWriter, name)
    __repr__ = _swig_repr
    __swig_setmethods__["header_size"] = _cv.CvSeqWriter_header_size_set
    __swig_getmethods__["header_size"] = _cv.CvSeqWriter_header_size_get
    if _newclass:header_size = _swig_property(_cv.CvSeqWriter_header_size_get, _cv.CvSeqWriter_header_size_set)
    __swig_setmethods__["seq"] = _cv.CvSeqWriter_seq_set
    __swig_getmethods__["seq"] = _cv.CvSeqWriter_seq_get
    if _newclass:seq = _swig_property(_cv.CvSeqWriter_seq_get, _cv.CvSeqWriter_seq_set)
    __swig_setmethods__["block"] = _cv.CvSeqWriter_block_set
    __swig_getmethods__["block"] = _cv.CvSeqWriter_block_get
    if _newclass:block = _swig_property(_cv.CvSeqWriter_block_get, _cv.CvSeqWriter_block_set)
    __swig_setmethods__["ptr"] = _cv.CvSeqWriter_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvSeqWriter_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvSeqWriter_ptr_get, _cv.CvSeqWriter_ptr_set)
    __swig_setmethods__["block_min"] = _cv.CvSeqWriter_block_min_set
    __swig_getmethods__["block_min"] = _cv.CvSeqWriter_block_min_get
    if _newclass:block_min = _swig_property(_cv.CvSeqWriter_block_min_get, _cv.CvSeqWriter_block_min_set)
    __swig_setmethods__["block_max"] = _cv.CvSeqWriter_block_max_set
    __swig_getmethods__["block_max"] = _cv.CvSeqWriter_block_max_get
    if _newclass:block_max = _swig_property(_cv.CvSeqWriter_block_max_get, _cv.CvSeqWriter_block_max_set)
    def __init__(self): 
        """__init__(self) -> CvSeqWriter"""
        this = _cv.new_CvSeqWriter()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSeqWriter
    __del__ = lambda self : None;
CvSeqWriter_swigregister = _cv.CvSeqWriter_swigregister
CvSeqWriter_swigregister(CvSeqWriter)

class CvSeqReader(_object):
    """Proxy of C++ CvSeqReader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSeqReader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSeqReader, name)
    __repr__ = _swig_repr
    __swig_setmethods__["header_size"] = _cv.CvSeqReader_header_size_set
    __swig_getmethods__["header_size"] = _cv.CvSeqReader_header_size_get
    if _newclass:header_size = _swig_property(_cv.CvSeqReader_header_size_get, _cv.CvSeqReader_header_size_set)
    __swig_setmethods__["seq"] = _cv.CvSeqReader_seq_set
    __swig_getmethods__["seq"] = _cv.CvSeqReader_seq_get
    if _newclass:seq = _swig_property(_cv.CvSeqReader_seq_get, _cv.CvSeqReader_seq_set)
    __swig_setmethods__["block"] = _cv.CvSeqReader_block_set
    __swig_getmethods__["block"] = _cv.CvSeqReader_block_get
    if _newclass:block = _swig_property(_cv.CvSeqReader_block_get, _cv.CvSeqReader_block_set)
    __swig_setmethods__["ptr"] = _cv.CvSeqReader_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvSeqReader_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvSeqReader_ptr_get, _cv.CvSeqReader_ptr_set)
    __swig_setmethods__["block_min"] = _cv.CvSeqReader_block_min_set
    __swig_getmethods__["block_min"] = _cv.CvSeqReader_block_min_get
    if _newclass:block_min = _swig_property(_cv.CvSeqReader_block_min_get, _cv.CvSeqReader_block_min_set)
    __swig_setmethods__["block_max"] = _cv.CvSeqReader_block_max_set
    __swig_getmethods__["block_max"] = _cv.CvSeqReader_block_max_get
    if _newclass:block_max = _swig_property(_cv.CvSeqReader_block_max_get, _cv.CvSeqReader_block_max_set)
    __swig_setmethods__["delta_index"] = _cv.CvSeqReader_delta_index_set
    __swig_getmethods__["delta_index"] = _cv.CvSeqReader_delta_index_get
    if _newclass:delta_index = _swig_property(_cv.CvSeqReader_delta_index_get, _cv.CvSeqReader_delta_index_set)
    __swig_setmethods__["prev_elem"] = _cv.CvSeqReader_prev_elem_set
    __swig_getmethods__["prev_elem"] = _cv.CvSeqReader_prev_elem_get
    if _newclass:prev_elem = _swig_property(_cv.CvSeqReader_prev_elem_get, _cv.CvSeqReader_prev_elem_set)
    def __init__(self): 
        """__init__(self) -> CvSeqReader"""
        this = _cv.new_CvSeqReader()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSeqReader
    __del__ = lambda self : None;
CvSeqReader_swigregister = _cv.CvSeqReader_swigregister
CvSeqReader_swigregister(CvSeqReader)

class CvAttrList(_object):
    """Proxy of C++ CvAttrList class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvAttrList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvAttrList, name)
    __repr__ = _swig_repr
    __swig_setmethods__["attr"] = _cv.CvAttrList_attr_set
    __swig_getmethods__["attr"] = _cv.CvAttrList_attr_get
    if _newclass:attr = _swig_property(_cv.CvAttrList_attr_get, _cv.CvAttrList_attr_set)
    __swig_setmethods__["next"] = _cv.CvAttrList_next_set
    __swig_getmethods__["next"] = _cv.CvAttrList_next_get
    if _newclass:next = _swig_property(_cv.CvAttrList_next_get, _cv.CvAttrList_next_set)
    def __init__(self): 
        """__init__(self) -> CvAttrList"""
        this = _cv.new_CvAttrList()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvAttrList
    __del__ = lambda self : None;
CvAttrList_swigregister = _cv.CvAttrList_swigregister
CvAttrList_swigregister(CvAttrList)

class CvString(_object):
    """Proxy of C++ CvString class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvString, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvString, name)
    __repr__ = _swig_repr
    __swig_setmethods__["len"] = _cv.CvString_len_set
    __swig_getmethods__["len"] = _cv.CvString_len_get
    if _newclass:len = _swig_property(_cv.CvString_len_get, _cv.CvString_len_set)
    __swig_setmethods__["ptr"] = _cv.CvString_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvString_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvString_ptr_get, _cv.CvString_ptr_set)
    def __init__(self): 
        """__init__(self) -> CvString"""
        this = _cv.new_CvString()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvString
    __del__ = lambda self : None;
CvString_swigregister = _cv.CvString_swigregister
CvString_swigregister(CvString)

def cvAttrList(attr = None, next = None):
  """
    cvAttrList(char attr = None, CvAttrList next = None) -> CvAttrList
    cvAttrList(char attr = None) -> CvAttrList
    cvAttrList() -> CvAttrList
    """
  return _cv.cvAttrList(attr, next)

class CvStringHashNode(_object):
    """Proxy of C++ CvStringHashNode class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvStringHashNode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvStringHashNode, name)
    __repr__ = _swig_repr
    __swig_setmethods__["hashval"] = _cv.CvStringHashNode_hashval_set
    __swig_getmethods__["hashval"] = _cv.CvStringHashNode_hashval_get
    if _newclass:hashval = _swig_property(_cv.CvStringHashNode_hashval_get, _cv.CvStringHashNode_hashval_set)
    __swig_setmethods__["str"] = _cv.CvStringHashNode_str_set
    __swig_getmethods__["str"] = _cv.CvStringHashNode_str_get
    if _newclass:str = _swig_property(_cv.CvStringHashNode_str_get, _cv.CvStringHashNode_str_set)
    __swig_setmethods__["next"] = _cv.CvStringHashNode_next_set
    __swig_getmethods__["next"] = _cv.CvStringHashNode_next_get
    if _newclass:next = _swig_property(_cv.CvStringHashNode_next_get, _cv.CvStringHashNode_next_set)
    def __init__(self): 
        """__init__(self) -> CvStringHashNode"""
        this = _cv.new_CvStringHashNode()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvStringHashNode
    __del__ = lambda self : None;
CvStringHashNode_swigregister = _cv.CvStringHashNode_swigregister
CvStringHashNode_swigregister(CvStringHashNode)

class CvFileNode(_object):
    """Proxy of C++ CvFileNode class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvFileNode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvFileNode, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tag"] = _cv.CvFileNode_tag_set
    __swig_getmethods__["tag"] = _cv.CvFileNode_tag_get
    if _newclass:tag = _swig_property(_cv.CvFileNode_tag_get, _cv.CvFileNode_tag_set)
    __swig_setmethods__["info"] = _cv.CvFileNode_info_set
    __swig_getmethods__["info"] = _cv.CvFileNode_info_get
    if _newclass:info = _swig_property(_cv.CvFileNode_info_get, _cv.CvFileNode_info_set)
    __swig_getmethods__["data"] = _cv.CvFileNode_data_get
    if _newclass:data = _swig_property(_cv.CvFileNode_data_get)
    def __init__(self): 
        """__init__(self) -> CvFileNode"""
        this = _cv.new_CvFileNode()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvFileNode
    __del__ = lambda self : None;
CvFileNode_swigregister = _cv.CvFileNode_swigregister
CvFileNode_swigregister(CvFileNode)

class CvFileNode_data(_object):
    """Proxy of C++ CvFileNode_data class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvFileNode_data, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvFileNode_data, name)
    __repr__ = _swig_repr
    __swig_setmethods__["f"] = _cv.CvFileNode_data_f_set
    __swig_getmethods__["f"] = _cv.CvFileNode_data_f_get
    if _newclass:f = _swig_property(_cv.CvFileNode_data_f_get, _cv.CvFileNode_data_f_set)
    __swig_setmethods__["i"] = _cv.CvFileNode_data_i_set
    __swig_getmethods__["i"] = _cv.CvFileNode_data_i_get
    if _newclass:i = _swig_property(_cv.CvFileNode_data_i_get, _cv.CvFileNode_data_i_set)
    __swig_setmethods__["str"] = _cv.CvFileNode_data_str_set
    __swig_getmethods__["str"] = _cv.CvFileNode_data_str_get
    if _newclass:str = _swig_property(_cv.CvFileNode_data_str_get, _cv.CvFileNode_data_str_set)
    __swig_setmethods__["seq"] = _cv.CvFileNode_data_seq_set
    __swig_getmethods__["seq"] = _cv.CvFileNode_data_seq_get
    if _newclass:seq = _swig_property(_cv.CvFileNode_data_seq_get, _cv.CvFileNode_data_seq_set)
    __swig_setmethods__["map"] = _cv.CvFileNode_data_map_set
    __swig_getmethods__["map"] = _cv.CvFileNode_data_map_get
    if _newclass:map = _swig_property(_cv.CvFileNode_data_map_get, _cv.CvFileNode_data_map_set)
    def __init__(self): 
        """__init__(self) -> CvFileNode_data"""
        this = _cv.new_CvFileNode_data()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvFileNode_data
    __del__ = lambda self : None;
CvFileNode_data_swigregister = _cv.CvFileNode_data_swigregister
CvFileNode_data_swigregister(CvFileNode_data)

class CvTypeInfo(_object):
    """Proxy of C++ CvTypeInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvTypeInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvTypeInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvTypeInfo_flags_set
    __swig_getmethods__["flags"] = _cv.CvTypeInfo_flags_get
    if _newclass:flags = _swig_property(_cv.CvTypeInfo_flags_get, _cv.CvTypeInfo_flags_set)
    __swig_setmethods__["header_size"] = _cv.CvTypeInfo_header_size_set
    __swig_getmethods__["header_size"] = _cv.CvTypeInfo_header_size_get
    if _newclass:header_size = _swig_property(_cv.CvTypeInfo_header_size_get, _cv.CvTypeInfo_header_size_set)
    __swig_setmethods__["prev"] = _cv.CvTypeInfo_prev_set
    __swig_getmethods__["prev"] = _cv.CvTypeInfo_prev_get
    if _newclass:prev = _swig_property(_cv.CvTypeInfo_prev_get, _cv.CvTypeInfo_prev_set)
    __swig_setmethods__["next"] = _cv.CvTypeInfo_next_set
    __swig_getmethods__["next"] = _cv.CvTypeInfo_next_get
    if _newclass:next = _swig_property(_cv.CvTypeInfo_next_get, _cv.CvTypeInfo_next_set)
    __swig_setmethods__["type_name"] = _cv.CvTypeInfo_type_name_set
    __swig_getmethods__["type_name"] = _cv.CvTypeInfo_type_name_get
    if _newclass:type_name = _swig_property(_cv.CvTypeInfo_type_name_get, _cv.CvTypeInfo_type_name_set)
    __swig_setmethods__["is_instance"] = _cv.CvTypeInfo_is_instance_set
    __swig_getmethods__["is_instance"] = _cv.CvTypeInfo_is_instance_get
    if _newclass:is_instance = _swig_property(_cv.CvTypeInfo_is_instance_get, _cv.CvTypeInfo_is_instance_set)
    __swig_setmethods__["release"] = _cv.CvTypeInfo_release_set
    __swig_getmethods__["release"] = _cv.CvTypeInfo_release_get
    if _newclass:release = _swig_property(_cv.CvTypeInfo_release_get, _cv.CvTypeInfo_release_set)
    __swig_setmethods__["read"] = _cv.CvTypeInfo_read_set
    __swig_getmethods__["read"] = _cv.CvTypeInfo_read_get
    if _newclass:read = _swig_property(_cv.CvTypeInfo_read_get, _cv.CvTypeInfo_read_set)
    __swig_setmethods__["write"] = _cv.CvTypeInfo_write_set
    __swig_getmethods__["write"] = _cv.CvTypeInfo_write_get
    if _newclass:write = _swig_property(_cv.CvTypeInfo_write_get, _cv.CvTypeInfo_write_set)
    __swig_setmethods__["clone"] = _cv.CvTypeInfo_clone_set
    __swig_getmethods__["clone"] = _cv.CvTypeInfo_clone_get
    if _newclass:clone = _swig_property(_cv.CvTypeInfo_clone_get, _cv.CvTypeInfo_clone_set)
    def __init__(self): 
        """__init__(self) -> CvTypeInfo"""
        this = _cv.new_CvTypeInfo()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvTypeInfo
    __del__ = lambda self : None;
CvTypeInfo_swigregister = _cv.CvTypeInfo_swigregister
CvTypeInfo_swigregister(CvTypeInfo)

class CvPluginFuncInfo(_object):
    """Proxy of C++ CvPluginFuncInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvPluginFuncInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvPluginFuncInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["func_addr"] = _cv.CvPluginFuncInfo_func_addr_set
    __swig_getmethods__["func_addr"] = _cv.CvPluginFuncInfo_func_addr_get
    if _newclass:func_addr = _swig_property(_cv.CvPluginFuncInfo_func_addr_get, _cv.CvPluginFuncInfo_func_addr_set)
    __swig_setmethods__["default_func_addr"] = _cv.CvPluginFuncInfo_default_func_addr_set
    __swig_getmethods__["default_func_addr"] = _cv.CvPluginFuncInfo_default_func_addr_get
    if _newclass:default_func_addr = _swig_property(_cv.CvPluginFuncInfo_default_func_addr_get, _cv.CvPluginFuncInfo_default_func_addr_set)
    __swig_setmethods__["func_names"] = _cv.CvPluginFuncInfo_func_names_set
    __swig_getmethods__["func_names"] = _cv.CvPluginFuncInfo_func_names_get
    if _newclass:func_names = _swig_property(_cv.CvPluginFuncInfo_func_names_get, _cv.CvPluginFuncInfo_func_names_set)
    __swig_setmethods__["search_modules"] = _cv.CvPluginFuncInfo_search_modules_set
    __swig_getmethods__["search_modules"] = _cv.CvPluginFuncInfo_search_modules_get
    if _newclass:search_modules = _swig_property(_cv.CvPluginFuncInfo_search_modules_get, _cv.CvPluginFuncInfo_search_modules_set)
    __swig_setmethods__["loaded_from"] = _cv.CvPluginFuncInfo_loaded_from_set
    __swig_getmethods__["loaded_from"] = _cv.CvPluginFuncInfo_loaded_from_get
    if _newclass:loaded_from = _swig_property(_cv.CvPluginFuncInfo_loaded_from_get, _cv.CvPluginFuncInfo_loaded_from_set)
    def __init__(self): 
        """__init__(self) -> CvPluginFuncInfo"""
        this = _cv.new_CvPluginFuncInfo()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvPluginFuncInfo
    __del__ = lambda self : None;
CvPluginFuncInfo_swigregister = _cv.CvPluginFuncInfo_swigregister
CvPluginFuncInfo_swigregister(CvPluginFuncInfo)

class CvModuleInfo(_object):
    """Proxy of C++ CvModuleInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvModuleInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvModuleInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["next"] = _cv.CvModuleInfo_next_set
    __swig_getmethods__["next"] = _cv.CvModuleInfo_next_get
    if _newclass:next = _swig_property(_cv.CvModuleInfo_next_get, _cv.CvModuleInfo_next_set)
    __swig_setmethods__["name"] = _cv.CvModuleInfo_name_set
    __swig_getmethods__["name"] = _cv.CvModuleInfo_name_get
    if _newclass:name = _swig_property(_cv.CvModuleInfo_name_get, _cv.CvModuleInfo_name_set)
    __swig_setmethods__["version"] = _cv.CvModuleInfo_version_set
    __swig_getmethods__["version"] = _cv.CvModuleInfo_version_get
    if _newclass:version = _swig_property(_cv.CvModuleInfo_version_get, _cv.CvModuleInfo_version_set)
    __swig_setmethods__["func_tab"] = _cv.CvModuleInfo_func_tab_set
    __swig_getmethods__["func_tab"] = _cv.CvModuleInfo_func_tab_get
    if _newclass:func_tab = _swig_property(_cv.CvModuleInfo_func_tab_get, _cv.CvModuleInfo_func_tab_set)
    def __init__(self): 
        """__init__(self) -> CvModuleInfo"""
        this = _cv.new_CvModuleInfo()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvModuleInfo
    __del__ = lambda self : None;
CvModuleInfo_swigregister = _cv.CvModuleInfo_swigregister
CvModuleInfo_swigregister(CvModuleInfo)


def cvAlloc(*args):
  """cvAlloc(size_t size) -> void"""
  return _cv.cvAlloc(*args)

def cvFree_(*args):
  """cvFree_(void ptr)"""
  return _cv.cvFree_(*args)

def cvResetImageROI(*args):
  """cvResetImageROI( image)"""
  return _cv.cvResetImageROI(*args)

def cvCreateMatHeader(*args):
  """cvCreateMatHeader(int rows, int cols, int type) -> CvMat"""
  return _cv.cvCreateMatHeader(*args)

def cvInitMatHeader(*args):
  """
    cvInitMatHeader(CvMat mat, int rows, int cols, int type, void data = None, 
        int step = 0x7fffffff) -> CvMat
    """
  return _cv.cvInitMatHeader(*args)

def cvCreateMat(*args):
  """cvCreateMat(int rows, int cols, int type) -> CvMat"""
  return _cv.cvCreateMat(*args)

def cvDecRefData(*args):
  """cvDecRefData(CvArr arr)"""
  return _cv.cvDecRefData(*args)

def cvIncRefData(*args):
  """cvIncRefData(CvArr arr) -> int"""
  return _cv.cvIncRefData(*args)

def cvCloneMat(*args):
  """cvCloneMat(CvMat mat) -> CvMat"""
  return _cv.cvCloneMat(*args)

def cvGetSubRect(*args):
  """cvGetSubRect(CvArr arr, CvRect rect) -> CvMat"""
  return _cv.cvGetSubRect(*args)

def cvGetRows(*args):
  """cvGetRows(CvArr arr, int start_row, int end_row, int delta_row = 1) -> CvMat"""
  return _cv.cvGetRows(*args)

def cvGetRow(*args):
  """cvGetRow(CvArr arr, int row) -> CvMat"""
  return _cv.cvGetRow(*args)

def cvGetCols(*args):
  """cvGetCols(CvArr arr, int start_col, int end_col) -> CvMat"""
  return _cv.cvGetCols(*args)

def cvGetCol(*args):
  """cvGetCol(CvArr arr, int col) -> CvMat"""
  return _cv.cvGetCol(*args)

def cvGetDiag(*args):
  """cvGetDiag(CvArr arr, int diag = 0) -> CvMat"""
  return _cv.cvGetDiag(*args)

def cvScalarToRawData(*args):
  """cvScalarToRawData(CvScalar scalar, void data, int type, int extend_to_12 = 0)"""
  return _cv.cvScalarToRawData(*args)

def cvRawDataToScalar(*args):
  """cvRawDataToScalar(void data, int type, CvScalar scalar)"""
  return _cv.cvRawDataToScalar(*args)

def cvCreateMatNDHeader(*args):
  """cvCreateMatNDHeader(int dims, int type) -> CvMatND"""
  return _cv.cvCreateMatNDHeader(*args)

def cvCreateMatND(*args):
  """cvCreateMatND(int dims, int type) -> CvMatND"""
  return _cv.cvCreateMatND(*args)

def cvInitMatNDHeader(*args):
  """cvInitMatNDHeader(CvMatND mat, int dims, int type, void data = None) -> CvMatND"""
  return _cv.cvInitMatNDHeader(*args)

def cvCloneMatND(*args):
  """cvCloneMatND(CvMatND mat) -> CvMatND"""
  return _cv.cvCloneMatND(*args)

def cvCreateSparseMat(*args):
  """cvCreateSparseMat(int dims, int type) -> CvSparseMat"""
  return _cv.cvCreateSparseMat(*args)

def cvCloneSparseMat(*args):
  """cvCloneSparseMat(CvSparseMat mat) -> CvSparseMat"""
  return _cv.cvCloneSparseMat(*args)

def cvInitSparseMatIterator(*args):
  """cvInitSparseMatIterator(CvSparseMat mat, CvSparseMatIterator mat_iterator) -> CvSparseNode"""
  return _cv.cvInitSparseMatIterator(*args)

def cvGetNextSparseNode(*args):
  """cvGetNextSparseNode(CvSparseMatIterator mat_iterator) -> CvSparseNode"""
  return _cv.cvGetNextSparseNode(*args)
class CvNArrayIterator(_object):
    """Proxy of C++ CvNArrayIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvNArrayIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvNArrayIterator, name)
    __repr__ = _swig_repr
    __swig_setmethods__["count"] = _cv.CvNArrayIterator_count_set
    __swig_getmethods__["count"] = _cv.CvNArrayIterator_count_get
    if _newclass:count = _swig_property(_cv.CvNArrayIterator_count_get, _cv.CvNArrayIterator_count_set)
    __swig_setmethods__["dims"] = _cv.CvNArrayIterator_dims_set
    __swig_getmethods__["dims"] = _cv.CvNArrayIterator_dims_get
    if _newclass:dims = _swig_property(_cv.CvNArrayIterator_dims_get, _cv.CvNArrayIterator_dims_set)
    __swig_setmethods__["size"] = _cv.CvNArrayIterator_size_set
    __swig_getmethods__["size"] = _cv.CvNArrayIterator_size_get
    if _newclass:size = _swig_property(_cv.CvNArrayIterator_size_get, _cv.CvNArrayIterator_size_set)
    __swig_setmethods__["ptr"] = _cv.CvNArrayIterator_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvNArrayIterator_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvNArrayIterator_ptr_get, _cv.CvNArrayIterator_ptr_set)
    __swig_setmethods__["stack"] = _cv.CvNArrayIterator_stack_set
    __swig_getmethods__["stack"] = _cv.CvNArrayIterator_stack_get
    if _newclass:stack = _swig_property(_cv.CvNArrayIterator_stack_get, _cv.CvNArrayIterator_stack_set)
    __swig_setmethods__["hdr"] = _cv.CvNArrayIterator_hdr_set
    __swig_getmethods__["hdr"] = _cv.CvNArrayIterator_hdr_get
    if _newclass:hdr = _swig_property(_cv.CvNArrayIterator_hdr_get, _cv.CvNArrayIterator_hdr_set)
    def __init__(self): 
        """__init__(self) -> CvNArrayIterator"""
        this = _cv.new_CvNArrayIterator()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvNArrayIterator
    __del__ = lambda self : None;
CvNArrayIterator_swigregister = _cv.CvNArrayIterator_swigregister
CvNArrayIterator_swigregister(CvNArrayIterator)


def cvInitNArrayIterator(*args):
  """
    cvInitNArrayIterator(int count, CvArr arrs, CvArr mask, CvMatND stubs, CvNArrayIterator array_iterator, 
        int flags = 0) -> int
    """
  return _cv.cvInitNArrayIterator(*args)

def cvNextNArraySlice(*args):
  """cvNextNArraySlice(CvNArrayIterator array_iterator) -> int"""
  return _cv.cvNextNArraySlice(*args)

def cvGetElemType(*args):
  """cvGetElemType(CvArr arr) -> int"""
  return _cv.cvGetElemType(*args)

def cvGetDims(*args):
  """cvGetDims(CvArr arr) -> int"""
  return _cv.cvGetDims(*args)

def cvGetDimSize(*args):
  """cvGetDimSize(CvArr arr, int index) -> int"""
  return _cv.cvGetDimSize(*args)

def cvPtr1D(*args):
  """cvPtr1D(CvArr arr, int idx0, int type = None) -> uchar"""
  return _cv.cvPtr1D(*args)

def cvPtr2D(*args):
  """cvPtr2D(CvArr arr, int idx0, int idx1, int type = None) -> uchar"""
  return _cv.cvPtr2D(*args)

def cvPtr3D(*args):
  """cvPtr3D(CvArr arr, int idx0, int idx1, int idx2, int type = None) -> uchar"""
  return _cv.cvPtr3D(*args)

def cvPtrND(*args):
  """
    cvPtrND(CvArr arr, int idx, int type = None, int create_node = 1, 
        unsigned int precalc_hashval = None) -> uchar
    """
  return _cv.cvPtrND(*args)

def cvGet1D(*args):
  """cvGet1D(CvArr arr, int idx0) -> CvScalar"""
  return _cv.cvGet1D(*args)

def cvGet2D(*args):
  """cvGet2D(CvArr arr, int idx0, int idx1) -> CvScalar"""
  return _cv.cvGet2D(*args)

def cvGet3D(*args):
  """cvGet3D(CvArr arr, int idx0, int idx1, int idx2) -> CvScalar"""
  return _cv.cvGet3D(*args)

def cvGetND(*args):
  """cvGetND(CvArr arr, int idx) -> CvScalar"""
  return _cv.cvGetND(*args)

def cvGetReal1D(*args):
  """cvGetReal1D(CvArr arr, int idx0) -> double"""
  return _cv.cvGetReal1D(*args)

def cvGetReal2D(*args):
  """cvGetReal2D(CvArr arr, int idx0, int idx1) -> double"""
  return _cv.cvGetReal2D(*args)

def cvGetReal3D(*args):
  """cvGetReal3D(CvArr arr, int idx0, int idx1, int idx2) -> double"""
  return _cv.cvGetReal3D(*args)

def cvGetRealND(*args):
  """cvGetRealND(CvArr arr, int idx) -> double"""
  return _cv.cvGetRealND(*args)

def cvSet1D(*args):
  """cvSet1D(CvArr arr, int idx0, CvScalar value)"""
  return _cv.cvSet1D(*args)

def cvSet2D(*args):
  """cvSet2D(CvArr arr, int idx0, int idx1, CvScalar value)"""
  return _cv.cvSet2D(*args)

def cvSet3D(*args):
  """cvSet3D(CvArr arr, int idx0, int idx1, int idx2, CvScalar value)"""
  return _cv.cvSet3D(*args)

def cvSetND(*args):
  """cvSetND(CvArr arr, int idx, CvScalar value)"""
  return _cv.cvSetND(*args)

def cvSetReal1D(*args):
  """cvSetReal1D(CvArr arr, int idx0, double value)"""
  return _cv.cvSetReal1D(*args)

def cvSetReal2D(*args):
  """cvSetReal2D(CvArr arr, int idx0, int idx1, double value)"""
  return _cv.cvSetReal2D(*args)

def cvSetReal3D(*args):
  """cvSetReal3D(CvArr arr, int idx0, int idx1, int idx2, double value)"""
  return _cv.cvSetReal3D(*args)

def cvSetRealND(*args):
  """cvSetRealND(CvArr arr, int idx, double value)"""
  return _cv.cvSetRealND(*args)

def cvClearND(*args):
  """cvClearND(CvArr arr, int idx)"""
  return _cv.cvClearND(*args)

def cvGetMat(*args):
  """cvGetMat(CvArr arr, int coi = None, int allowND = 0) -> CvMat"""
  return _cv.cvGetMat(*args)

def cvReshapeMatND(*args):
  """
    cvReshapeMatND(CvArr arr, int sizeof_header, CvArr header, int new_cn, 
        int new_dims, int new_sizes) -> CvArr
    """
  return _cv.cvReshapeMatND(*args)

def cvReshape(*args):
  """cvReshape(CvArr arr, int new_cn, int new_rows = 0) -> CvMat"""
  return _cv.cvReshape(*args)

def cvRepeat(*args):
  """cvRepeat(CvArr src, CvArr dst)"""
  return _cv.cvRepeat(*args)

def cvCreateData(*args):
  """cvCreateData(CvArr arr)"""
  return _cv.cvCreateData(*args)

def cvReleaseData(*args):
  """cvReleaseData(CvArr arr)"""
  return _cv.cvReleaseData(*args)

def cvSetData(*args):
  """cvSetData(CvArr arr, void data, int step)"""
  return _cv.cvSetData(*args)

def cvGetRawData(*args):
  """cvGetRawData(CvArr arr, uchar data, int step = None, CvSize roi_size = None)"""
  return _cv.cvGetRawData(*args)

def cvGetSize(*args):
  """cvGetSize(CvArr arr) -> CvSize"""
  return _cv.cvGetSize(*args)

def cvCopy(*args):
  """cvCopy(CvArr src, CvArr dst, CvArr mask = None)"""
  return _cv.cvCopy(*args)

def cvSet(*args):
  """cvSet(CvArr arr, CvScalar value, CvArr mask = None)"""
  return _cv.cvSet(*args)

def cvSetZero(*args):
  """cvSetZero(CvArr arr)"""
  return _cv.cvSetZero(*args)

def cvSplit(*args):
  """cvSplit(CvArr src, CvArr dst0, CvArr dst1, CvArr dst2, CvArr dst3)"""
  return _cv.cvSplit(*args)

def cvMerge(*args):
  """cvMerge(CvArr src0, CvArr src1, CvArr src2, CvArr src3, CvArr dst)"""
  return _cv.cvMerge(*args)

def cvMixChannels(*args):
  """
    cvMixChannels(CvArr src, int src_count, CvArr dst, int dst_count, 
        int from_to, int pair_count)
    """
  return _cv.cvMixChannels(*args)

def cvConvertScale(*args):
  """cvConvertScale(CvArr src, CvArr dst, double scale = 1, double shift = 0)"""
  return _cv.cvConvertScale(*args)

def cvConvertScaleAbs(*args):
  """cvConvertScaleAbs(CvArr src, CvArr dst, double scale = 1, double shift = 0)"""
  return _cv.cvConvertScaleAbs(*args)

def cvCheckTermCriteria(*args):
  """cvCheckTermCriteria(CvTermCriteria criteria, double default_eps, int default_max_iters) -> CvTermCriteria"""
  return _cv.cvCheckTermCriteria(*args)

def cvAdd(*args):
  """cvAdd(CvArr src1, CvArr src2, CvArr dst, CvArr mask = None)"""
  return _cv.cvAdd(*args)

def cvAddS(*args):
  """cvAddS(CvArr src, CvScalar value, CvArr dst, CvArr mask = None)"""
  return _cv.cvAddS(*args)

def cvSub(*args):
  """cvSub(CvArr src1, CvArr src2, CvArr dst, CvArr mask = None)"""
  return _cv.cvSub(*args)

def cvSubS(*args):
  """cvSubS(CvArr src, CvScalar value, CvArr dst, CvArr mask = None)"""
  return _cv.cvSubS(*args)

def cvSubRS(*args):
  """cvSubRS(CvArr src, CvScalar value, CvArr dst, CvArr mask = None)"""
  return _cv.cvSubRS(*args)

def cvMul(*args):
  """cvMul(CvArr src1, CvArr src2, CvArr dst, double scale = 1)"""
  return _cv.cvMul(*args)

def cvDiv(*args):
  """cvDiv(CvArr src1, CvArr src2, CvArr dst, double scale = 1)"""
  return _cv.cvDiv(*args)

def cvScaleAdd(*args):
  """cvScaleAdd(CvArr src1, CvScalar scale, CvArr src2, CvArr dst)"""
  return _cv.cvScaleAdd(*args)

def cvAddWeighted(*args):
  """
    cvAddWeighted(CvArr src1, double alpha, CvArr src2, double beta, 
        double gamma, CvArr dst)
    """
  return _cv.cvAddWeighted(*args)

def cvDotProduct(*args):
  """cvDotProduct(CvArr src1, CvArr src2) -> double"""
  return _cv.cvDotProduct(*args)

def cvAnd(*args):
  """cvAnd(CvArr src1, CvArr src2, CvArr dst, CvArr mask = None)"""
  return _cv.cvAnd(*args)

def cvAndS(*args):
  """cvAndS(CvArr src, CvScalar value, CvArr dst, CvArr mask = None)"""
  return _cv.cvAndS(*args)

def cvOr(*args):
  """cvOr(CvArr src1, CvArr src2, CvArr dst, CvArr mask = None)"""
  return _cv.cvOr(*args)

def cvOrS(*args):
  """cvOrS(CvArr src, CvScalar value, CvArr dst, CvArr mask = None)"""
  return _cv.cvOrS(*args)

def cvXor(*args):
  """cvXor(CvArr src1, CvArr src2, CvArr dst, CvArr mask = None)"""
  return _cv.cvXor(*args)

def cvXorS(*args):
  """cvXorS(CvArr src, CvScalar value, CvArr dst, CvArr mask = None)"""
  return _cv.cvXorS(*args)

def cvNot(*args):
  """cvNot(CvArr src, CvArr dst)"""
  return _cv.cvNot(*args)

def cvInRange(*args):
  """cvInRange(CvArr src, CvArr lower, CvArr upper, CvArr dst)"""
  return _cv.cvInRange(*args)

def cvInRangeS(*args):
  """cvInRangeS(CvArr src, CvScalar lower, CvScalar upper, CvArr dst)"""
  return _cv.cvInRangeS(*args)

def cvCmp(*args):
  """cvCmp(CvArr src1, CvArr src2, CvArr dst, int cmp_op)"""
  return _cv.cvCmp(*args)

def cvCmpS(*args):
  """cvCmpS(CvArr src, double value, CvArr dst, int cmp_op)"""
  return _cv.cvCmpS(*args)

def cvMin(*args):
  """cvMin(CvArr src1, CvArr src2, CvArr dst)"""
  return _cv.cvMin(*args)

def cvMax(*args):
  """cvMax(CvArr src1, CvArr src2, CvArr dst)"""
  return _cv.cvMax(*args)

def cvMinS(*args):
  """cvMinS(CvArr src, double value, CvArr dst)"""
  return _cv.cvMinS(*args)

def cvMaxS(*args):
  """cvMaxS(CvArr src, double value, CvArr dst)"""
  return _cv.cvMaxS(*args)

def cvAbsDiff(*args):
  """cvAbsDiff(CvArr src1, CvArr src2, CvArr dst)"""
  return _cv.cvAbsDiff(*args)

def cvAbsDiffS(*args):
  """cvAbsDiffS(CvArr src, CvArr dst, CvScalar value)"""
  return _cv.cvAbsDiffS(*args)

def cvCartToPolar(*args):
  """
    cvCartToPolar(CvArr x, CvArr y, CvArr magnitude, CvArr angle = None, 
        int angle_in_degrees = 0)
    """
  return _cv.cvCartToPolar(*args)

def cvPolarToCart(*args):
  """cvPolarToCart(CvArr magnitude, CvArr angle, CvArr x, CvArr y, int angle_in_degrees = 0)"""
  return _cv.cvPolarToCart(*args)

def cvPow(*args):
  """cvPow(CvArr src, CvArr dst, double power)"""
  return _cv.cvPow(*args)

def cvExp(*args):
  """cvExp(CvArr src, CvArr dst)"""
  return _cv.cvExp(*args)

def cvLog(*args):
  """cvLog(CvArr src, CvArr dst)"""
  return _cv.cvLog(*args)

def cvFastArctan(*args):
  """cvFastArctan(float y, float x) -> float"""
  return _cv.cvFastArctan(*args)

def cvCbrt(*args):
  """cvCbrt(float value) -> float"""
  return _cv.cvCbrt(*args)

def cvCheckArr(*args):
  """cvCheckArr(CvArr arr, int flags = 0, double min_val = 0, double max_val = 0) -> int"""
  return _cv.cvCheckArr(*args)

def cvRandArr(*args):
  """
    cvRandArr(CvRNG rng, CvArr arr, int dist_type, CvScalar param1, 
        CvScalar param2)
    """
  return _cv.cvRandArr(*args)

def cvRandShuffle(*args):
  """cvRandShuffle(CvArr mat, CvRNG rng, double iter_factor = 1.)"""
  return _cv.cvRandShuffle(*args)

def cvSort(*args):
  """cvSort(CvArr src, CvArr dst = None, CvArr idxmat = None, int flags = 0)"""
  return _cv.cvSort(*args)

def cvSolveCubic(*args):
  """cvSolveCubic(CvMat coeffs) -> int"""
  return _cv.cvSolveCubic(*args)

def cvSolvePoly(*args):
  """cvSolvePoly(CvMat coeffs, int maxiter = 20, int fig = 100)"""
  return _cv.cvSolvePoly(*args)

def cvCrossProduct(*args):
  """cvCrossProduct(CvArr src1, CvArr src2, CvArr dst)"""
  return _cv.cvCrossProduct(*args)

def cvGEMM(*args):
  """
    cvGEMM(CvArr src1, CvArr src2, double alpha, CvArr src3, double beta, 
        CvArr dst, int tABC = 0)
    """
  return _cv.cvGEMM(*args)

def cvTransform(*args):
  """cvTransform(CvArr src, CvArr dst, CvMat transmat, CvMat shiftvec = None)"""
  return _cv.cvTransform(*args)

def cvPerspectiveTransform(*args):
  """cvPerspectiveTransform(CvArr src, CvArr dst, CvMat mat)"""
  return _cv.cvPerspectiveTransform(*args)

def cvMulTransposed(*args):
  """
    cvMulTransposed(CvArr src, CvArr dst, int order, CvArr delta = None, 
        double scale = 1.)
    """
  return _cv.cvMulTransposed(*args)

def cvTranspose(*args):
  """cvTranspose(CvArr src, CvArr dst)"""
  return _cv.cvTranspose(*args)

def cvCompleteSymm(*args):
  """cvCompleteSymm(CvMat matrix, int LtoR = 0)"""
  return _cv.cvCompleteSymm(*args)

def cvFlip(*args):
  """cvFlip(CvArr src, CvArr dst = None, int flip_mode = 0)"""
  return _cv.cvFlip(*args)

def cvSVD(*args):
  """cvSVD(CvArr A, CvArr W, CvArr U = None, CvArr V = None, int flags = 0)"""
  return _cv.cvSVD(*args)

def cvSVBkSb(*args):
  """cvSVBkSb(CvArr W, CvArr U, CvArr V, CvArr B, CvArr X, int flags)"""
  return _cv.cvSVBkSb(*args)

def cvInvert(*args):
  """cvInvert(CvArr src, CvArr dst, int method = 0) -> double"""
  return _cv.cvInvert(*args)

def cvSolve(*args):
  """cvSolve(CvArr src1, CvArr src2, CvArr dst, int method = 0) -> int"""
  return _cv.cvSolve(*args)

def cvDet(*args):
  """cvDet(CvArr mat) -> double"""
  return _cv.cvDet(*args)

def cvTrace(*args):
  """cvTrace(CvArr mat) -> CvScalar"""
  return _cv.cvTrace(*args)

def cvEigenVV(*args):
  """
    cvEigenVV(CvArr mat, CvArr evects, CvArr evals, double eps = 0, 
        int lowindex = -1, int highindex = -1)
    """
  return _cv.cvEigenVV(*args)

def cvSetIdentity(*args):
  """cvSetIdentity(CvArr mat, CvScalar value = cvRealScalar(1))"""
  return _cv.cvSetIdentity(*args)

def cvRange(*args):
  """cvRange(CvArr mat, double start, double end) -> CvArr"""
  return _cv.cvRange(*args)

def cvCalcCovarMatrix(*args):
  """cvCalcCovarMatrix(CvArr vects, int count, CvArr cov_mat, CvArr avg, int flags)"""
  return _cv.cvCalcCovarMatrix(*args)

def cvCalcPCA(*args):
  """
    cvCalcPCA(CvArr data, CvArr mean, CvArr eigenvals, CvArr eigenvects, 
        int flags)
    """
  return _cv.cvCalcPCA(*args)

def cvProjectPCA(*args):
  """cvProjectPCA(CvArr data, CvArr mean, CvArr eigenvects, CvArr result)"""
  return _cv.cvProjectPCA(*args)

def cvBackProjectPCA(*args):
  """cvBackProjectPCA(CvArr proj, CvArr mean, CvArr eigenvects, CvArr result)"""
  return _cv.cvBackProjectPCA(*args)

def cvMahalanobis(*args):
  """cvMahalanobis(CvArr vec1, CvArr vec2, CvArr mat) -> double"""
  return _cv.cvMahalanobis(*args)

def cvSum(*args):
  """cvSum(CvArr arr) -> CvScalar"""
  return _cv.cvSum(*args)

def cvCountNonZero(*args):
  """cvCountNonZero(CvArr arr) -> int"""
  return _cv.cvCountNonZero(*args)

def cvAvg(*args):
  """cvAvg(CvArr arr, CvArr mask = None) -> CvScalar"""
  return _cv.cvAvg(*args)

def cvAvgSdv(*args):
  """cvAvgSdv(CvArr arr, CvScalar mean, CvScalar std_dev, CvArr mask = None)"""
  return _cv.cvAvgSdv(*args)

def cvMinMaxLoc(*args):
  """cvMinMaxLoc(CvArr arr, CvArr mask = None)"""
  return _cv.cvMinMaxLoc(*args)

def cvNorm(*args):
  """cvNorm(CvArr arr1, CvArr arr2 = None, int norm_type = 4, CvArr mask = None) -> double"""
  return _cv.cvNorm(*args)

def cvNormalize(*args):
  """
    cvNormalize(CvArr src, CvArr dst, double a = 1., double b = 0., 
        int norm_type = 4, CvArr mask = None)
    """
  return _cv.cvNormalize(*args)

def cvReduce(*args):
  """cvReduce(CvArr src, CvArr dst, int dim = -1, int op = 0)"""
  return _cv.cvReduce(*args)

def cvDFT(*args):
  """cvDFT(CvArr src, CvArr dst, int flags, int nonzero_rows = 0)"""
  return _cv.cvDFT(*args)

def cvMulSpectrums(*args):
  """cvMulSpectrums(CvArr src1, CvArr src2, CvArr dst, int flags)"""
  return _cv.cvMulSpectrums(*args)

def cvGetOptimalDFTSize(*args):
  """cvGetOptimalDFTSize(int size0) -> int"""
  return _cv.cvGetOptimalDFTSize(*args)

def cvDCT(*args):
  """cvDCT(CvArr src, CvArr dst, int flags)"""
  return _cv.cvDCT(*args)

def cvSliceLength(*args):
  """cvSliceLength(CvSlice slice, CvSeq seq) -> int"""
  return _cv.cvSliceLength(*args)

def cvCreateMemStorage(block_size = 0):
  """cvCreateMemStorage(int block_size = 0) -> CvMemStorage"""
  return _cv.cvCreateMemStorage(block_size)

def cvCreateChildMemStorage(*args):
  """cvCreateChildMemStorage(CvMemStorage parent) -> CvMemStorage"""
  return _cv.cvCreateChildMemStorage(*args)

def cvClearMemStorage(*args):
  """cvClearMemStorage(CvMemStorage storage)"""
  return _cv.cvClearMemStorage(*args)

def cvSaveMemStoragePos(*args):
  """cvSaveMemStoragePos(CvMemStorage storage, CvMemStoragePos pos)"""
  return _cv.cvSaveMemStoragePos(*args)

def cvRestoreMemStoragePos(*args):
  """cvRestoreMemStoragePos(CvMemStorage storage, CvMemStoragePos pos)"""
  return _cv.cvRestoreMemStoragePos(*args)

def cvMemStorageAlloc(*args):
  """cvMemStorageAlloc(CvMemStorage storage, size_t size) -> void"""
  return _cv.cvMemStorageAlloc(*args)

def cvMemStorageAllocString(*args):
  """cvMemStorageAllocString(CvMemStorage storage, char ptr, int len = -1) -> CvString"""
  return _cv.cvMemStorageAllocString(*args)

def cvCreateSeq(*args):
  """cvCreateSeq(int seq_flags, int header_size, int elem_size, CvMemStorage storage) -> CvSeq"""
  return _cv.cvCreateSeq(*args)

def cvSetSeqBlockSize(*args):
  """cvSetSeqBlockSize(CvSeq seq, int delta_elems)"""
  return _cv.cvSetSeqBlockSize(*args)

def cvSeqPush(*args):
  """cvSeqPush(CvSeq seq, void element = None) -> schar"""
  return _cv.cvSeqPush(*args)

def cvSeqPushFront(*args):
  """cvSeqPushFront(CvSeq seq, void element = None) -> schar"""
  return _cv.cvSeqPushFront(*args)

def cvSeqPop(*args):
  """cvSeqPop(CvSeq seq, void element = None)"""
  return _cv.cvSeqPop(*args)

def cvSeqPopFront(*args):
  """cvSeqPopFront(CvSeq seq, void element = None)"""
  return _cv.cvSeqPopFront(*args)

def cvSeqPushMulti(*args):
  """cvSeqPushMulti(CvSeq seq, void elements, int count, int in_front = 0)"""
  return _cv.cvSeqPushMulti(*args)

def cvSeqPopMulti(*args):
  """cvSeqPopMulti(CvSeq seq, void elements, int count, int in_front = 0)"""
  return _cv.cvSeqPopMulti(*args)

def cvSeqInsert(*args):
  """cvSeqInsert(CvSeq seq, int before_index, void element = None) -> schar"""
  return _cv.cvSeqInsert(*args)

def cvSeqRemove(*args):
  """cvSeqRemove(CvSeq seq, int index)"""
  return _cv.cvSeqRemove(*args)

def cvClearSeq(*args):
  """cvClearSeq(CvSeq seq)"""
  return _cv.cvClearSeq(*args)

def cvGetSeqElem(*args):
  """cvGetSeqElem(CvSeq seq, int index) -> schar"""
  return _cv.cvGetSeqElem(*args)

def cvSeqElemIdx(*args):
  """cvSeqElemIdx(CvSeq seq, void element, CvSeqBlock block = None) -> int"""
  return _cv.cvSeqElemIdx(*args)

def cvStartAppendToSeq(*args):
  """cvStartAppendToSeq(CvSeq seq, CvSeqWriter writer)"""
  return _cv.cvStartAppendToSeq(*args)

def cvStartWriteSeq(*args):
  """
    cvStartWriteSeq(int seq_flags, int header_size, int elem_size, CvMemStorage storage, 
        CvSeqWriter writer)
    """
  return _cv.cvStartWriteSeq(*args)

def cvEndWriteSeq(*args):
  """cvEndWriteSeq(CvSeqWriter writer) -> CvSeq"""
  return _cv.cvEndWriteSeq(*args)

def cvFlushSeqWriter(*args):
  """cvFlushSeqWriter(CvSeqWriter writer)"""
  return _cv.cvFlushSeqWriter(*args)

def cvStartReadSeq(*args):
  """cvStartReadSeq(CvSeq seq, CvSeqReader reader, int reverse = 0)"""
  return _cv.cvStartReadSeq(*args)

def cvGetSeqReaderPos(*args):
  """cvGetSeqReaderPos(CvSeqReader reader) -> int"""
  return _cv.cvGetSeqReaderPos(*args)

def cvSetSeqReaderPos(*args):
  """cvSetSeqReaderPos(CvSeqReader reader, int index, int is_relative = 0)"""
  return _cv.cvSetSeqReaderPos(*args)

def cvMakeSeqHeaderForArray(*args):
  """
    cvMakeSeqHeaderForArray(int seq_type, int header_size, int elem_size, void elements, 
        int total, CvSeq seq, CvSeqBlock block) -> CvSeq
    """
  return _cv.cvMakeSeqHeaderForArray(*args)

def cvSeqSlice(*args):
  """
    cvSeqSlice(CvSeq seq, CvSlice slice, CvMemStorage storage = None, 
        int copy_data = 0) -> CvSeq
    """
  return _cv.cvSeqSlice(*args)

def cvCloneSeq(*args):
  """cvCloneSeq(CvSeq seq, CvMemStorage storage = None) -> CvSeq"""
  return _cv.cvCloneSeq(*args)

def cvSeqRemoveSlice(*args):
  """cvSeqRemoveSlice(CvSeq seq, CvSlice slice)"""
  return _cv.cvSeqRemoveSlice(*args)

def cvSeqInsertSlice(*args):
  """cvSeqInsertSlice(CvSeq seq, int before_index, CvArr from_arr)"""
  return _cv.cvSeqInsertSlice(*args)

def cvSeqSort(*args):
  """cvSeqSort(CvSeq seq, CvCmpFunc func, void userdata = None)"""
  return _cv.cvSeqSort(*args)

def cvSeqSearch(*args):
  """
    cvSeqSearch(CvSeq seq, void elem, CvCmpFunc func, int is_sorted, 
        int elem_idx, void userdata = None) -> schar
    """
  return _cv.cvSeqSearch(*args)

def cvSeqInvert(*args):
  """cvSeqInvert(CvSeq seq)"""
  return _cv.cvSeqInvert(*args)

def cvSeqPartition(*args):
  """
    cvSeqPartition(CvSeq seq, CvMemStorage storage, CvSeq labels, CvCmpFunc is_equal, 
        void userdata) -> int
    """
  return _cv.cvSeqPartition(*args)

def cvChangeSeqBlock(*args):
  """cvChangeSeqBlock(void reader, int direction)"""
  return _cv.cvChangeSeqBlock(*args)

def cvCreateSeqBlock(*args):
  """cvCreateSeqBlock(CvSeqWriter writer)"""
  return _cv.cvCreateSeqBlock(*args)

def cvCreateSet(*args):
  """cvCreateSet(int set_flags, int header_size, int elem_size, CvMemStorage storage) -> CvSet"""
  return _cv.cvCreateSet(*args)

def cvSetAdd(*args):
  """cvSetAdd(CvSet set_header, CvSetElem elem = None, CvSetElem inserted_elem = None) -> int"""
  return _cv.cvSetAdd(*args)

def cvSetNew(*args):
  """cvSetNew(CvSet set_header) -> CvSetElem"""
  return _cv.cvSetNew(*args)

def cvSetRemoveByPtr(*args):
  """cvSetRemoveByPtr(CvSet set_header, void elem)"""
  return _cv.cvSetRemoveByPtr(*args)

def cvSetRemove(*args):
  """cvSetRemove(CvSet set_header, int index)"""
  return _cv.cvSetRemove(*args)

def cvGetSetElem(*args):
  """cvGetSetElem(CvSet set_header, int index) -> CvSetElem"""
  return _cv.cvGetSetElem(*args)

def cvClearSet(*args):
  """cvClearSet(CvSet set_header)"""
  return _cv.cvClearSet(*args)

def cvCreateGraph(*args):
  """
    cvCreateGraph(int graph_flags, int header_size, int vtx_size, int edge_size, 
        CvMemStorage storage) -> CvGraph
    """
  return _cv.cvCreateGraph(*args)

def cvGraphAddVtx(*args):
  """cvGraphAddVtx(CvGraph graph, CvGraphVtx vtx = None, CvGraphVtx inserted_vtx = None) -> int"""
  return _cv.cvGraphAddVtx(*args)

def cvGraphRemoveVtx(*args):
  """cvGraphRemoveVtx(CvGraph graph, int index) -> int"""
  return _cv.cvGraphRemoveVtx(*args)

def cvGraphRemoveVtxByPtr(*args):
  """cvGraphRemoveVtxByPtr(CvGraph graph, CvGraphVtx vtx) -> int"""
  return _cv.cvGraphRemoveVtxByPtr(*args)

def cvGraphAddEdge(*args):
  """
    cvGraphAddEdge(CvGraph graph, int start_idx, int end_idx, CvGraphEdge edge = None, 
        CvGraphEdge inserted_edge = None) -> int
    """
  return _cv.cvGraphAddEdge(*args)

def cvGraphAddEdgeByPtr(*args):
  """
    cvGraphAddEdgeByPtr(CvGraph graph, CvGraphVtx start_vtx, CvGraphVtx end_vtx, 
        CvGraphEdge edge = None, CvGraphEdge inserted_edge = None) -> int
    """
  return _cv.cvGraphAddEdgeByPtr(*args)

def cvGraphRemoveEdge(*args):
  """cvGraphRemoveEdge(CvGraph graph, int start_idx, int end_idx)"""
  return _cv.cvGraphRemoveEdge(*args)

def cvGraphRemoveEdgeByPtr(*args):
  """cvGraphRemoveEdgeByPtr(CvGraph graph, CvGraphVtx start_vtx, CvGraphVtx end_vtx)"""
  return _cv.cvGraphRemoveEdgeByPtr(*args)

def cvFindGraphEdge(*args):
  """cvFindGraphEdge(CvGraph graph, int start_idx, int end_idx) -> CvGraphEdge"""
  return _cv.cvFindGraphEdge(*args)

def cvFindGraphEdgeByPtr(*args):
  """cvFindGraphEdgeByPtr(CvGraph graph, CvGraphVtx start_vtx, CvGraphVtx end_vtx) -> CvGraphEdge"""
  return _cv.cvFindGraphEdgeByPtr(*args)

def cvClearGraph(*args):
  """cvClearGraph(CvGraph graph)"""
  return _cv.cvClearGraph(*args)

def cvGraphVtxDegree(*args):
  """cvGraphVtxDegree(CvGraph graph, int vtx_idx) -> int"""
  return _cv.cvGraphVtxDegree(*args)

def cvGraphVtxDegreeByPtr(*args):
  """cvGraphVtxDegreeByPtr(CvGraph graph, CvGraphVtx vtx) -> int"""
  return _cv.cvGraphVtxDegreeByPtr(*args)
class CvGraphScanner(_object):
    """Proxy of C++ CvGraphScanner class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvGraphScanner, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvGraphScanner, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["vtx"] = _cv.CvGraphScanner_vtx_set
    __swig_getmethods__["vtx"] = _cv.CvGraphScanner_vtx_get
    if _newclass:vtx = _swig_property(_cv.CvGraphScanner_vtx_get, _cv.CvGraphScanner_vtx_set)
    __swig_setmethods__["dst"] = _cv.CvGraphScanner_dst_set
    __swig_getmethods__["dst"] = _cv.CvGraphScanner_dst_get
    if _newclass:dst = _swig_property(_cv.CvGraphScanner_dst_get, _cv.CvGraphScanner_dst_set)
    __swig_setmethods__["edge"] = _cv.CvGraphScanner_edge_set
    __swig_getmethods__["edge"] = _cv.CvGraphScanner_edge_get
    if _newclass:edge = _swig_property(_cv.CvGraphScanner_edge_get, _cv.CvGraphScanner_edge_set)
    __swig_setmethods__["graph"] = _cv.CvGraphScanner_graph_set
    __swig_getmethods__["graph"] = _cv.CvGraphScanner_graph_get
    if _newclass:graph = _swig_property(_cv.CvGraphScanner_graph_get, _cv.CvGraphScanner_graph_set)
    __swig_setmethods__["stack"] = _cv.CvGraphScanner_stack_set
    __swig_getmethods__["stack"] = _cv.CvGraphScanner_stack_get
    if _newclass:stack = _swig_property(_cv.CvGraphScanner_stack_get, _cv.CvGraphScanner_stack_set)
    __swig_setmethods__["index"] = _cv.CvGraphScanner_index_set
    __swig_getmethods__["index"] = _cv.CvGraphScanner_index_get
    if _newclass:index = _swig_property(_cv.CvGraphScanner_index_get, _cv.CvGraphScanner_index_set)
    __swig_setmethods__["mask"] = _cv.CvGraphScanner_mask_set
    __swig_getmethods__["mask"] = _cv.CvGraphScanner_mask_get
    if _newclass:mask = _swig_property(_cv.CvGraphScanner_mask_get, _cv.CvGraphScanner_mask_set)
    __swig_destroy__ = _cv.delete_CvGraphScanner
    __del__ = lambda self : None;
CvGraphScanner_swigregister = _cv.CvGraphScanner_swigregister
CvGraphScanner_swigregister(CvGraphScanner)


def cvCreateGraphScanner(*args):
  """cvCreateGraphScanner(CvGraph graph, CvGraphVtx vtx = None, int mask = -1) -> CvGraphScanner"""
  return _cv.cvCreateGraphScanner(*args)

def cvNextGraphItem(*args):
  """cvNextGraphItem(CvGraphScanner scanner) -> int"""
  return _cv.cvNextGraphItem(*args)

def cvCloneGraph(*args):
  """cvCloneGraph(CvGraph graph, CvMemStorage storage) -> CvGraph"""
  return _cv.cvCloneGraph(*args)

def cvLine(*args):
  """
    cvLine(CvArr img, CvPoint pt1, CvPoint pt2, CvScalar color, 
        int thickness = 1, int line_type = 8, int shift = 0)
    """
  return _cv.cvLine(*args)

def cvRectangle(*args):
  """
    cvRectangle(CvArr img, CvPoint pt1, CvPoint pt2, CvScalar color, 
        int thickness = 1, int line_type = 8, int shift = 0)
    """
  return _cv.cvRectangle(*args)

def cvCircle(*args):
  """
    cvCircle(CvArr img, CvPoint center, int radius, CvScalar color, 
        int thickness = 1, int line_type = 8, int shift = 0)
    """
  return _cv.cvCircle(*args)

def cvEllipse(*args):
  """
    cvEllipse(CvArr img, CvPoint center, CvSize axes, double angle, 
        double start_angle, double end_angle, CvScalar color, 
        int thickness = 1, int line_type = 8, 
        int shift = 0)
    """
  return _cv.cvEllipse(*args)

def cvEllipseBox(*args):
  """
    cvEllipseBox(CvArr img, CvBox2D box, CvScalar color, int thickness = 1, 
        int line_type = 8, int shift = 0)
    """
  return _cv.cvEllipseBox(*args)

def cvFillConvexPoly(*args):
  """
    cvFillConvexPoly(CvArr img, CvPoint pts, int npts, CvScalar color, int line_type = 8, 
        int shift = 0)
    """
  return _cv.cvFillConvexPoly(*args)

def cvFillPoly(*args):
  """
    cvFillPoly(CvArr img, CvPoint pts, int npts, int contours, CvScalar color, 
        int line_type = 8, int shift = 0)
    """
  return _cv.cvFillPoly(*args)

def cvPolyLine(*args):
  """
    cvPolyLine(CvArr img, CvPoint pts, int npts, int contours, int is_closed, 
        CvScalar color, int thickness = 1, 
        int line_type = 8, int shift = 0)
    """
  return _cv.cvPolyLine(*args)

def cvClipLine(*args):
  """cvClipLine(CvSize img_size, CvPoint pt1, CvPoint pt2) -> int"""
  return _cv.cvClipLine(*args)

def cvInitLineIterator(*args):
  """
    cvInitLineIterator(CvArr image, CvPoint pt1, CvPoint pt2, CvLineIterator line_iterator, 
        int connectivity = 8, int left_to_right = 0) -> int
    """
  return _cv.cvInitLineIterator(*args)
class CvFont(_object):
    """Proxy of C++ CvFont class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvFont, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvFont, name)
    __repr__ = _swig_repr
    __swig_setmethods__["font_face"] = _cv.CvFont_font_face_set
    __swig_getmethods__["font_face"] = _cv.CvFont_font_face_get
    if _newclass:font_face = _swig_property(_cv.CvFont_font_face_get, _cv.CvFont_font_face_set)
    __swig_setmethods__["ascii"] = _cv.CvFont_ascii_set
    __swig_getmethods__["ascii"] = _cv.CvFont_ascii_get
    if _newclass:ascii = _swig_property(_cv.CvFont_ascii_get, _cv.CvFont_ascii_set)
    __swig_setmethods__["greek"] = _cv.CvFont_greek_set
    __swig_getmethods__["greek"] = _cv.CvFont_greek_get
    if _newclass:greek = _swig_property(_cv.CvFont_greek_get, _cv.CvFont_greek_set)
    __swig_setmethods__["cyrillic"] = _cv.CvFont_cyrillic_set
    __swig_getmethods__["cyrillic"] = _cv.CvFont_cyrillic_get
    if _newclass:cyrillic = _swig_property(_cv.CvFont_cyrillic_get, _cv.CvFont_cyrillic_set)
    __swig_setmethods__["hscale"] = _cv.CvFont_hscale_set
    __swig_getmethods__["hscale"] = _cv.CvFont_hscale_get
    if _newclass:hscale = _swig_property(_cv.CvFont_hscale_get, _cv.CvFont_hscale_set)
    __swig_setmethods__["vscale"] = _cv.CvFont_vscale_set
    __swig_getmethods__["vscale"] = _cv.CvFont_vscale_get
    if _newclass:vscale = _swig_property(_cv.CvFont_vscale_get, _cv.CvFont_vscale_set)
    __swig_setmethods__["shear"] = _cv.CvFont_shear_set
    __swig_getmethods__["shear"] = _cv.CvFont_shear_get
    if _newclass:shear = _swig_property(_cv.CvFont_shear_get, _cv.CvFont_shear_set)
    __swig_setmethods__["thickness"] = _cv.CvFont_thickness_set
    __swig_getmethods__["thickness"] = _cv.CvFont_thickness_get
    if _newclass:thickness = _swig_property(_cv.CvFont_thickness_get, _cv.CvFont_thickness_set)
    __swig_setmethods__["dx"] = _cv.CvFont_dx_set
    __swig_getmethods__["dx"] = _cv.CvFont_dx_get
    if _newclass:dx = _swig_property(_cv.CvFont_dx_get, _cv.CvFont_dx_set)
    __swig_setmethods__["line_type"] = _cv.CvFont_line_type_set
    __swig_getmethods__["line_type"] = _cv.CvFont_line_type_get
    if _newclass:line_type = _swig_property(_cv.CvFont_line_type_get, _cv.CvFont_line_type_set)
    def __init__(self): 
        """__init__(self) -> CvFont"""
        this = _cv.new_CvFont()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvFont
    __del__ = lambda self : None;
CvFont_swigregister = _cv.CvFont_swigregister
CvFont_swigregister(CvFont)


def cvInitFont(*args):
  """
    cvInitFont(CvFont font, double hscale, double vscale, double shear = 0, 
        int thickness = 1, int line_type = 8)
    """
  return _cv.cvInitFont(*args)

def cvFont(*args):
  """cvFont(double scale, int thickness = 1) -> CvFont"""
  return _cv.cvFont(*args)

def cvPutText(*args):
  """cvPutText(CvArr img, char text, CvPoint org, CvFont font, CvScalar color)"""
  return _cv.cvPutText(*args)

def cvGetTextSize(*args):
  """cvGetTextSize(char text_string, CvFont font)"""
  return _cv.cvGetTextSize(*args)

def cvColorToScalar(*args):
  """cvColorToScalar(double packed_color, int arrtype) -> CvScalar"""
  return _cv.cvColorToScalar(*args)

def cvEllipse2Poly(*args):
  """
    cvEllipse2Poly(CvPoint center, CvSize axes, int angle, int arc_start, 
        int arc_end, CvPoint pts, int delta) -> int
    """
  return _cv.cvEllipse2Poly(*args)

def cvDrawContours(*args):
  """
    cvDrawContours(CvArr img, CvSeq contour, CvScalar external_color, 
        CvScalar hole_color, int max_level, int thickness = 1, 
        int line_type = 8, CvPoint offset = cvPoint(0,0))
    """
  return _cv.cvDrawContours(*args)

def cvLUT(*args):
  """cvLUT(CvArr src, CvArr dst, CvArr lut)"""
  return _cv.cvLUT(*args)
class CvTreeNodeIterator(_object):
    """Proxy of C++ CvTreeNodeIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvTreeNodeIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvTreeNodeIterator, name)
    __repr__ = _swig_repr
    __swig_setmethods__["node"] = _cv.CvTreeNodeIterator_node_set
    __swig_getmethods__["node"] = _cv.CvTreeNodeIterator_node_get
    if _newclass:node = _swig_property(_cv.CvTreeNodeIterator_node_get, _cv.CvTreeNodeIterator_node_set)
    __swig_setmethods__["level"] = _cv.CvTreeNodeIterator_level_set
    __swig_getmethods__["level"] = _cv.CvTreeNodeIterator_level_get
    if _newclass:level = _swig_property(_cv.CvTreeNodeIterator_level_get, _cv.CvTreeNodeIterator_level_set)
    __swig_setmethods__["max_level"] = _cv.CvTreeNodeIterator_max_level_set
    __swig_getmethods__["max_level"] = _cv.CvTreeNodeIterator_max_level_get
    if _newclass:max_level = _swig_property(_cv.CvTreeNodeIterator_max_level_get, _cv.CvTreeNodeIterator_max_level_set)
    def __init__(self): 
        """__init__(self) -> CvTreeNodeIterator"""
        this = _cv.new_CvTreeNodeIterator()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvTreeNodeIterator
    __del__ = lambda self : None;
CvTreeNodeIterator_swigregister = _cv.CvTreeNodeIterator_swigregister
CvTreeNodeIterator_swigregister(CvTreeNodeIterator)


def cvInitTreeNodeIterator(*args):
  """cvInitTreeNodeIterator(CvTreeNodeIterator tree_iterator, void first, int max_level)"""
  return _cv.cvInitTreeNodeIterator(*args)

def cvNextTreeNode(*args):
  """cvNextTreeNode(CvTreeNodeIterator tree_iterator) -> void"""
  return _cv.cvNextTreeNode(*args)

def cvPrevTreeNode(*args):
  """cvPrevTreeNode(CvTreeNodeIterator tree_iterator) -> void"""
  return _cv.cvPrevTreeNode(*args)

def cvInsertNodeIntoTree(*args):
  """cvInsertNodeIntoTree(void node, void parent, void frame)"""
  return _cv.cvInsertNodeIntoTree(*args)

def cvRemoveNodeFromTree(*args):
  """cvRemoveNodeFromTree(void node, void frame)"""
  return _cv.cvRemoveNodeFromTree(*args)

def cvTreeToNodeSeq(*args):
  """cvTreeToNodeSeq(void first, int header_size, CvMemStorage storage) -> CvSeq"""
  return _cv.cvTreeToNodeSeq(*args)

def cvKMeans2(*args):
  """
    cvKMeans2(CvArr samples, int cluster_count, CvArr labels, CvTermCriteria termcrit, 
        int attempts = 1, CvRNG rng = None, 
        int flags = 0, CvArr _centers = None, 
        double compactness = None) -> int
    """
  return _cv.cvKMeans2(*args)

def cvRegisterModule(*args):
  """cvRegisterModule(CvModuleInfo module_info) -> int"""
  return _cv.cvRegisterModule(*args)

def cvUseOptimized(*args):
  """cvUseOptimized(int on_off) -> int"""
  return _cv.cvUseOptimized(*args)

def cvGetModuleInfo(*args):
  """cvGetModuleInfo(char module_name, char version, char loaded_addon_plugins)"""
  return _cv.cvGetModuleInfo(*args)

def cvGetErrStatus():
  """cvGetErrStatus() -> int"""
  return _cv.cvGetErrStatus()

def cvSetErrStatus(*args):
  """cvSetErrStatus(int status)"""
  return _cv.cvSetErrStatus(*args)

def cvGetErrMode():
  """cvGetErrMode() -> int"""
  return _cv.cvGetErrMode()

def cvSetErrMode(*args):
  """cvSetErrMode(int mode) -> int"""
  return _cv.cvSetErrMode(*args)

def cvError(*args):
  """
    cvError(int status, char func_name, char err_msg, char file_name, 
        int line)
    """
  return _cv.cvError(*args)

def cvErrorStr(*args):
  """cvErrorStr(int status) -> char"""
  return _cv.cvErrorStr(*args)

def cvGetErrInfo(*args):
  """
    cvGetErrInfo(char errcode_desc, char description, char filename, 
        int line) -> int
    """
  return _cv.cvGetErrInfo(*args)

def cvErrorFromIppStatus(*args):
  """cvErrorFromIppStatus(int ipp_status) -> int"""
  return _cv.cvErrorFromIppStatus(*args)

def cvRedirectError(*args):
  """
    cvRedirectError(CvErrorCallback error_handler, void userdata = None, 
        void prev_userdata = None) -> CvErrorCallback
    """
  return _cv.cvRedirectError(*args)

def cvNulDevReport(*args):
  """
    cvNulDevReport(int status, char func_name, char err_msg, char file_name, 
        int line, void userdata) -> int
    """
  return _cv.cvNulDevReport(*args)

def cvStdErrReport(*args):
  """
    cvStdErrReport(int status, char func_name, char err_msg, char file_name, 
        int line, void userdata) -> int
    """
  return _cv.cvStdErrReport(*args)

def cvGuiBoxReport(*args):
  """
    cvGuiBoxReport(int status, char func_name, char err_msg, char file_name, 
        int line, void userdata) -> int
    """
  return _cv.cvGuiBoxReport(*args)

def cvSetMemoryManager(alloc_func = None, free_func = None, userdata = None):
  """
    cvSetMemoryManager(CvAllocFunc alloc_func = None, CvFreeFunc free_func = None, 
        void userdata = None)
    """
  return _cv.cvSetMemoryManager(alloc_func, free_func, userdata)

def cvSetIPLAllocators(*args):
  """
    cvSetIPLAllocators(Cv_iplCreateImageHeader create_header, Cv_iplAllocateImageData allocate_data, 
        Cv_iplDeallocate deallocate, 
        Cv_iplCreateROI create_roi, Cv_iplCloneImage clone_image)
    """
  return _cv.cvSetIPLAllocators(*args)

def cvOpenFileStorage(*args):
  """cvOpenFileStorage(char filename, CvMemStorage memstorage, int flags) -> CvFileStorage"""
  return _cv.cvOpenFileStorage(*args)

def cvReleaseFileStorage(*args):
  """cvReleaseFileStorage(CvFileStorage fs)"""
  return _cv.cvReleaseFileStorage(*args)

def cvAttrValue(*args):
  """cvAttrValue(CvAttrList attr, char attr_name) -> char"""
  return _cv.cvAttrValue(*args)

def cvStartWriteStruct(*args):
  """
    cvStartWriteStruct(CvFileStorage fs, char name, int struct_flags, char type_name = None, 
        CvAttrList attributes = cvAttrList())
    """
  return _cv.cvStartWriteStruct(*args)

def cvEndWriteStruct(*args):
  """cvEndWriteStruct(CvFileStorage fs)"""
  return _cv.cvEndWriteStruct(*args)

def cvWriteInt(*args):
  """cvWriteInt(CvFileStorage fs, char name, int value)"""
  return _cv.cvWriteInt(*args)

def cvWriteReal(*args):
  """cvWriteReal(CvFileStorage fs, char name, double value)"""
  return _cv.cvWriteReal(*args)

def cvWriteString(*args):
  """cvWriteString(CvFileStorage fs, char name, char str, int quote = 0)"""
  return _cv.cvWriteString(*args)

def cvWriteComment(*args):
  """cvWriteComment(CvFileStorage fs, char comment, int eol_comment)"""
  return _cv.cvWriteComment(*args)

def cvWrite(*args):
  """cvWrite(CvFileStorage fs, char name, void ptr, CvAttrList attributes = cvAttrList())"""
  return _cv.cvWrite(*args)

def cvStartNextStream(*args):
  """cvStartNextStream(CvFileStorage fs)"""
  return _cv.cvStartNextStream(*args)

def cvWriteRawData(*args):
  """cvWriteRawData(CvFileStorage fs, void src, int len, char dt)"""
  return _cv.cvWriteRawData(*args)

def cvGetHashedKey(*args):
  """cvGetHashedKey(CvFileStorage fs, char name, int len = -1, int create_missing = 0) -> CvStringHashNode"""
  return _cv.cvGetHashedKey(*args)

def cvGetRootFileNode(*args):
  """cvGetRootFileNode(CvFileStorage fs, int stream_index = 0) -> CvFileNode"""
  return _cv.cvGetRootFileNode(*args)

def cvGetFileNode(*args):
  """
    cvGetFileNode(CvFileStorage fs, CvFileNode map, CvStringHashNode key, 
        int create_missing = 0) -> CvFileNode
    """
  return _cv.cvGetFileNode(*args)

def cvGetFileNodeByName(*args):
  """cvGetFileNodeByName(CvFileStorage fs, CvFileNode map, char name) -> CvFileNode"""
  return _cv.cvGetFileNodeByName(*args)

def cvReadInt(*args):
  """cvReadInt(CvFileNode node, int default_value = 0) -> int"""
  return _cv.cvReadInt(*args)

def cvReadIntByName(*args):
  """cvReadIntByName(CvFileStorage fs, CvFileNode map, char name, int default_value = 0) -> int"""
  return _cv.cvReadIntByName(*args)

def cvReadReal(*args):
  """cvReadReal(CvFileNode node, double default_value = 0.) -> double"""
  return _cv.cvReadReal(*args)

def cvReadRealByName(*args):
  """cvReadRealByName(CvFileStorage fs, CvFileNode map, char name, double default_value = 0.) -> double"""
  return _cv.cvReadRealByName(*args)

def cvReadString(*args):
  """cvReadString(CvFileNode node, char default_value = None) -> char"""
  return _cv.cvReadString(*args)

def cvReadStringByName(*args):
  """cvReadStringByName(CvFileStorage fs, CvFileNode map, char name, char default_value = None) -> char"""
  return _cv.cvReadStringByName(*args)

def cvRead(*args):
  """cvRead(CvFileStorage fs, CvFileNode node, CvAttrList attributes = None) -> void"""
  return _cv.cvRead(*args)

def cvReadByName(*args):
  """cvReadByName(CvFileStorage fs, CvFileNode map, char name, CvAttrList attributes = None) -> void"""
  return _cv.cvReadByName(*args)

def cvStartReadRawData(*args):
  """cvStartReadRawData(CvFileStorage fs, CvFileNode src, CvSeqReader reader)"""
  return _cv.cvStartReadRawData(*args)

def cvReadRawDataSlice(*args):
  """
    cvReadRawDataSlice(CvFileStorage fs, CvSeqReader reader, int count, void dst, 
        char dt)
    """
  return _cv.cvReadRawDataSlice(*args)

def cvReadRawData(*args):
  """cvReadRawData(CvFileStorage fs, CvFileNode src, void dst, char dt)"""
  return _cv.cvReadRawData(*args)

def cvWriteFileNode(*args):
  """
    cvWriteFileNode(CvFileStorage fs, char new_node_name, CvFileNode node, 
        int embed)
    """
  return _cv.cvWriteFileNode(*args)

def cvGetFileNodeName(*args):
  """cvGetFileNodeName(CvFileNode node) -> char"""
  return _cv.cvGetFileNodeName(*args)

def cvRegisterType(*args):
  """cvRegisterType(CvTypeInfo info)"""
  return _cv.cvRegisterType(*args)

def cvUnregisterType(*args):
  """cvUnregisterType(char type_name)"""
  return _cv.cvUnregisterType(*args)

def cvFirstType():
  """cvFirstType() -> CvTypeInfo"""
  return _cv.cvFirstType()

def cvFindType(*args):
  """cvFindType(char type_name) -> CvTypeInfo"""
  return _cv.cvFindType(*args)

def cvTypeOf(*args):
  """cvTypeOf(void struct_ptr) -> CvTypeInfo"""
  return _cv.cvTypeOf(*args)

def cvClone(*args):
  """cvClone(void struct_ptr) -> void"""
  return _cv.cvClone(*args)

def cvSave(*args):
  """
    cvSave(char filename, void struct_ptr, char name = None, char comment = None, 
        CvAttrList attributes = cvAttrList())
    """
  return _cv.cvSave(*args)

def cvLoad(*args):
  """
    cvLoad(char filename, CvMemStorage memstorage = None, char name = None, 
        char real_name = None) -> void
    """
  return _cv.cvLoad(*args)

def cvGetTickCount():
  """cvGetTickCount() -> int64"""
  return _cv.cvGetTickCount()

def cvGetTickFrequency():
  """cvGetTickFrequency() -> double"""
  return _cv.cvGetTickFrequency()

def cvGetNumThreads():
  """cvGetNumThreads() -> int"""
  return _cv.cvGetNumThreads()

def cvSetNumThreads(threads = 0):
  """cvSetNumThreads(int threads = 0)"""
  return _cv.cvSetNumThreads(threads)

def cvGetThreadNum():
  """cvGetThreadNum() -> int"""
  return _cv.cvGetThreadNum()

def cvSetImageIOFunctions(*args):
  """
    cvSetImageIOFunctions(CvLoadImageFunc _load_image, CvLoadImageMFunc _load_image_m, 
        CvSaveImageFunc _save_image, CvShowImageFunc _show_image) -> int
    """
  return _cv.cvSetImageIOFunctions(*args)
class CvImage(_object):
    """Proxy of C++ CvImage class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvImage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvImage, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> CvImage
        __init__(self, CvSize size, int depth, int channels) -> CvImage
        __init__(self,  img) -> CvImage
        __init__(self, CvImage img) -> CvImage
        __init__(self, char filename, char imgname = None, int color = -1) -> CvImage
        __init__(self, char filename, char imgname = None) -> CvImage
        __init__(self, char filename) -> CvImage
        __init__(self, CvFileStorage fs, char mapname, char imgname) -> CvImage
        __init__(self, CvFileStorage fs, char seqname, int idx) -> CvImage
        """
        this = _cv.new_CvImage(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvImage
    __del__ = lambda self : None;
    def clone(self):
        """clone(self) -> CvImage"""
        return _cv.CvImage_clone(self)

    def create(self, *args):
        """create(self, CvSize size, int depth, int channels)"""
        return _cv.CvImage_create(self, *args)

    def release(self):
        """release(self)"""
        return _cv.CvImage_release(self)

    def clear(self):
        """clear(self)"""
        return _cv.CvImage_clear(self)

    def attach(self, *args):
        """
        attach(self,  img, bool use_refcount = True)
        attach(self,  img)
        """
        return _cv.CvImage_attach(self, *args)

    def detach(self):
        """detach(self)"""
        return _cv.CvImage_detach(self)

    def load(self, *args):
        """
        load(self, char filename, char imgname = None, int color = -1) -> bool
        load(self, char filename, char imgname = None) -> bool
        load(self, char filename) -> bool
        """
        return _cv.CvImage_load(self, *args)

    def read(self, *args):
        """
        read(self, CvFileStorage fs, char mapname, char imgname) -> bool
        read(self, CvFileStorage fs, char seqname, int idx) -> bool
        """
        return _cv.CvImage_read(self, *args)

    def save(self, *args):
        """
        save(self, char filename, char imgname, int params = None)
        save(self, char filename, char imgname)
        """
        return _cv.CvImage_save(self, *args)

    def write(self, *args):
        """write(self, CvFileStorage fs, char imgname)"""
        return _cv.CvImage_write(self, *args)

    def show(self, *args):
        """show(self, char window_name)"""
        return _cv.CvImage_show(self, *args)

    def is_valid(self):
        """is_valid(self) -> bool"""
        return _cv.CvImage_is_valid(self)

    def width(self):
        """width(self) -> int"""
        return _cv.CvImage_width(self)

    def height(self):
        """height(self) -> int"""
        return _cv.CvImage_height(self)

    def size(self):
        """size(self) -> CvSize"""
        return _cv.CvImage_size(self)

    def roi_size(self):
        """roi_size(self) -> CvSize"""
        return _cv.CvImage_roi_size(self)

    def roi(self):
        """roi(self) -> CvRect"""
        return _cv.CvImage_roi(self)

    def coi(self):
        """coi(self) -> int"""
        return _cv.CvImage_coi(self)

    def set_roi(self, *args):
        """set_roi(self, CvRect roi)"""
        return _cv.CvImage_set_roi(self, *args)

    def reset_roi(self):
        """reset_roi(self)"""
        return _cv.CvImage_reset_roi(self)

    def set_coi(self, *args):
        """set_coi(self, int coi)"""
        return _cv.CvImage_set_coi(self, *args)

    def depth(self):
        """depth(self) -> int"""
        return _cv.CvImage_depth(self)

    def channels(self):
        """channels(self) -> int"""
        return _cv.CvImage_channels(self)

    def pix_size(self):
        """pix_size(self) -> int"""
        return _cv.CvImage_pix_size(self)

    def data(self, *args):
        """
        data(self) -> uchar
        data(self) -> uchar
        """
        return _cv.CvImage_data(self, *args)

    def step(self):
        """step(self) -> int"""
        return _cv.CvImage_step(self)

    def origin(self):
        """origin(self) -> int"""
        return _cv.CvImage_origin(self)

    def roi_row(self, *args):
        """
        roi_row(self, int y) -> uchar
        roi_row(self, int y) -> uchar
        """
        return _cv.CvImage_roi_row(self, *args)

    def asIplImage(self):
        """asIplImage(self)"""
        return _cv.CvImage_asIplImage(self)

CvImage_swigregister = _cv.CvImage_swigregister
CvImage_swigregister(CvImage)

class CvMatrix(_object):
    """Proxy of C++ CvMatrix class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvMatrix, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvMatrix, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> CvMatrix
        __init__(self, int rows, int cols, int type) -> CvMatrix
        __init__(self, int rows, int cols, int type, CvMat hdr, void data = None, 
            int step = 0x7fffffff) -> CvMatrix
        __init__(self, int rows, int cols, int type, CvMat hdr, void data = None) -> CvMatrix
        __init__(self, int rows, int cols, int type, CvMat hdr) -> CvMatrix
        __init__(self, int rows, int cols, int type, CvMemStorage storage, 
            bool alloc_data = True) -> CvMatrix
        __init__(self, int rows, int cols, int type, CvMemStorage storage) -> CvMatrix
        __init__(self, int rows, int cols, int type, void data, int step = 0x7fffffff) -> CvMatrix
        __init__(self, int rows, int cols, int type, void data) -> CvMatrix
        __init__(self, CvMat m) -> CvMatrix
        __init__(self, CvMatrix m) -> CvMatrix
        __init__(self, char filename, char matname = None, int color = -1) -> CvMatrix
        __init__(self, char filename, char matname = None) -> CvMatrix
        __init__(self, char filename) -> CvMatrix
        __init__(self, CvFileStorage fs, char mapname, char matname) -> CvMatrix
        __init__(self, CvFileStorage fs, char seqname, int idx) -> CvMatrix
        """
        this = _cv.new_CvMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvMatrix
    __del__ = lambda self : None;
    def clone(self):
        """clone(self) -> CvMatrix"""
        return _cv.CvMatrix_clone(self)

    def set(self, *args):
        """set(self, CvMat m, bool add_ref)"""
        return _cv.CvMatrix_set(self, *args)

    def create(self, *args):
        """create(self, int rows, int cols, int type)"""
        return _cv.CvMatrix_create(self, *args)

    def addref(self):
        """addref(self)"""
        return _cv.CvMatrix_addref(self)

    def release(self):
        """release(self)"""
        return _cv.CvMatrix_release(self)

    def clear(self):
        """clear(self)"""
        return _cv.CvMatrix_clear(self)

    def load(self, *args):
        """
        load(self, char filename, char matname = None, int color = -1) -> bool
        load(self, char filename, char matname = None) -> bool
        load(self, char filename) -> bool
        """
        return _cv.CvMatrix_load(self, *args)

    def read(self, *args):
        """
        read(self, CvFileStorage fs, char mapname, char matname) -> bool
        read(self, CvFileStorage fs, char seqname, int idx) -> bool
        """
        return _cv.CvMatrix_read(self, *args)

    def save(self, *args):
        """
        save(self, char filename, char matname, int params = None)
        save(self, char filename, char matname)
        """
        return _cv.CvMatrix_save(self, *args)

    def write(self, *args):
        """write(self, CvFileStorage fs, char matname)"""
        return _cv.CvMatrix_write(self, *args)

    def show(self, *args):
        """show(self, char window_name)"""
        return _cv.CvMatrix_show(self, *args)

    def is_valid(self):
        """is_valid(self) -> bool"""
        return _cv.CvMatrix_is_valid(self)

    def rows(self):
        """rows(self) -> int"""
        return _cv.CvMatrix_rows(self)

    def cols(self):
        """cols(self) -> int"""
        return _cv.CvMatrix_cols(self)

    def size(self):
        """size(self) -> CvSize"""
        return _cv.CvMatrix_size(self)

    def type(self):
        """type(self) -> int"""
        return _cv.CvMatrix_type(self)

    def depth(self):
        """depth(self) -> int"""
        return _cv.CvMatrix_depth(self)

    def channels(self):
        """channels(self) -> int"""
        return _cv.CvMatrix_channels(self)

    def pix_size(self):
        """pix_size(self) -> int"""
        return _cv.CvMatrix_pix_size(self)

    def data(self, *args):
        """
        data(self) -> uchar
        data(self) -> uchar
        """
        return _cv.CvMatrix_data(self, *args)

    def step(self):
        """step(self) -> int"""
        return _cv.CvMatrix_step(self)

    def set_data(self, *args):
        """
        set_data(self, void data, int step = 0x7fffffff)
        set_data(self, void data)
        """
        return _cv.CvMatrix_set_data(self, *args)

    def row(self, *args):
        """
        row(self, int i) -> uchar
        row(self, int i) -> uchar
        """
        return _cv.CvMatrix_row(self, *args)

    def asCvMat(self):
        """asCvMat(self) -> CvMat"""
        return _cv.CvMatrix_asCvMat(self)

CvMatrix_swigregister = _cv.CvMatrix_swigregister
CvMatrix_swigregister(CvMatrix)

class CvModule(_object):
    """Proxy of C++ CvModule class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvModule, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvModule, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, CvModuleInfo _info) -> CvModule"""
        this = _cv.new_CvModule(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvModule
    __del__ = lambda self : None;
    __swig_setmethods__["info"] = _cv.CvModule_info_set
    __swig_getmethods__["info"] = _cv.CvModule_info_get
    if _newclass:info = _swig_property(_cv.CvModule_info_get, _cv.CvModule_info_set)
    __swig_setmethods__["first"] = _cv.CvModule_first_set
    __swig_getmethods__["first"] = _cv.CvModule_first_get
    if _newclass:first = _swig_property(_cv.CvModule_first_get, _cv.CvModule_first_set)
    __swig_setmethods__["last"] = _cv.CvModule_last_set
    __swig_getmethods__["last"] = _cv.CvModule_last_get
    if _newclass:last = _swig_property(_cv.CvModule_last_get, _cv.CvModule_last_set)
CvModule_swigregister = _cv.CvModule_swigregister
CvModule_swigregister(CvModule)
cvar = _cv.cvar

class CvType(_object):
    """Proxy of C++ CvType class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvType, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char type_name, CvIsInstanceFunc is_instance, CvReleaseFunc release = 0, 
            CvReadFunc read = 0, CvWriteFunc write = 0, 
            CvCloneFunc clone = 0) -> CvType
        __init__(self, char type_name, CvIsInstanceFunc is_instance, CvReleaseFunc release = 0, 
            CvReadFunc read = 0, CvWriteFunc write = 0) -> CvType
        __init__(self, char type_name, CvIsInstanceFunc is_instance, CvReleaseFunc release = 0, 
            CvReadFunc read = 0) -> CvType
        __init__(self, char type_name, CvIsInstanceFunc is_instance, CvReleaseFunc release = 0) -> CvType
        __init__(self, char type_name, CvIsInstanceFunc is_instance) -> CvType
        """
        this = _cv.new_CvType(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvType
    __del__ = lambda self : None;
    __swig_setmethods__["info"] = _cv.CvType_info_set
    __swig_getmethods__["info"] = _cv.CvType_info_get
    if _newclass:info = _swig_property(_cv.CvType_info_get, _cv.CvType_info_set)
    __swig_setmethods__["first"] = _cv.CvType_first_set
    __swig_getmethods__["first"] = _cv.CvType_first_get
    if _newclass:first = _swig_property(_cv.CvType_first_get, _cv.CvType_first_set)
    __swig_setmethods__["last"] = _cv.CvType_last_set
    __swig_getmethods__["last"] = _cv.CvType_last_get
    if _newclass:last = _swig_property(_cv.CvType_last_get, _cv.CvType_last_set)
CvType_swigregister = _cv.CvType_swigregister
CvType_swigregister(CvType)

class CvMoments(_object):
    """Proxy of C++ CvMoments class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvMoments, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvMoments, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m00"] = _cv.CvMoments_m00_set
    __swig_getmethods__["m00"] = _cv.CvMoments_m00_get
    if _newclass:m00 = _swig_property(_cv.CvMoments_m00_get, _cv.CvMoments_m00_set)
    __swig_setmethods__["m10"] = _cv.CvMoments_m10_set
    __swig_getmethods__["m10"] = _cv.CvMoments_m10_get
    if _newclass:m10 = _swig_property(_cv.CvMoments_m10_get, _cv.CvMoments_m10_set)
    __swig_setmethods__["m01"] = _cv.CvMoments_m01_set
    __swig_getmethods__["m01"] = _cv.CvMoments_m01_get
    if _newclass:m01 = _swig_property(_cv.CvMoments_m01_get, _cv.CvMoments_m01_set)
    __swig_setmethods__["m20"] = _cv.CvMoments_m20_set
    __swig_getmethods__["m20"] = _cv.CvMoments_m20_get
    if _newclass:m20 = _swig_property(_cv.CvMoments_m20_get, _cv.CvMoments_m20_set)
    __swig_setmethods__["m11"] = _cv.CvMoments_m11_set
    __swig_getmethods__["m11"] = _cv.CvMoments_m11_get
    if _newclass:m11 = _swig_property(_cv.CvMoments_m11_get, _cv.CvMoments_m11_set)
    __swig_setmethods__["m02"] = _cv.CvMoments_m02_set
    __swig_getmethods__["m02"] = _cv.CvMoments_m02_get
    if _newclass:m02 = _swig_property(_cv.CvMoments_m02_get, _cv.CvMoments_m02_set)
    __swig_setmethods__["m30"] = _cv.CvMoments_m30_set
    __swig_getmethods__["m30"] = _cv.CvMoments_m30_get
    if _newclass:m30 = _swig_property(_cv.CvMoments_m30_get, _cv.CvMoments_m30_set)
    __swig_setmethods__["m21"] = _cv.CvMoments_m21_set
    __swig_getmethods__["m21"] = _cv.CvMoments_m21_get
    if _newclass:m21 = _swig_property(_cv.CvMoments_m21_get, _cv.CvMoments_m21_set)
    __swig_setmethods__["m12"] = _cv.CvMoments_m12_set
    __swig_getmethods__["m12"] = _cv.CvMoments_m12_get
    if _newclass:m12 = _swig_property(_cv.CvMoments_m12_get, _cv.CvMoments_m12_set)
    __swig_setmethods__["m03"] = _cv.CvMoments_m03_set
    __swig_getmethods__["m03"] = _cv.CvMoments_m03_get
    if _newclass:m03 = _swig_property(_cv.CvMoments_m03_get, _cv.CvMoments_m03_set)
    __swig_setmethods__["mu20"] = _cv.CvMoments_mu20_set
    __swig_getmethods__["mu20"] = _cv.CvMoments_mu20_get
    if _newclass:mu20 = _swig_property(_cv.CvMoments_mu20_get, _cv.CvMoments_mu20_set)
    __swig_setmethods__["mu11"] = _cv.CvMoments_mu11_set
    __swig_getmethods__["mu11"] = _cv.CvMoments_mu11_get
    if _newclass:mu11 = _swig_property(_cv.CvMoments_mu11_get, _cv.CvMoments_mu11_set)
    __swig_setmethods__["mu02"] = _cv.CvMoments_mu02_set
    __swig_getmethods__["mu02"] = _cv.CvMoments_mu02_get
    if _newclass:mu02 = _swig_property(_cv.CvMoments_mu02_get, _cv.CvMoments_mu02_set)
    __swig_setmethods__["mu30"] = _cv.CvMoments_mu30_set
    __swig_getmethods__["mu30"] = _cv.CvMoments_mu30_get
    if _newclass:mu30 = _swig_property(_cv.CvMoments_mu30_get, _cv.CvMoments_mu30_set)
    __swig_setmethods__["mu21"] = _cv.CvMoments_mu21_set
    __swig_getmethods__["mu21"] = _cv.CvMoments_mu21_get
    if _newclass:mu21 = _swig_property(_cv.CvMoments_mu21_get, _cv.CvMoments_mu21_set)
    __swig_setmethods__["mu12"] = _cv.CvMoments_mu12_set
    __swig_getmethods__["mu12"] = _cv.CvMoments_mu12_get
    if _newclass:mu12 = _swig_property(_cv.CvMoments_mu12_get, _cv.CvMoments_mu12_set)
    __swig_setmethods__["mu03"] = _cv.CvMoments_mu03_set
    __swig_getmethods__["mu03"] = _cv.CvMoments_mu03_get
    if _newclass:mu03 = _swig_property(_cv.CvMoments_mu03_get, _cv.CvMoments_mu03_set)
    __swig_setmethods__["inv_sqrt_m00"] = _cv.CvMoments_inv_sqrt_m00_set
    __swig_getmethods__["inv_sqrt_m00"] = _cv.CvMoments_inv_sqrt_m00_get
    if _newclass:inv_sqrt_m00 = _swig_property(_cv.CvMoments_inv_sqrt_m00_get, _cv.CvMoments_inv_sqrt_m00_set)
    def __init__(self): 
        """__init__(self) -> CvMoments"""
        this = _cv.new_CvMoments()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvMoments
    __del__ = lambda self : None;
CvMoments_swigregister = _cv.CvMoments_swigregister
CvMoments_swigregister(CvMoments)

class CvHuMoments(_object):
    """Proxy of C++ CvHuMoments class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvHuMoments, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvHuMoments, name)
    __repr__ = _swig_repr
    __swig_setmethods__["hu1"] = _cv.CvHuMoments_hu1_set
    __swig_getmethods__["hu1"] = _cv.CvHuMoments_hu1_get
    if _newclass:hu1 = _swig_property(_cv.CvHuMoments_hu1_get, _cv.CvHuMoments_hu1_set)
    __swig_setmethods__["hu2"] = _cv.CvHuMoments_hu2_set
    __swig_getmethods__["hu2"] = _cv.CvHuMoments_hu2_get
    if _newclass:hu2 = _swig_property(_cv.CvHuMoments_hu2_get, _cv.CvHuMoments_hu2_set)
    __swig_setmethods__["hu3"] = _cv.CvHuMoments_hu3_set
    __swig_getmethods__["hu3"] = _cv.CvHuMoments_hu3_get
    if _newclass:hu3 = _swig_property(_cv.CvHuMoments_hu3_get, _cv.CvHuMoments_hu3_set)
    __swig_setmethods__["hu4"] = _cv.CvHuMoments_hu4_set
    __swig_getmethods__["hu4"] = _cv.CvHuMoments_hu4_get
    if _newclass:hu4 = _swig_property(_cv.CvHuMoments_hu4_get, _cv.CvHuMoments_hu4_set)
    __swig_setmethods__["hu5"] = _cv.CvHuMoments_hu5_set
    __swig_getmethods__["hu5"] = _cv.CvHuMoments_hu5_get
    if _newclass:hu5 = _swig_property(_cv.CvHuMoments_hu5_get, _cv.CvHuMoments_hu5_set)
    __swig_setmethods__["hu6"] = _cv.CvHuMoments_hu6_set
    __swig_getmethods__["hu6"] = _cv.CvHuMoments_hu6_get
    if _newclass:hu6 = _swig_property(_cv.CvHuMoments_hu6_get, _cv.CvHuMoments_hu6_set)
    __swig_setmethods__["hu7"] = _cv.CvHuMoments_hu7_set
    __swig_getmethods__["hu7"] = _cv.CvHuMoments_hu7_get
    if _newclass:hu7 = _swig_property(_cv.CvHuMoments_hu7_get, _cv.CvHuMoments_hu7_set)
    def __init__(self): 
        """__init__(self) -> CvHuMoments"""
        this = _cv.new_CvHuMoments()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvHuMoments
    __del__ = lambda self : None;
CvHuMoments_swigregister = _cv.CvHuMoments_swigregister
CvHuMoments_swigregister(CvHuMoments)

class CvConnectedComp(_object):
    """Proxy of C++ CvConnectedComp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvConnectedComp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvConnectedComp, name)
    __repr__ = _swig_repr
    __swig_setmethods__["area"] = _cv.CvConnectedComp_area_set
    __swig_getmethods__["area"] = _cv.CvConnectedComp_area_get
    if _newclass:area = _swig_property(_cv.CvConnectedComp_area_get, _cv.CvConnectedComp_area_set)
    __swig_setmethods__["value"] = _cv.CvConnectedComp_value_set
    __swig_getmethods__["value"] = _cv.CvConnectedComp_value_get
    if _newclass:value = _swig_property(_cv.CvConnectedComp_value_get, _cv.CvConnectedComp_value_set)
    __swig_setmethods__["rect"] = _cv.CvConnectedComp_rect_set
    __swig_getmethods__["rect"] = _cv.CvConnectedComp_rect_get
    if _newclass:rect = _swig_property(_cv.CvConnectedComp_rect_get, _cv.CvConnectedComp_rect_set)
    __swig_setmethods__["contour"] = _cv.CvConnectedComp_contour_set
    __swig_getmethods__["contour"] = _cv.CvConnectedComp_contour_get
    if _newclass:contour = _swig_property(_cv.CvConnectedComp_contour_get, _cv.CvConnectedComp_contour_set)
    def __init__(self): 
        """__init__(self) -> CvConnectedComp"""
        this = _cv.new_CvConnectedComp()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvConnectedComp
    __del__ = lambda self : None;
CvConnectedComp_swigregister = _cv.CvConnectedComp_swigregister
CvConnectedComp_swigregister(CvConnectedComp)

class CvChainPtReader(_object):
    """Proxy of C++ CvChainPtReader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvChainPtReader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvChainPtReader, name)
    __repr__ = _swig_repr
    __swig_setmethods__["header_size"] = _cv.CvChainPtReader_header_size_set
    __swig_getmethods__["header_size"] = _cv.CvChainPtReader_header_size_get
    if _newclass:header_size = _swig_property(_cv.CvChainPtReader_header_size_get, _cv.CvChainPtReader_header_size_set)
    __swig_setmethods__["seq"] = _cv.CvChainPtReader_seq_set
    __swig_getmethods__["seq"] = _cv.CvChainPtReader_seq_get
    if _newclass:seq = _swig_property(_cv.CvChainPtReader_seq_get, _cv.CvChainPtReader_seq_set)
    __swig_setmethods__["block"] = _cv.CvChainPtReader_block_set
    __swig_getmethods__["block"] = _cv.CvChainPtReader_block_get
    if _newclass:block = _swig_property(_cv.CvChainPtReader_block_get, _cv.CvChainPtReader_block_set)
    __swig_setmethods__["ptr"] = _cv.CvChainPtReader_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvChainPtReader_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvChainPtReader_ptr_get, _cv.CvChainPtReader_ptr_set)
    __swig_setmethods__["block_min"] = _cv.CvChainPtReader_block_min_set
    __swig_getmethods__["block_min"] = _cv.CvChainPtReader_block_min_get
    if _newclass:block_min = _swig_property(_cv.CvChainPtReader_block_min_get, _cv.CvChainPtReader_block_min_set)
    __swig_setmethods__["block_max"] = _cv.CvChainPtReader_block_max_set
    __swig_getmethods__["block_max"] = _cv.CvChainPtReader_block_max_get
    if _newclass:block_max = _swig_property(_cv.CvChainPtReader_block_max_get, _cv.CvChainPtReader_block_max_set)
    __swig_setmethods__["delta_index"] = _cv.CvChainPtReader_delta_index_set
    __swig_getmethods__["delta_index"] = _cv.CvChainPtReader_delta_index_get
    if _newclass:delta_index = _swig_property(_cv.CvChainPtReader_delta_index_get, _cv.CvChainPtReader_delta_index_set)
    __swig_setmethods__["prev_elem"] = _cv.CvChainPtReader_prev_elem_set
    __swig_getmethods__["prev_elem"] = _cv.CvChainPtReader_prev_elem_get
    if _newclass:prev_elem = _swig_property(_cv.CvChainPtReader_prev_elem_get, _cv.CvChainPtReader_prev_elem_set)
    __swig_setmethods__["code"] = _cv.CvChainPtReader_code_set
    __swig_getmethods__["code"] = _cv.CvChainPtReader_code_get
    if _newclass:code = _swig_property(_cv.CvChainPtReader_code_get, _cv.CvChainPtReader_code_set)
    __swig_setmethods__["pt"] = _cv.CvChainPtReader_pt_set
    __swig_getmethods__["pt"] = _cv.CvChainPtReader_pt_get
    if _newclass:pt = _swig_property(_cv.CvChainPtReader_pt_get, _cv.CvChainPtReader_pt_set)
    __swig_setmethods__["deltas"] = _cv.CvChainPtReader_deltas_set
    __swig_getmethods__["deltas"] = _cv.CvChainPtReader_deltas_get
    if _newclass:deltas = _swig_property(_cv.CvChainPtReader_deltas_get, _cv.CvChainPtReader_deltas_set)
    def __init__(self): 
        """__init__(self) -> CvChainPtReader"""
        this = _cv.new_CvChainPtReader()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvChainPtReader
    __del__ = lambda self : None;
CvChainPtReader_swigregister = _cv.CvChainPtReader_swigregister
CvChainPtReader_swigregister(CvChainPtReader)

class CvContourTree(_object):
    """Proxy of C++ CvContourTree class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvContourTree, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvContourTree, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvContourTree_flags_set
    __swig_getmethods__["flags"] = _cv.CvContourTree_flags_get
    if _newclass:flags = _swig_property(_cv.CvContourTree_flags_get, _cv.CvContourTree_flags_set)
    __swig_setmethods__["header_size"] = _cv.CvContourTree_header_size_set
    __swig_getmethods__["header_size"] = _cv.CvContourTree_header_size_get
    if _newclass:header_size = _swig_property(_cv.CvContourTree_header_size_get, _cv.CvContourTree_header_size_set)
    __swig_setmethods__["h_prev"] = _cv.CvContourTree_h_prev_set
    __swig_getmethods__["h_prev"] = _cv.CvContourTree_h_prev_get
    if _newclass:h_prev = _swig_property(_cv.CvContourTree_h_prev_get, _cv.CvContourTree_h_prev_set)
    __swig_setmethods__["h_next"] = _cv.CvContourTree_h_next_set
    __swig_getmethods__["h_next"] = _cv.CvContourTree_h_next_get
    if _newclass:h_next = _swig_property(_cv.CvContourTree_h_next_get, _cv.CvContourTree_h_next_set)
    __swig_setmethods__["v_prev"] = _cv.CvContourTree_v_prev_set
    __swig_getmethods__["v_prev"] = _cv.CvContourTree_v_prev_get
    if _newclass:v_prev = _swig_property(_cv.CvContourTree_v_prev_get, _cv.CvContourTree_v_prev_set)
    __swig_setmethods__["v_next"] = _cv.CvContourTree_v_next_set
    __swig_getmethods__["v_next"] = _cv.CvContourTree_v_next_get
    if _newclass:v_next = _swig_property(_cv.CvContourTree_v_next_get, _cv.CvContourTree_v_next_set)
    __swig_setmethods__["total"] = _cv.CvContourTree_total_set
    __swig_getmethods__["total"] = _cv.CvContourTree_total_get
    if _newclass:total = _swig_property(_cv.CvContourTree_total_get, _cv.CvContourTree_total_set)
    __swig_setmethods__["elem_size"] = _cv.CvContourTree_elem_size_set
    __swig_getmethods__["elem_size"] = _cv.CvContourTree_elem_size_get
    if _newclass:elem_size = _swig_property(_cv.CvContourTree_elem_size_get, _cv.CvContourTree_elem_size_set)
    __swig_setmethods__["block_max"] = _cv.CvContourTree_block_max_set
    __swig_getmethods__["block_max"] = _cv.CvContourTree_block_max_get
    if _newclass:block_max = _swig_property(_cv.CvContourTree_block_max_get, _cv.CvContourTree_block_max_set)
    __swig_setmethods__["ptr"] = _cv.CvContourTree_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvContourTree_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvContourTree_ptr_get, _cv.CvContourTree_ptr_set)
    __swig_setmethods__["delta_elems"] = _cv.CvContourTree_delta_elems_set
    __swig_getmethods__["delta_elems"] = _cv.CvContourTree_delta_elems_get
    if _newclass:delta_elems = _swig_property(_cv.CvContourTree_delta_elems_get, _cv.CvContourTree_delta_elems_set)
    __swig_setmethods__["storage"] = _cv.CvContourTree_storage_set
    __swig_getmethods__["storage"] = _cv.CvContourTree_storage_get
    if _newclass:storage = _swig_property(_cv.CvContourTree_storage_get, _cv.CvContourTree_storage_set)
    __swig_setmethods__["free_blocks"] = _cv.CvContourTree_free_blocks_set
    __swig_getmethods__["free_blocks"] = _cv.CvContourTree_free_blocks_get
    if _newclass:free_blocks = _swig_property(_cv.CvContourTree_free_blocks_get, _cv.CvContourTree_free_blocks_set)
    __swig_setmethods__["first"] = _cv.CvContourTree_first_set
    __swig_getmethods__["first"] = _cv.CvContourTree_first_get
    if _newclass:first = _swig_property(_cv.CvContourTree_first_get, _cv.CvContourTree_first_set)
    __swig_setmethods__["p1"] = _cv.CvContourTree_p1_set
    __swig_getmethods__["p1"] = _cv.CvContourTree_p1_get
    if _newclass:p1 = _swig_property(_cv.CvContourTree_p1_get, _cv.CvContourTree_p1_set)
    __swig_setmethods__["p2"] = _cv.CvContourTree_p2_set
    __swig_getmethods__["p2"] = _cv.CvContourTree_p2_get
    if _newclass:p2 = _swig_property(_cv.CvContourTree_p2_get, _cv.CvContourTree_p2_set)
    def __init__(self): 
        """__init__(self) -> CvContourTree"""
        this = _cv.new_CvContourTree()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvContourTree
    __del__ = lambda self : None;
CvContourTree_swigregister = _cv.CvContourTree_swigregister
CvContourTree_swigregister(CvContourTree)

class CvConvexityDefect(_object):
    """Proxy of C++ CvConvexityDefect class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvConvexityDefect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvConvexityDefect, name)
    __repr__ = _swig_repr
    __swig_setmethods__["start"] = _cv.CvConvexityDefect_start_set
    __swig_getmethods__["start"] = _cv.CvConvexityDefect_start_get
    if _newclass:start = _swig_property(_cv.CvConvexityDefect_start_get, _cv.CvConvexityDefect_start_set)
    __swig_setmethods__["end"] = _cv.CvConvexityDefect_end_set
    __swig_getmethods__["end"] = _cv.CvConvexityDefect_end_get
    if _newclass:end = _swig_property(_cv.CvConvexityDefect_end_get, _cv.CvConvexityDefect_end_set)
    __swig_setmethods__["depth_point"] = _cv.CvConvexityDefect_depth_point_set
    __swig_getmethods__["depth_point"] = _cv.CvConvexityDefect_depth_point_get
    if _newclass:depth_point = _swig_property(_cv.CvConvexityDefect_depth_point_get, _cv.CvConvexityDefect_depth_point_set)
    __swig_setmethods__["depth"] = _cv.CvConvexityDefect_depth_set
    __swig_getmethods__["depth"] = _cv.CvConvexityDefect_depth_get
    if _newclass:depth = _swig_property(_cv.CvConvexityDefect_depth_get, _cv.CvConvexityDefect_depth_set)
    def __init__(self): 
        """__init__(self) -> CvConvexityDefect"""
        this = _cv.new_CvConvexityDefect()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvConvexityDefect
    __del__ = lambda self : None;
CvConvexityDefect_swigregister = _cv.CvConvexityDefect_swigregister
CvConvexityDefect_swigregister(CvConvexityDefect)

class CvQuadEdge2D(_object):
    """Proxy of C++ CvQuadEdge2D class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvQuadEdge2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvQuadEdge2D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvQuadEdge2D_flags_set
    __swig_getmethods__["flags"] = _cv.CvQuadEdge2D_flags_get
    if _newclass:flags = _swig_property(_cv.CvQuadEdge2D_flags_get, _cv.CvQuadEdge2D_flags_set)
    __swig_setmethods__["pt"] = _cv.CvQuadEdge2D_pt_set
    __swig_getmethods__["pt"] = _cv.CvQuadEdge2D_pt_get
    if _newclass:pt = _swig_property(_cv.CvQuadEdge2D_pt_get, _cv.CvQuadEdge2D_pt_set)
    __swig_setmethods__["next"] = _cv.CvQuadEdge2D_next_set
    __swig_getmethods__["next"] = _cv.CvQuadEdge2D_next_get
    if _newclass:next = _swig_property(_cv.CvQuadEdge2D_next_get, _cv.CvQuadEdge2D_next_set)
    def __init__(self): 
        """__init__(self) -> CvQuadEdge2D"""
        this = _cv.new_CvQuadEdge2D()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvQuadEdge2D
    __del__ = lambda self : None;
CvQuadEdge2D_swigregister = _cv.CvQuadEdge2D_swigregister
CvQuadEdge2D_swigregister(CvQuadEdge2D)

class CvSubdiv2DPoint(_object):
    """Proxy of C++ CvSubdiv2DPoint class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSubdiv2DPoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSubdiv2DPoint, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvSubdiv2DPoint_flags_set
    __swig_getmethods__["flags"] = _cv.CvSubdiv2DPoint_flags_get
    if _newclass:flags = _swig_property(_cv.CvSubdiv2DPoint_flags_get, _cv.CvSubdiv2DPoint_flags_set)
    __swig_setmethods__["first"] = _cv.CvSubdiv2DPoint_first_set
    __swig_getmethods__["first"] = _cv.CvSubdiv2DPoint_first_get
    if _newclass:first = _swig_property(_cv.CvSubdiv2DPoint_first_get, _cv.CvSubdiv2DPoint_first_set)
    __swig_setmethods__["pt"] = _cv.CvSubdiv2DPoint_pt_set
    __swig_getmethods__["pt"] = _cv.CvSubdiv2DPoint_pt_get
    if _newclass:pt = _swig_property(_cv.CvSubdiv2DPoint_pt_get, _cv.CvSubdiv2DPoint_pt_set)
    def __init__(self): 
        """__init__(self) -> CvSubdiv2DPoint"""
        this = _cv.new_CvSubdiv2DPoint()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSubdiv2DPoint
    __del__ = lambda self : None;
CvSubdiv2DPoint_swigregister = _cv.CvSubdiv2DPoint_swigregister
CvSubdiv2DPoint_swigregister(CvSubdiv2DPoint)

class CvSubdiv2D(_object):
    """Proxy of C++ CvSubdiv2D class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSubdiv2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSubdiv2D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvSubdiv2D_flags_set
    __swig_getmethods__["flags"] = _cv.CvSubdiv2D_flags_get
    if _newclass:flags = _swig_property(_cv.CvSubdiv2D_flags_get, _cv.CvSubdiv2D_flags_set)
    __swig_setmethods__["header_size"] = _cv.CvSubdiv2D_header_size_set
    __swig_getmethods__["header_size"] = _cv.CvSubdiv2D_header_size_get
    if _newclass:header_size = _swig_property(_cv.CvSubdiv2D_header_size_get, _cv.CvSubdiv2D_header_size_set)
    __swig_setmethods__["h_prev"] = _cv.CvSubdiv2D_h_prev_set
    __swig_getmethods__["h_prev"] = _cv.CvSubdiv2D_h_prev_get
    if _newclass:h_prev = _swig_property(_cv.CvSubdiv2D_h_prev_get, _cv.CvSubdiv2D_h_prev_set)
    __swig_setmethods__["h_next"] = _cv.CvSubdiv2D_h_next_set
    __swig_getmethods__["h_next"] = _cv.CvSubdiv2D_h_next_get
    if _newclass:h_next = _swig_property(_cv.CvSubdiv2D_h_next_get, _cv.CvSubdiv2D_h_next_set)
    __swig_setmethods__["v_prev"] = _cv.CvSubdiv2D_v_prev_set
    __swig_getmethods__["v_prev"] = _cv.CvSubdiv2D_v_prev_get
    if _newclass:v_prev = _swig_property(_cv.CvSubdiv2D_v_prev_get, _cv.CvSubdiv2D_v_prev_set)
    __swig_setmethods__["v_next"] = _cv.CvSubdiv2D_v_next_set
    __swig_getmethods__["v_next"] = _cv.CvSubdiv2D_v_next_get
    if _newclass:v_next = _swig_property(_cv.CvSubdiv2D_v_next_get, _cv.CvSubdiv2D_v_next_set)
    __swig_setmethods__["total"] = _cv.CvSubdiv2D_total_set
    __swig_getmethods__["total"] = _cv.CvSubdiv2D_total_get
    if _newclass:total = _swig_property(_cv.CvSubdiv2D_total_get, _cv.CvSubdiv2D_total_set)
    __swig_setmethods__["elem_size"] = _cv.CvSubdiv2D_elem_size_set
    __swig_getmethods__["elem_size"] = _cv.CvSubdiv2D_elem_size_get
    if _newclass:elem_size = _swig_property(_cv.CvSubdiv2D_elem_size_get, _cv.CvSubdiv2D_elem_size_set)
    __swig_setmethods__["block_max"] = _cv.CvSubdiv2D_block_max_set
    __swig_getmethods__["block_max"] = _cv.CvSubdiv2D_block_max_get
    if _newclass:block_max = _swig_property(_cv.CvSubdiv2D_block_max_get, _cv.CvSubdiv2D_block_max_set)
    __swig_setmethods__["ptr"] = _cv.CvSubdiv2D_ptr_set
    __swig_getmethods__["ptr"] = _cv.CvSubdiv2D_ptr_get
    if _newclass:ptr = _swig_property(_cv.CvSubdiv2D_ptr_get, _cv.CvSubdiv2D_ptr_set)
    __swig_setmethods__["delta_elems"] = _cv.CvSubdiv2D_delta_elems_set
    __swig_getmethods__["delta_elems"] = _cv.CvSubdiv2D_delta_elems_get
    if _newclass:delta_elems = _swig_property(_cv.CvSubdiv2D_delta_elems_get, _cv.CvSubdiv2D_delta_elems_set)
    __swig_setmethods__["storage"] = _cv.CvSubdiv2D_storage_set
    __swig_getmethods__["storage"] = _cv.CvSubdiv2D_storage_get
    if _newclass:storage = _swig_property(_cv.CvSubdiv2D_storage_get, _cv.CvSubdiv2D_storage_set)
    __swig_setmethods__["free_blocks"] = _cv.CvSubdiv2D_free_blocks_set
    __swig_getmethods__["free_blocks"] = _cv.CvSubdiv2D_free_blocks_get
    if _newclass:free_blocks = _swig_property(_cv.CvSubdiv2D_free_blocks_get, _cv.CvSubdiv2D_free_blocks_set)
    __swig_setmethods__["first"] = _cv.CvSubdiv2D_first_set
    __swig_getmethods__["first"] = _cv.CvSubdiv2D_first_get
    if _newclass:first = _swig_property(_cv.CvSubdiv2D_first_get, _cv.CvSubdiv2D_first_set)
    __swig_setmethods__["free_elems"] = _cv.CvSubdiv2D_free_elems_set
    __swig_getmethods__["free_elems"] = _cv.CvSubdiv2D_free_elems_get
    if _newclass:free_elems = _swig_property(_cv.CvSubdiv2D_free_elems_get, _cv.CvSubdiv2D_free_elems_set)
    __swig_setmethods__["active_count"] = _cv.CvSubdiv2D_active_count_set
    __swig_getmethods__["active_count"] = _cv.CvSubdiv2D_active_count_get
    if _newclass:active_count = _swig_property(_cv.CvSubdiv2D_active_count_get, _cv.CvSubdiv2D_active_count_set)
    __swig_setmethods__["quad_edges"] = _cv.CvSubdiv2D_quad_edges_set
    __swig_getmethods__["quad_edges"] = _cv.CvSubdiv2D_quad_edges_get
    if _newclass:quad_edges = _swig_property(_cv.CvSubdiv2D_quad_edges_get, _cv.CvSubdiv2D_quad_edges_set)
    __swig_setmethods__["is_geometry_valid"] = _cv.CvSubdiv2D_is_geometry_valid_set
    __swig_getmethods__["is_geometry_valid"] = _cv.CvSubdiv2D_is_geometry_valid_get
    if _newclass:is_geometry_valid = _swig_property(_cv.CvSubdiv2D_is_geometry_valid_get, _cv.CvSubdiv2D_is_geometry_valid_set)
    __swig_setmethods__["recent_edge"] = _cv.CvSubdiv2D_recent_edge_set
    __swig_getmethods__["recent_edge"] = _cv.CvSubdiv2D_recent_edge_get
    if _newclass:recent_edge = _swig_property(_cv.CvSubdiv2D_recent_edge_get, _cv.CvSubdiv2D_recent_edge_set)
    __swig_setmethods__["topleft"] = _cv.CvSubdiv2D_topleft_set
    __swig_getmethods__["topleft"] = _cv.CvSubdiv2D_topleft_get
    if _newclass:topleft = _swig_property(_cv.CvSubdiv2D_topleft_get, _cv.CvSubdiv2D_topleft_set)
    __swig_setmethods__["bottomright"] = _cv.CvSubdiv2D_bottomright_set
    __swig_getmethods__["bottomright"] = _cv.CvSubdiv2D_bottomright_get
    if _newclass:bottomright = _swig_property(_cv.CvSubdiv2D_bottomright_get, _cv.CvSubdiv2D_bottomright_set)
    __swig_setmethods__["edges"] = _cv.CvSubdiv2D_edges_set
    __swig_getmethods__["edges"] = _cv.CvSubdiv2D_edges_get
    if _newclass:edges = _swig_property(_cv.CvSubdiv2D_edges_get, _cv.CvSubdiv2D_edges_set)
    def typed_edges_get(self):
        """typed_edges_get(self) -> CvSeq_CvQuadEdge2D"""
        return _cv.CvSubdiv2D_typed_edges_get(self)

    def typed_edges_set(self, *args):
        """typed_edges_set(self, CvSeq_CvQuadEdge2D arg0)"""
        return _cv.CvSubdiv2D_typed_edges_set(self, *args)

    def __iter__(self):
    	s = CvSeq_QuadEdge2D.cast(self)
    	for i in range(s.total):
    		yield s[i]

    def __init__(self): 
        """__init__(self) -> CvSubdiv2D"""
        this = _cv.new_CvSubdiv2D()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSubdiv2D
    __del__ = lambda self : None;
CvSubdiv2D_swigregister = _cv.CvSubdiv2D_swigregister
CvSubdiv2D_swigregister(CvSubdiv2D)

CV_PTLOC_ERROR = _cv.CV_PTLOC_ERROR
CV_PTLOC_OUTSIDE_RECT = _cv.CV_PTLOC_OUTSIDE_RECT
CV_PTLOC_INSIDE = _cv.CV_PTLOC_INSIDE
CV_PTLOC_VERTEX = _cv.CV_PTLOC_VERTEX
CV_PTLOC_ON_EDGE = _cv.CV_PTLOC_ON_EDGE
CV_NEXT_AROUND_ORG = _cv.CV_NEXT_AROUND_ORG
CV_NEXT_AROUND_DST = _cv.CV_NEXT_AROUND_DST
CV_PREV_AROUND_ORG = _cv.CV_PREV_AROUND_ORG
CV_PREV_AROUND_DST = _cv.CV_PREV_AROUND_DST
CV_NEXT_AROUND_LEFT = _cv.CV_NEXT_AROUND_LEFT
CV_NEXT_AROUND_RIGHT = _cv.CV_NEXT_AROUND_RIGHT
CV_PREV_AROUND_LEFT = _cv.CV_PREV_AROUND_LEFT
CV_PREV_AROUND_RIGHT = _cv.CV_PREV_AROUND_RIGHT
CV_GAUSSIAN_5x5 = _cv.CV_GAUSSIAN_5x5
class CvMatrix3(_object):
    """Proxy of C++ CvMatrix3 class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvMatrix3, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvMatrix3, name)
    __repr__ = _swig_repr
    __swig_setmethods__["m"] = _cv.CvMatrix3_m_set
    __swig_getmethods__["m"] = _cv.CvMatrix3_m_get
    if _newclass:m = _swig_property(_cv.CvMatrix3_m_get, _cv.CvMatrix3_m_set)
    def __init__(self): 
        """__init__(self) -> CvMatrix3"""
        this = _cv.new_CvMatrix3()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvMatrix3
    __del__ = lambda self : None;
CvMatrix3_swigregister = _cv.CvMatrix3_swigregister
CvMatrix3_swigregister(CvMatrix3)

class CvConDensation(_object):
    """Proxy of C++ CvConDensation class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvConDensation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvConDensation, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["MP"] = _cv.CvConDensation_MP_set
    __swig_getmethods__["MP"] = _cv.CvConDensation_MP_get
    if _newclass:MP = _swig_property(_cv.CvConDensation_MP_get, _cv.CvConDensation_MP_set)
    __swig_setmethods__["DP"] = _cv.CvConDensation_DP_set
    __swig_getmethods__["DP"] = _cv.CvConDensation_DP_get
    if _newclass:DP = _swig_property(_cv.CvConDensation_DP_get, _cv.CvConDensation_DP_set)
    __swig_setmethods__["DynamMatr"] = _cv.CvConDensation_DynamMatr_set
    __swig_getmethods__["DynamMatr"] = _cv.CvConDensation_DynamMatr_get
    if _newclass:DynamMatr = _swig_property(_cv.CvConDensation_DynamMatr_get, _cv.CvConDensation_DynamMatr_set)
    __swig_setmethods__["State"] = _cv.CvConDensation_State_set
    __swig_getmethods__["State"] = _cv.CvConDensation_State_get
    if _newclass:State = _swig_property(_cv.CvConDensation_State_get, _cv.CvConDensation_State_set)
    __swig_setmethods__["SamplesNum"] = _cv.CvConDensation_SamplesNum_set
    __swig_getmethods__["SamplesNum"] = _cv.CvConDensation_SamplesNum_get
    if _newclass:SamplesNum = _swig_property(_cv.CvConDensation_SamplesNum_get, _cv.CvConDensation_SamplesNum_set)
    __swig_setmethods__["flSamples"] = _cv.CvConDensation_flSamples_set
    __swig_getmethods__["flSamples"] = _cv.CvConDensation_flSamples_get
    if _newclass:flSamples = _swig_property(_cv.CvConDensation_flSamples_get, _cv.CvConDensation_flSamples_set)
    __swig_setmethods__["flNewSamples"] = _cv.CvConDensation_flNewSamples_set
    __swig_getmethods__["flNewSamples"] = _cv.CvConDensation_flNewSamples_get
    if _newclass:flNewSamples = _swig_property(_cv.CvConDensation_flNewSamples_get, _cv.CvConDensation_flNewSamples_set)
    __swig_setmethods__["flConfidence"] = _cv.CvConDensation_flConfidence_set
    __swig_getmethods__["flConfidence"] = _cv.CvConDensation_flConfidence_get
    if _newclass:flConfidence = _swig_property(_cv.CvConDensation_flConfidence_get, _cv.CvConDensation_flConfidence_set)
    __swig_setmethods__["flCumulative"] = _cv.CvConDensation_flCumulative_set
    __swig_getmethods__["flCumulative"] = _cv.CvConDensation_flCumulative_get
    if _newclass:flCumulative = _swig_property(_cv.CvConDensation_flCumulative_get, _cv.CvConDensation_flCumulative_set)
    __swig_setmethods__["Temp"] = _cv.CvConDensation_Temp_set
    __swig_getmethods__["Temp"] = _cv.CvConDensation_Temp_get
    if _newclass:Temp = _swig_property(_cv.CvConDensation_Temp_get, _cv.CvConDensation_Temp_set)
    __swig_setmethods__["RandomSample"] = _cv.CvConDensation_RandomSample_set
    __swig_getmethods__["RandomSample"] = _cv.CvConDensation_RandomSample_get
    if _newclass:RandomSample = _swig_property(_cv.CvConDensation_RandomSample_get, _cv.CvConDensation_RandomSample_set)
    __swig_setmethods__["RandS"] = _cv.CvConDensation_RandS_set
    __swig_getmethods__["RandS"] = _cv.CvConDensation_RandS_get
    if _newclass:RandS = _swig_property(_cv.CvConDensation_RandS_get, _cv.CvConDensation_RandS_set)
    __swig_destroy__ = _cv.delete_CvConDensation
    __del__ = lambda self : None;
CvConDensation_swigregister = _cv.CvConDensation_swigregister
CvConDensation_swigregister(CvConDensation)

class CvKalman(_object):
    """Proxy of C++ CvKalman class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvKalman, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvKalman, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["MP"] = _cv.CvKalman_MP_set
    __swig_getmethods__["MP"] = _cv.CvKalman_MP_get
    if _newclass:MP = _swig_property(_cv.CvKalman_MP_get, _cv.CvKalman_MP_set)
    __swig_setmethods__["DP"] = _cv.CvKalman_DP_set
    __swig_getmethods__["DP"] = _cv.CvKalman_DP_get
    if _newclass:DP = _swig_property(_cv.CvKalman_DP_get, _cv.CvKalman_DP_set)
    __swig_setmethods__["CP"] = _cv.CvKalman_CP_set
    __swig_getmethods__["CP"] = _cv.CvKalman_CP_get
    if _newclass:CP = _swig_property(_cv.CvKalman_CP_get, _cv.CvKalman_CP_set)
    __swig_setmethods__["PosterState"] = _cv.CvKalman_PosterState_set
    __swig_getmethods__["PosterState"] = _cv.CvKalman_PosterState_get
    if _newclass:PosterState = _swig_property(_cv.CvKalman_PosterState_get, _cv.CvKalman_PosterState_set)
    __swig_setmethods__["PriorState"] = _cv.CvKalman_PriorState_set
    __swig_getmethods__["PriorState"] = _cv.CvKalman_PriorState_get
    if _newclass:PriorState = _swig_property(_cv.CvKalman_PriorState_get, _cv.CvKalman_PriorState_set)
    __swig_setmethods__["DynamMatr"] = _cv.CvKalman_DynamMatr_set
    __swig_getmethods__["DynamMatr"] = _cv.CvKalman_DynamMatr_get
    if _newclass:DynamMatr = _swig_property(_cv.CvKalman_DynamMatr_get, _cv.CvKalman_DynamMatr_set)
    __swig_setmethods__["MeasurementMatr"] = _cv.CvKalman_MeasurementMatr_set
    __swig_getmethods__["MeasurementMatr"] = _cv.CvKalman_MeasurementMatr_get
    if _newclass:MeasurementMatr = _swig_property(_cv.CvKalman_MeasurementMatr_get, _cv.CvKalman_MeasurementMatr_set)
    __swig_setmethods__["MNCovariance"] = _cv.CvKalman_MNCovariance_set
    __swig_getmethods__["MNCovariance"] = _cv.CvKalman_MNCovariance_get
    if _newclass:MNCovariance = _swig_property(_cv.CvKalman_MNCovariance_get, _cv.CvKalman_MNCovariance_set)
    __swig_setmethods__["PNCovariance"] = _cv.CvKalman_PNCovariance_set
    __swig_getmethods__["PNCovariance"] = _cv.CvKalman_PNCovariance_get
    if _newclass:PNCovariance = _swig_property(_cv.CvKalman_PNCovariance_get, _cv.CvKalman_PNCovariance_set)
    __swig_setmethods__["KalmGainMatr"] = _cv.CvKalman_KalmGainMatr_set
    __swig_getmethods__["KalmGainMatr"] = _cv.CvKalman_KalmGainMatr_get
    if _newclass:KalmGainMatr = _swig_property(_cv.CvKalman_KalmGainMatr_get, _cv.CvKalman_KalmGainMatr_set)
    __swig_setmethods__["PriorErrorCovariance"] = _cv.CvKalman_PriorErrorCovariance_set
    __swig_getmethods__["PriorErrorCovariance"] = _cv.CvKalman_PriorErrorCovariance_get
    if _newclass:PriorErrorCovariance = _swig_property(_cv.CvKalman_PriorErrorCovariance_get, _cv.CvKalman_PriorErrorCovariance_set)
    __swig_setmethods__["PosterErrorCovariance"] = _cv.CvKalman_PosterErrorCovariance_set
    __swig_getmethods__["PosterErrorCovariance"] = _cv.CvKalman_PosterErrorCovariance_get
    if _newclass:PosterErrorCovariance = _swig_property(_cv.CvKalman_PosterErrorCovariance_get, _cv.CvKalman_PosterErrorCovariance_set)
    __swig_setmethods__["Temp1"] = _cv.CvKalman_Temp1_set
    __swig_getmethods__["Temp1"] = _cv.CvKalman_Temp1_get
    if _newclass:Temp1 = _swig_property(_cv.CvKalman_Temp1_get, _cv.CvKalman_Temp1_set)
    __swig_setmethods__["Temp2"] = _cv.CvKalman_Temp2_set
    __swig_getmethods__["Temp2"] = _cv.CvKalman_Temp2_get
    if _newclass:Temp2 = _swig_property(_cv.CvKalman_Temp2_get, _cv.CvKalman_Temp2_set)
    __swig_setmethods__["state_pre"] = _cv.CvKalman_state_pre_set
    __swig_getmethods__["state_pre"] = _cv.CvKalman_state_pre_get
    if _newclass:state_pre = _swig_property(_cv.CvKalman_state_pre_get, _cv.CvKalman_state_pre_set)
    __swig_setmethods__["state_post"] = _cv.CvKalman_state_post_set
    __swig_getmethods__["state_post"] = _cv.CvKalman_state_post_get
    if _newclass:state_post = _swig_property(_cv.CvKalman_state_post_get, _cv.CvKalman_state_post_set)
    __swig_setmethods__["transition_matrix"] = _cv.CvKalman_transition_matrix_set
    __swig_getmethods__["transition_matrix"] = _cv.CvKalman_transition_matrix_get
    if _newclass:transition_matrix = _swig_property(_cv.CvKalman_transition_matrix_get, _cv.CvKalman_transition_matrix_set)
    __swig_setmethods__["control_matrix"] = _cv.CvKalman_control_matrix_set
    __swig_getmethods__["control_matrix"] = _cv.CvKalman_control_matrix_get
    if _newclass:control_matrix = _swig_property(_cv.CvKalman_control_matrix_get, _cv.CvKalman_control_matrix_set)
    __swig_setmethods__["measurement_matrix"] = _cv.CvKalman_measurement_matrix_set
    __swig_getmethods__["measurement_matrix"] = _cv.CvKalman_measurement_matrix_get
    if _newclass:measurement_matrix = _swig_property(_cv.CvKalman_measurement_matrix_get, _cv.CvKalman_measurement_matrix_set)
    __swig_setmethods__["process_noise_cov"] = _cv.CvKalman_process_noise_cov_set
    __swig_getmethods__["process_noise_cov"] = _cv.CvKalman_process_noise_cov_get
    if _newclass:process_noise_cov = _swig_property(_cv.CvKalman_process_noise_cov_get, _cv.CvKalman_process_noise_cov_set)
    __swig_setmethods__["measurement_noise_cov"] = _cv.CvKalman_measurement_noise_cov_set
    __swig_getmethods__["measurement_noise_cov"] = _cv.CvKalman_measurement_noise_cov_get
    if _newclass:measurement_noise_cov = _swig_property(_cv.CvKalman_measurement_noise_cov_get, _cv.CvKalman_measurement_noise_cov_set)
    __swig_setmethods__["error_cov_pre"] = _cv.CvKalman_error_cov_pre_set
    __swig_getmethods__["error_cov_pre"] = _cv.CvKalman_error_cov_pre_get
    if _newclass:error_cov_pre = _swig_property(_cv.CvKalman_error_cov_pre_get, _cv.CvKalman_error_cov_pre_set)
    __swig_setmethods__["gain"] = _cv.CvKalman_gain_set
    __swig_getmethods__["gain"] = _cv.CvKalman_gain_get
    if _newclass:gain = _swig_property(_cv.CvKalman_gain_get, _cv.CvKalman_gain_set)
    __swig_setmethods__["error_cov_post"] = _cv.CvKalman_error_cov_post_set
    __swig_getmethods__["error_cov_post"] = _cv.CvKalman_error_cov_post_get
    if _newclass:error_cov_post = _swig_property(_cv.CvKalman_error_cov_post_get, _cv.CvKalman_error_cov_post_set)
    __swig_setmethods__["temp1"] = _cv.CvKalman_temp1_set
    __swig_getmethods__["temp1"] = _cv.CvKalman_temp1_get
    if _newclass:temp1 = _swig_property(_cv.CvKalman_temp1_get, _cv.CvKalman_temp1_set)
    __swig_setmethods__["temp2"] = _cv.CvKalman_temp2_set
    __swig_getmethods__["temp2"] = _cv.CvKalman_temp2_get
    if _newclass:temp2 = _swig_property(_cv.CvKalman_temp2_get, _cv.CvKalman_temp2_set)
    __swig_setmethods__["temp3"] = _cv.CvKalman_temp3_set
    __swig_getmethods__["temp3"] = _cv.CvKalman_temp3_get
    if _newclass:temp3 = _swig_property(_cv.CvKalman_temp3_get, _cv.CvKalman_temp3_set)
    __swig_setmethods__["temp4"] = _cv.CvKalman_temp4_set
    __swig_getmethods__["temp4"] = _cv.CvKalman_temp4_get
    if _newclass:temp4 = _swig_property(_cv.CvKalman_temp4_get, _cv.CvKalman_temp4_set)
    __swig_setmethods__["temp5"] = _cv.CvKalman_temp5_set
    __swig_getmethods__["temp5"] = _cv.CvKalman_temp5_get
    if _newclass:temp5 = _swig_property(_cv.CvKalman_temp5_get, _cv.CvKalman_temp5_set)
    __swig_destroy__ = _cv.delete_CvKalman
    __del__ = lambda self : None;
CvKalman_swigregister = _cv.CvKalman_swigregister
CvKalman_swigregister(CvKalman)

class CvHaarFeature(_object):
    """Proxy of C++ CvHaarFeature class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvHaarFeature, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvHaarFeature, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tilted"] = _cv.CvHaarFeature_tilted_set
    __swig_getmethods__["tilted"] = _cv.CvHaarFeature_tilted_get
    if _newclass:tilted = _swig_property(_cv.CvHaarFeature_tilted_get, _cv.CvHaarFeature_tilted_set)
    __swig_getmethods__["rect"] = _cv.CvHaarFeature_rect_get
    if _newclass:rect = _swig_property(_cv.CvHaarFeature_rect_get)
    def __init__(self): 
        """__init__(self) -> CvHaarFeature"""
        this = _cv.new_CvHaarFeature()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvHaarFeature
    __del__ = lambda self : None;
CvHaarFeature_swigregister = _cv.CvHaarFeature_swigregister
CvHaarFeature_swigregister(CvHaarFeature)

class CvHaarFeature_rect(_object):
    """Proxy of C++ CvHaarFeature_rect class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvHaarFeature_rect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvHaarFeature_rect, name)
    __repr__ = _swig_repr
    __swig_setmethods__["r"] = _cv.CvHaarFeature_rect_r_set
    __swig_getmethods__["r"] = _cv.CvHaarFeature_rect_r_get
    if _newclass:r = _swig_property(_cv.CvHaarFeature_rect_r_get, _cv.CvHaarFeature_rect_r_set)
    __swig_setmethods__["weight"] = _cv.CvHaarFeature_rect_weight_set
    __swig_getmethods__["weight"] = _cv.CvHaarFeature_rect_weight_get
    if _newclass:weight = _swig_property(_cv.CvHaarFeature_rect_weight_get, _cv.CvHaarFeature_rect_weight_set)
    def __init__(self): 
        """__init__(self) -> CvHaarFeature_rect"""
        this = _cv.new_CvHaarFeature_rect()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvHaarFeature_rect
    __del__ = lambda self : None;
CvHaarFeature_rect_swigregister = _cv.CvHaarFeature_rect_swigregister
CvHaarFeature_rect_swigregister(CvHaarFeature_rect)

class CvHaarClassifier(_object):
    """Proxy of C++ CvHaarClassifier class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvHaarClassifier, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvHaarClassifier, name)
    __repr__ = _swig_repr
    __swig_setmethods__["count"] = _cv.CvHaarClassifier_count_set
    __swig_getmethods__["count"] = _cv.CvHaarClassifier_count_get
    if _newclass:count = _swig_property(_cv.CvHaarClassifier_count_get, _cv.CvHaarClassifier_count_set)
    __swig_setmethods__["haar_feature"] = _cv.CvHaarClassifier_haar_feature_set
    __swig_getmethods__["haar_feature"] = _cv.CvHaarClassifier_haar_feature_get
    if _newclass:haar_feature = _swig_property(_cv.CvHaarClassifier_haar_feature_get, _cv.CvHaarClassifier_haar_feature_set)
    __swig_setmethods__["threshold"] = _cv.CvHaarClassifier_threshold_set
    __swig_getmethods__["threshold"] = _cv.CvHaarClassifier_threshold_get
    if _newclass:threshold = _swig_property(_cv.CvHaarClassifier_threshold_get, _cv.CvHaarClassifier_threshold_set)
    __swig_setmethods__["left"] = _cv.CvHaarClassifier_left_set
    __swig_getmethods__["left"] = _cv.CvHaarClassifier_left_get
    if _newclass:left = _swig_property(_cv.CvHaarClassifier_left_get, _cv.CvHaarClassifier_left_set)
    __swig_setmethods__["right"] = _cv.CvHaarClassifier_right_set
    __swig_getmethods__["right"] = _cv.CvHaarClassifier_right_get
    if _newclass:right = _swig_property(_cv.CvHaarClassifier_right_get, _cv.CvHaarClassifier_right_set)
    __swig_setmethods__["alpha"] = _cv.CvHaarClassifier_alpha_set
    __swig_getmethods__["alpha"] = _cv.CvHaarClassifier_alpha_get
    if _newclass:alpha = _swig_property(_cv.CvHaarClassifier_alpha_get, _cv.CvHaarClassifier_alpha_set)
    def __init__(self): 
        """__init__(self) -> CvHaarClassifier"""
        this = _cv.new_CvHaarClassifier()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvHaarClassifier
    __del__ = lambda self : None;
CvHaarClassifier_swigregister = _cv.CvHaarClassifier_swigregister
CvHaarClassifier_swigregister(CvHaarClassifier)

class CvHaarStageClassifier(_object):
    """Proxy of C++ CvHaarStageClassifier class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvHaarStageClassifier, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvHaarStageClassifier, name)
    __repr__ = _swig_repr
    __swig_setmethods__["count"] = _cv.CvHaarStageClassifier_count_set
    __swig_getmethods__["count"] = _cv.CvHaarStageClassifier_count_get
    if _newclass:count = _swig_property(_cv.CvHaarStageClassifier_count_get, _cv.CvHaarStageClassifier_count_set)
    __swig_setmethods__["threshold"] = _cv.CvHaarStageClassifier_threshold_set
    __swig_getmethods__["threshold"] = _cv.CvHaarStageClassifier_threshold_get
    if _newclass:threshold = _swig_property(_cv.CvHaarStageClassifier_threshold_get, _cv.CvHaarStageClassifier_threshold_set)
    __swig_setmethods__["classifier"] = _cv.CvHaarStageClassifier_classifier_set
    __swig_getmethods__["classifier"] = _cv.CvHaarStageClassifier_classifier_get
    if _newclass:classifier = _swig_property(_cv.CvHaarStageClassifier_classifier_get, _cv.CvHaarStageClassifier_classifier_set)
    __swig_setmethods__["next"] = _cv.CvHaarStageClassifier_next_set
    __swig_getmethods__["next"] = _cv.CvHaarStageClassifier_next_get
    if _newclass:next = _swig_property(_cv.CvHaarStageClassifier_next_get, _cv.CvHaarStageClassifier_next_set)
    __swig_setmethods__["child"] = _cv.CvHaarStageClassifier_child_set
    __swig_getmethods__["child"] = _cv.CvHaarStageClassifier_child_get
    if _newclass:child = _swig_property(_cv.CvHaarStageClassifier_child_get, _cv.CvHaarStageClassifier_child_set)
    __swig_setmethods__["parent"] = _cv.CvHaarStageClassifier_parent_set
    __swig_getmethods__["parent"] = _cv.CvHaarStageClassifier_parent_get
    if _newclass:parent = _swig_property(_cv.CvHaarStageClassifier_parent_get, _cv.CvHaarStageClassifier_parent_set)
    def __init__(self): 
        """__init__(self) -> CvHaarStageClassifier"""
        this = _cv.new_CvHaarStageClassifier()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvHaarStageClassifier
    __del__ = lambda self : None;
CvHaarStageClassifier_swigregister = _cv.CvHaarStageClassifier_swigregister
CvHaarStageClassifier_swigregister(CvHaarStageClassifier)

class CvHaarClassifierCascade(_object):
    """Proxy of C++ CvHaarClassifierCascade class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvHaarClassifierCascade, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvHaarClassifierCascade, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["flags"] = _cv.CvHaarClassifierCascade_flags_set
    __swig_getmethods__["flags"] = _cv.CvHaarClassifierCascade_flags_get
    if _newclass:flags = _swig_property(_cv.CvHaarClassifierCascade_flags_get, _cv.CvHaarClassifierCascade_flags_set)
    __swig_setmethods__["count"] = _cv.CvHaarClassifierCascade_count_set
    __swig_getmethods__["count"] = _cv.CvHaarClassifierCascade_count_get
    if _newclass:count = _swig_property(_cv.CvHaarClassifierCascade_count_get, _cv.CvHaarClassifierCascade_count_set)
    __swig_setmethods__["orig_window_size"] = _cv.CvHaarClassifierCascade_orig_window_size_set
    __swig_getmethods__["orig_window_size"] = _cv.CvHaarClassifierCascade_orig_window_size_get
    if _newclass:orig_window_size = _swig_property(_cv.CvHaarClassifierCascade_orig_window_size_get, _cv.CvHaarClassifierCascade_orig_window_size_set)
    __swig_setmethods__["real_window_size"] = _cv.CvHaarClassifierCascade_real_window_size_set
    __swig_getmethods__["real_window_size"] = _cv.CvHaarClassifierCascade_real_window_size_get
    if _newclass:real_window_size = _swig_property(_cv.CvHaarClassifierCascade_real_window_size_get, _cv.CvHaarClassifierCascade_real_window_size_set)
    __swig_setmethods__["scale"] = _cv.CvHaarClassifierCascade_scale_set
    __swig_getmethods__["scale"] = _cv.CvHaarClassifierCascade_scale_get
    if _newclass:scale = _swig_property(_cv.CvHaarClassifierCascade_scale_get, _cv.CvHaarClassifierCascade_scale_set)
    __swig_setmethods__["stage_classifier"] = _cv.CvHaarClassifierCascade_stage_classifier_set
    __swig_getmethods__["stage_classifier"] = _cv.CvHaarClassifierCascade_stage_classifier_get
    if _newclass:stage_classifier = _swig_property(_cv.CvHaarClassifierCascade_stage_classifier_get, _cv.CvHaarClassifierCascade_stage_classifier_set)
    __swig_setmethods__["hid_cascade"] = _cv.CvHaarClassifierCascade_hid_cascade_set
    __swig_getmethods__["hid_cascade"] = _cv.CvHaarClassifierCascade_hid_cascade_get
    if _newclass:hid_cascade = _swig_property(_cv.CvHaarClassifierCascade_hid_cascade_get, _cv.CvHaarClassifierCascade_hid_cascade_set)
    __swig_destroy__ = _cv.delete_CvHaarClassifierCascade
    __del__ = lambda self : None;
CvHaarClassifierCascade_swigregister = _cv.CvHaarClassifierCascade_swigregister
CvHaarClassifierCascade_swigregister(CvHaarClassifierCascade)

class CvAvgComp(_object):
    """Proxy of C++ CvAvgComp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvAvgComp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvAvgComp, name)
    __repr__ = _swig_repr
    __swig_setmethods__["rect"] = _cv.CvAvgComp_rect_set
    __swig_getmethods__["rect"] = _cv.CvAvgComp_rect_get
    if _newclass:rect = _swig_property(_cv.CvAvgComp_rect_get, _cv.CvAvgComp_rect_set)
    __swig_setmethods__["neighbors"] = _cv.CvAvgComp_neighbors_set
    __swig_getmethods__["neighbors"] = _cv.CvAvgComp_neighbors_get
    if _newclass:neighbors = _swig_property(_cv.CvAvgComp_neighbors_get, _cv.CvAvgComp_neighbors_set)
    def __init__(self): 
        """__init__(self) -> CvAvgComp"""
        this = _cv.new_CvAvgComp()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvAvgComp
    __del__ = lambda self : None;
CvAvgComp_swigregister = _cv.CvAvgComp_swigregister
CvAvgComp_swigregister(CvAvgComp)


def cvCopyMakeBorder(*args):
  """
    cvCopyMakeBorder(CvArr src, CvArr dst, CvPoint offset, int bordertype, 
        CvScalar value = cvScalarAll(0))
    """
  return _cv.cvCopyMakeBorder(*args)

def cvSmooth(*args):
  """
    cvSmooth(CvArr src, CvArr dst, int smoothtype = 2, int size1 = 3, 
        int size2 = 0, double sigma1 = 0, double sigma2 = 0)
    """
  return _cv.cvSmooth(*args)

def cvFilter2D(*args):
  """cvFilter2D(CvArr src, CvArr dst, CvMat kernel, CvPoint anchor = cvPoint(-1,-1))"""
  return _cv.cvFilter2D(*args)

def cvIntegral(*args):
  """cvIntegral(CvArr image, CvArr sum, CvArr sqsum = None, CvArr tilted_sum = None)"""
  return _cv.cvIntegral(*args)

def cvPyrDown(*args):
  """cvPyrDown(CvArr src, CvArr dst, int filter = CV_GAUSSIAN_5x5)"""
  return _cv.cvPyrDown(*args)

def cvPyrUp(*args):
  """cvPyrUp(CvArr src, CvArr dst, int filter = CV_GAUSSIAN_5x5)"""
  return _cv.cvPyrUp(*args)

def cvCreatePyramid(*args):
  """
    cvCreatePyramid(CvArr img, int extra_layers, double rate, CvSize layer_sizes = None, 
        CvArr bufarr = None, int calc = 1, 
        int filter = CV_GAUSSIAN_5x5) -> CvMat
    """
  return _cv.cvCreatePyramid(*args)

def cvReleasePyramid(*args):
  """cvReleasePyramid(CvMat pyramid, int extra_layers)"""
  return _cv.cvReleasePyramid(*args)

def cvPyrSegmentationUntyped(*args):
  """
    cvPyrSegmentationUntyped( src,  dst, CvMemStorage storage, int level, double threshold1, 
        double threshold2)
    """
  return _cv.cvPyrSegmentationUntyped(*args)

def cvPyrMeanShiftFiltering(*args):
  """
    cvPyrMeanShiftFiltering(CvArr src, CvArr dst, double sp, double sr, int max_level = 1, 
        CvTermCriteria termcrit = cvTermCriteria(1 +2,5,1))
    """
  return _cv.cvPyrMeanShiftFiltering(*args)

def cvWatershed(*args):
  """cvWatershed(CvArr image, CvArr markers)"""
  return _cv.cvWatershed(*args)

def cvInpaint(*args):
  """
    cvInpaint(CvArr src, CvArr inpaint_mask, CvArr dst, double inpaintRange, 
        int flags)
    """
  return _cv.cvInpaint(*args)

def cvSobel(*args):
  """cvSobel(CvArr src, CvArr dst, int xorder, int yorder, int aperture_size = 3)"""
  return _cv.cvSobel(*args)

def cvLaplace(*args):
  """cvLaplace(CvArr src, CvArr dst, int aperture_size = 3)"""
  return _cv.cvLaplace(*args)

def cvCvtColor(*args):
  """cvCvtColor(CvArr src, CvArr dst, int code)"""
  return _cv.cvCvtColor(*args)

def cvResize(*args):
  """cvResize(CvArr src, CvArr dst, int interpolation = 1)"""
  return _cv.cvResize(*args)

def cvWarpAffine(*args):
  """
    cvWarpAffine(CvArr src, CvArr dst, CvMat map_matrix, int flags = 1+8, 
        CvScalar fillval = cvScalarAll(0))
    """
  return _cv.cvWarpAffine(*args)

def cvGetAffineTransform(*args):
  """cvGetAffineTransform(CvPoint2D32f src, CvPoint2D32f dst, CvMat map_matrix) -> CvMat"""
  return _cv.cvGetAffineTransform(*args)

def cv2DRotationMatrix(*args):
  """cv2DRotationMatrix(CvPoint2D32f center, double angle, double scale, CvMat map_matrix) -> CvMat"""
  return _cv.cv2DRotationMatrix(*args)

def cvWarpPerspective(*args):
  """
    cvWarpPerspective(CvArr src, CvArr dst, CvMat map_matrix, int flags = 1+8, 
        CvScalar fillval = cvScalarAll(0))
    """
  return _cv.cvWarpPerspective(*args)

def cvGetPerspectiveTransform(*args):
  """cvGetPerspectiveTransform(CvPoint2D32f src, CvPoint2D32f dst, CvMat map_matrix) -> CvMat"""
  return _cv.cvGetPerspectiveTransform(*args)

def cvRemap(*args):
  """
    cvRemap(CvArr src, CvArr dst, CvArr mapx, CvArr mapy, int flags = 1+8, 
        CvScalar fillval = cvScalarAll(0))
    """
  return _cv.cvRemap(*args)

def cvConvertMaps(*args):
  """cvConvertMaps(CvArr mapx, CvArr mapy, CvArr mapxy, CvArr mapalpha)"""
  return _cv.cvConvertMaps(*args)

def cvLogPolar(*args):
  """
    cvLogPolar(CvArr src, CvArr dst, CvPoint2D32f center, double M, 
        int flags = 1+8)
    """
  return _cv.cvLogPolar(*args)

def cvLinearPolar(*args):
  """
    cvLinearPolar(CvArr src, CvArr dst, CvPoint2D32f center, double maxRadius, 
        int flags = 1+8)
    """
  return _cv.cvLinearPolar(*args)

def cvCreateStructuringElementEx(*args):
  """
    cvCreateStructuringElementEx(int cols, int rows, int anchor_x, int anchor_y, int shape, 
        int values = None)
    """
  return _cv.cvCreateStructuringElementEx(*args)

def cvErode(*args):
  """cvErode(CvArr src, CvArr dst,  element = None, int iterations = 1)"""
  return _cv.cvErode(*args)

def cvDilate(*args):
  """cvDilate(CvArr src, CvArr dst,  element = None, int iterations = 1)"""
  return _cv.cvDilate(*args)

def cvMorphologyEx(*args):
  """
    cvMorphologyEx(CvArr src, CvArr dst, CvArr temp,  element, int operation, 
        int iterations = 1)
    """
  return _cv.cvMorphologyEx(*args)

def cvMoments(*args):
  """cvMoments(CvArr arr, CvMoments moments, int binary = 0)"""
  return _cv.cvMoments(*args)

def cvGetSpatialMoment(*args):
  """cvGetSpatialMoment(CvMoments moments, int x_order, int y_order) -> double"""
  return _cv.cvGetSpatialMoment(*args)

def cvGetCentralMoment(*args):
  """cvGetCentralMoment(CvMoments moments, int x_order, int y_order) -> double"""
  return _cv.cvGetCentralMoment(*args)

def cvGetNormalizedCentralMoment(*args):
  """cvGetNormalizedCentralMoment(CvMoments moments, int x_order, int y_order) -> double"""
  return _cv.cvGetNormalizedCentralMoment(*args)

def cvGetHuMoments(*args):
  """cvGetHuMoments(CvMoments moments, CvHuMoments hu_moments)"""
  return _cv.cvGetHuMoments(*args)

def cvSampleLine(*args):
  """
    cvSampleLine(CvArr image, CvPoint pt1, CvPoint pt2, void buffer, 
        int connectivity = 8) -> int
    """
  return _cv.cvSampleLine(*args)

def cvGetRectSubPix(*args):
  """cvGetRectSubPix(CvArr src, CvArr dst, CvPoint2D32f center)"""
  return _cv.cvGetRectSubPix(*args)

def cvGetQuadrangleSubPix(*args):
  """cvGetQuadrangleSubPix(CvArr src, CvArr dst, CvMat map_matrix)"""
  return _cv.cvGetQuadrangleSubPix(*args)

def cvMatchTemplate(*args):
  """cvMatchTemplate(CvArr image, CvArr templ, CvArr result, int method)"""
  return _cv.cvMatchTemplate(*args)

def cvCalcEMD2(*args):
  """
    cvCalcEMD2(CvArr signature1, CvArr signature2, int distance_type, 
        CvDistanceFunction distance_func = None, 
        CvArr cost_matrix = None, CvArr flow = None, 
        float lower_bound = None, void userdata = None) -> float
    """
  return _cv.cvCalcEMD2(*args)

def cvFindContoursUntyped(*args):
  """
    cvFindContoursUntyped(CvArr image, CvMemStorage storage, int header_size = sizeof(CvContour), 
        int mode = 1, int method = 2, 
        CvPoint offset = cvPoint(0,0)) -> int
    """
  return _cv.cvFindContoursUntyped(*args)

def cvStartFindContours(*args):
  """
    cvStartFindContours(CvArr image, CvMemStorage storage, int header_size = sizeof(CvContour), 
        int mode = 1, int method = 2, 
        CvPoint offset = cvPoint(0,0)) -> CvContourScanner
    """
  return _cv.cvStartFindContours(*args)

def cvFindNextContour(*args):
  """cvFindNextContour(CvContourScanner scanner) -> CvSeq"""
  return _cv.cvFindNextContour(*args)

def cvSubstituteContour(*args):
  """cvSubstituteContour(CvContourScanner scanner, CvSeq new_contour)"""
  return _cv.cvSubstituteContour(*args)

def cvEndFindContours(*args):
  """cvEndFindContours(CvContourScanner scanner) -> CvSeq"""
  return _cv.cvEndFindContours(*args)

def cvApproxChainsUntyped(*args):
  """
    cvApproxChainsUntyped(CvSeq src_seq, CvMemStorage storage, int method = 2, 
        double parameter = 0, int minimal_perimeter = 0, 
        int recursive = 0) -> CvSeq
    """
  return _cv.cvApproxChainsUntyped(*args)

def cvStartReadChainPoints(*args):
  """cvStartReadChainPoints(CvChain chain, CvChainPtReader reader)"""
  return _cv.cvStartReadChainPoints(*args)

def cvReadChainPoint(*args):
  """cvReadChainPoint(CvChainPtReader reader) -> CvPoint"""
  return _cv.cvReadChainPoint(*args)

def cvCalcOpticalFlowLK(*args):
  """
    cvCalcOpticalFlowLK(CvArr prev, CvArr curr, CvSize win_size, CvArr velx, 
        CvArr vely)
    """
  return _cv.cvCalcOpticalFlowLK(*args)

def cvCalcOpticalFlowBM(*args):
  """
    cvCalcOpticalFlowBM(CvArr prev, CvArr curr, CvSize block_size, CvSize shift_size, 
        CvSize max_range, int use_previous, 
        CvArr velx, CvArr vely)
    """
  return _cv.cvCalcOpticalFlowBM(*args)

def cvCalcOpticalFlowHS(*args):
  """
    cvCalcOpticalFlowHS(CvArr prev, CvArr curr, int use_previous, CvArr velx, 
        CvArr vely, double _lambda, CvTermCriteria criteria)
    """
  return _cv.cvCalcOpticalFlowHS(*args)

def cvCalcOpticalFlowPyrLK(*args):
  """
    cvCalcOpticalFlowPyrLK(CvArr prev, CvArr curr, CvArr prev_pyr, CvArr curr_pyr, 
        CvPoint2D32f prev_features, CvPoint2D32f curr_features, 
        CvSize win_size, int level, char status, 
        float track_error, CvTermCriteria criteria, 
        int flags)
    """
  return _cv.cvCalcOpticalFlowPyrLK(*args)

def cvCalcAffineFlowPyrLK(*args):
  """
    cvCalcAffineFlowPyrLK(CvArr prev, CvArr curr, CvArr prev_pyr, CvArr curr_pyr, 
        CvPoint2D32f prev_features, CvPoint2D32f curr_features, 
        float matrices, int count, CvSize win_size, 
        int level, char status, float track_error, 
        CvTermCriteria criteria, int flags)
    """
  return _cv.cvCalcAffineFlowPyrLK(*args)

def cvEstimateRigidTransform(*args):
  """cvEstimateRigidTransform(CvArr A, CvArr B, CvMat M, int full_affine) -> int"""
  return _cv.cvEstimateRigidTransform(*args)

def cvUpdateMotionHistory(*args):
  """cvUpdateMotionHistory(CvArr silhouette, CvArr mhi, double timestamp, double duration)"""
  return _cv.cvUpdateMotionHistory(*args)

def cvCalcMotionGradient(*args):
  """
    cvCalcMotionGradient(CvArr mhi, CvArr mask, CvArr orientation, double delta1, 
        double delta2, int aperture_size = 3)
    """
  return _cv.cvCalcMotionGradient(*args)

def cvCalcGlobalOrientation(*args):
  """
    cvCalcGlobalOrientation(CvArr orientation, CvArr mask, CvArr mhi, double timestamp, 
        double duration) -> double
    """
  return _cv.cvCalcGlobalOrientation(*args)

def cvAcc(*args):
  """cvAcc(CvArr image, CvArr sum, CvArr mask = None)"""
  return _cv.cvAcc(*args)

def cvSquareAcc(*args):
  """cvSquareAcc(CvArr image, CvArr sqsum, CvArr mask = None)"""
  return _cv.cvSquareAcc(*args)

def cvMultiplyAcc(*args):
  """cvMultiplyAcc(CvArr image1, CvArr image2, CvArr acc, CvArr mask = None)"""
  return _cv.cvMultiplyAcc(*args)

def cvRunningAvg(*args):
  """cvRunningAvg(CvArr image, CvArr acc, double alpha, CvArr mask = None)"""
  return _cv.cvRunningAvg(*args)

def cvCamShift(*args):
  """
    cvCamShift(CvArr prob_image, CvRect window, CvTermCriteria criteria, 
        CvConnectedComp comp, CvBox2D box = None) -> int
    """
  return _cv.cvCamShift(*args)

def cvMeanShift(*args):
  """
    cvMeanShift(CvArr prob_image, CvRect window, CvTermCriteria criteria, 
        CvConnectedComp comp) -> int
    """
  return _cv.cvMeanShift(*args)

def cvCreateConDensation(*args):
  """cvCreateConDensation(int dynam_params, int measure_params, int sample_count) -> CvConDensation"""
  return _cv.cvCreateConDensation(*args)

def cvConDensUpdateByTime(*args):
  """cvConDensUpdateByTime(CvConDensation condens)"""
  return _cv.cvConDensUpdateByTime(*args)

def cvConDensInitSampleSet(*args):
  """cvConDensInitSampleSet(CvConDensation condens, CvMat lower_bound, CvMat upper_bound)"""
  return _cv.cvConDensInitSampleSet(*args)

def cvCreateKalman(*args):
  """cvCreateKalman(int dynam_params, int measure_params, int control_params = 0) -> CvKalman"""
  return _cv.cvCreateKalman(*args)

def cvKalmanPredict(*args):
  """cvKalmanPredict(CvKalman kalman, CvMat control = None) -> CvMat"""
  return _cv.cvKalmanPredict(*args)

def cvKalmanCorrect(*args):
  """cvKalmanCorrect(CvKalman kalman, CvMat measurement) -> CvMat"""
  return _cv.cvKalmanCorrect(*args)

def cvInitSubdivDelaunay2D(*args):
  """cvInitSubdivDelaunay2D(CvSubdiv2D subdiv, CvRect rect)"""
  return _cv.cvInitSubdivDelaunay2D(*args)

def cvCreateSubdiv2D(*args):
  """
    cvCreateSubdiv2D(int subdiv_type, int header_size, int vtx_size, int quadedge_size, 
        CvMemStorage storage) -> CvSubdiv2D
    """
  return _cv.cvCreateSubdiv2D(*args)

def cvCreateSubdivDelaunay2D(*args):
  """cvCreateSubdivDelaunay2D(CvRect rect, CvMemStorage storage) -> CvSubdiv2D"""
  return _cv.cvCreateSubdivDelaunay2D(*args)

def cvSubdivDelaunay2DInsert(*args):
  """cvSubdivDelaunay2DInsert(CvSubdiv2D subdiv, CvPoint2D32f pt) -> CvSubdiv2DPoint"""
  return _cv.cvSubdivDelaunay2DInsert(*args)

def cvSubdiv2DLocate(*args):
  """cvSubdiv2DLocate(CvSubdiv2D subdiv, CvPoint2D32f pt) -> CvSubdiv2DPointLocation"""
  return _cv.cvSubdiv2DLocate(*args)

def cvCalcSubdivVoronoi2D(*args):
  """cvCalcSubdivVoronoi2D(CvSubdiv2D subdiv)"""
  return _cv.cvCalcSubdivVoronoi2D(*args)

def cvClearSubdivVoronoi2D(*args):
  """cvClearSubdivVoronoi2D(CvSubdiv2D subdiv)"""
  return _cv.cvClearSubdivVoronoi2D(*args)

def cvFindNearestPoint2D(*args):
  """cvFindNearestPoint2D(CvSubdiv2D subdiv, CvPoint2D32f pt) -> CvSubdiv2DPoint"""
  return _cv.cvFindNearestPoint2D(*args)

def cvSubdiv2DNextEdge(*args):
  """cvSubdiv2DNextEdge(CvSubdiv2DEdge edge) -> CvSubdiv2DEdge"""
  return _cv.cvSubdiv2DNextEdge(*args)

def cvSubdiv2DRotateEdge(*args):
  """cvSubdiv2DRotateEdge(CvSubdiv2DEdge edge, int rotate) -> CvSubdiv2DEdge"""
  return _cv.cvSubdiv2DRotateEdge(*args)

def cvSubdiv2DSymEdge(*args):
  """cvSubdiv2DSymEdge(CvSubdiv2DEdge edge) -> CvSubdiv2DEdge"""
  return _cv.cvSubdiv2DSymEdge(*args)

def cvSubdiv2DGetEdge(*args):
  """cvSubdiv2DGetEdge(CvSubdiv2DEdge edge, CvNextEdgeType type) -> CvSubdiv2DEdge"""
  return _cv.cvSubdiv2DGetEdge(*args)

def cvSubdiv2DEdgeOrg(*args):
  """cvSubdiv2DEdgeOrg(CvSubdiv2DEdge edge) -> CvSubdiv2DPoint"""
  return _cv.cvSubdiv2DEdgeOrg(*args)

def cvSubdiv2DEdgeDst(*args):
  """cvSubdiv2DEdgeDst(CvSubdiv2DEdge edge) -> CvSubdiv2DPoint"""
  return _cv.cvSubdiv2DEdgeDst(*args)

def cvTriangleArea(*args):
  """cvTriangleArea(CvPoint2D32f a, CvPoint2D32f b, CvPoint2D32f c) -> double"""
  return _cv.cvTriangleArea(*args)

def cvFindDominantPoints(*args):
  """
    cvFindDominantPoints(CvSeq contour, CvMemStorage storage, int method = 1, 
        double parameter1 = 0, double parameter2 = 0, 
        double parameter3 = 0, double parameter4 = 0) -> CvSeq
    """
  return _cv.cvFindDominantPoints(*args)

def cvArcLength(*args):
  """
    cvArcLength(void curve, CvSlice slice = cvSlice(0, 0x3fffffff), 
        int is_closed = -1) -> double
    """
  return _cv.cvArcLength(*args)

def cvBoundingRect(*args):
  """cvBoundingRect(CvArr points, int update = 0) -> CvRect"""
  return _cv.cvBoundingRect(*args)

def cvContourArea(*args):
  """cvContourArea(CvArr contour, CvSlice slice = cvSlice(0, 0x3fffffff)) -> double"""
  return _cv.cvContourArea(*args)

def cvMinAreaRect2(*args):
  """cvMinAreaRect2(CvArr points, CvMemStorage storage = None) -> CvBox2D"""
  return _cv.cvMinAreaRect2(*args)

def cvMinEnclosingCircle(*args):
  """cvMinEnclosingCircle(CvArr points) -> int"""
  return _cv.cvMinEnclosingCircle(*args)

def cvMatchShapes(*args):
  """cvMatchShapes(void object1, void object2, int method, double parameter = 0) -> double"""
  return _cv.cvMatchShapes(*args)

def cvCreateContourTree(*args):
  """cvCreateContourTree(CvSeq contour, CvMemStorage storage, double threshold) -> CvContourTree"""
  return _cv.cvCreateContourTree(*args)

def cvContourFromContourTreeUntyped(*args):
  """cvContourFromContourTreeUntyped(CvContourTree tree, CvMemStorage storage, CvTermCriteria criteria) -> CvSeq"""
  return _cv.cvContourFromContourTreeUntyped(*args)

def cvMatchContourTrees(*args):
  """
    cvMatchContourTrees(CvContourTree tree1, CvContourTree tree2, int method, 
        double threshold) -> double
    """
  return _cv.cvMatchContourTrees(*args)

def cvCalcPGH(*args):
  """cvCalcPGH(CvSeq contour, CvHistogram hist)"""
  return _cv.cvCalcPGH(*args)

def cvCheckContourConvexity(*args):
  """cvCheckContourConvexity(CvArr contour) -> int"""
  return _cv.cvCheckContourConvexity(*args)

def cvConvexityDefectsUntyped(*args):
  """cvConvexityDefectsUntyped(CvArr contour, CvArr convexhull, CvMemStorage storage = None) -> CvSeq"""
  return _cv.cvConvexityDefectsUntyped(*args)

def cvFitEllipse2(*args):
  """cvFitEllipse2(CvArr points) -> CvBox2D"""
  return _cv.cvFitEllipse2(*args)

def cvMaxRect(*args):
  """cvMaxRect(CvRect rect1, CvRect rect2) -> CvRect"""
  return _cv.cvMaxRect(*args)

def cvBoxPoints(*args):
  """cvBoxPoints(CvBox2D box)"""
  return _cv.cvBoxPoints(*args)

def cvPointSeqFromMat(*args):
  """
    cvPointSeqFromMat(int seq_kind, CvArr mat, CvContour contour_header, 
        CvSeqBlock block) -> CvSeq
    """
  return _cv.cvPointSeqFromMat(*args)

def cvPointPolygonTest(*args):
  """cvPointPolygonTest(CvArr contour, CvPoint2D32f pt, int measure_dist) -> double"""
  return _cv.cvPointPolygonTest(*args)

def cvCreateHist(*args):
  """cvCreateHist(int dims, int type, float ranges = None, int uniform = 1) -> CvHistogram"""
  return _cv.cvCreateHist(*args)

def cvSetHistBinRanges(*args):
  """cvSetHistBinRanges(CvHistogram hist, float ranges, int uniform = 1)"""
  return _cv.cvSetHistBinRanges(*args)

def cvMakeHistHeaderForArray(*args):
  """
    cvMakeHistHeaderForArray(int dims, CvHistogram hist, float data, float ranges = None, 
        int uniform = 1) -> CvHistogram
    """
  return _cv.cvMakeHistHeaderForArray(*args)

def cvClearHist(*args):
  """cvClearHist(CvHistogram hist)"""
  return _cv.cvClearHist(*args)

def cvGetMinMaxHistValue(*args):
  """cvGetMinMaxHistValue(CvHistogram hist)"""
  return _cv.cvGetMinMaxHistValue(*args)

def cvNormalizeHist(*args):
  """cvNormalizeHist(CvHistogram hist, double factor)"""
  return _cv.cvNormalizeHist(*args)

def cvThreshHist(*args):
  """cvThreshHist(CvHistogram hist, double threshold)"""
  return _cv.cvThreshHist(*args)

def cvCompareHist(*args):
  """cvCompareHist(CvHistogram hist1, CvHistogram hist2, int method) -> double"""
  return _cv.cvCompareHist(*args)

def cvCopyHist(*args):
  """cvCopyHist(CvHistogram src, CvHistogram dst)"""
  return _cv.cvCopyHist(*args)

def cvCalcBayesianProb(*args):
  """cvCalcBayesianProb(CvHistogram src, int number, CvHistogram dst)"""
  return _cv.cvCalcBayesianProb(*args)

def cvCalcArrHist(*args):
  """cvCalcArrHist(CvArr arr, CvHistogram hist, int accumulate = 0, CvArr mask = None)"""
  return _cv.cvCalcArrHist(*args)

def cvCalcHist(*args):
  """cvCalcHist( image, CvHistogram hist, int accumulate = 0, CvArr mask = None)"""
  return _cv.cvCalcHist(*args)

def cvCalcArrBackProject(*args):
  """cvCalcArrBackProject(CvArr image, CvArr dst, CvHistogram hist)"""
  return _cv.cvCalcArrBackProject(*args)

def cvCalcArrBackProjectPatch(*args):
  """
    cvCalcArrBackProjectPatch(CvArr image, CvArr dst, CvSize range, CvHistogram hist, 
        int method, double factor)
    """
  return _cv.cvCalcArrBackProjectPatch(*args)

def cvCalcProbDensity(*args):
  """
    cvCalcProbDensity(CvHistogram hist1, CvHistogram hist2, CvHistogram dst_hist, 
        double scale = 255)
    """
  return _cv.cvCalcProbDensity(*args)

def cvEqualizeHist(*args):
  """cvEqualizeHist(CvArr src, CvArr dst)"""
  return _cv.cvEqualizeHist(*args)

def cvCalcImageHomography(*args):
  """cvCalcImageHomography(float line, CvPoint3D32f center, float intrinsic, float homography)"""
  return _cv.cvCalcImageHomography(*args)

def cvDistTransform(*args):
  """
    cvDistTransform(CvArr src, CvArr dst, int distance_type = 2, int mask_size = 3, 
        float mask = None, CvArr labels = None)
    """
  return _cv.cvDistTransform(*args)

def cvThreshold(*args):
  """
    cvThreshold(CvArr src, CvArr dst, double threshold, double max_value, 
        int threshold_type) -> double
    """
  return _cv.cvThreshold(*args)

def cvAdaptiveThreshold(*args):
  """
    cvAdaptiveThreshold(CvArr src, CvArr dst, double max_value, int adaptive_method = 0, 
        int threshold_type = 0, int block_size = 3, 
        double param1 = 5)
    """
  return _cv.cvAdaptiveThreshold(*args)

def cvFloodFill(*args):
  """
    cvFloodFill(CvArr image, CvPoint seed_point, CvScalar new_val, 
        CvScalar lo_diff = cvScalarAll(0), CvScalar up_diff = cvScalarAll(0), 
        CvConnectedComp comp = None, 
        int flags = 4, CvArr mask = None)
    """
  return _cv.cvFloodFill(*args)

def cvCanny(*args):
  """
    cvCanny(CvArr image, CvArr edges, double threshold1, double threshold2, 
        int aperture_size = 3)
    """
  return _cv.cvCanny(*args)

def cvPreCornerDetect(*args):
  """cvPreCornerDetect(CvArr image, CvArr corners, int aperture_size = 3)"""
  return _cv.cvPreCornerDetect(*args)

def cvCornerEigenValsAndVecs(*args):
  """cvCornerEigenValsAndVecs(CvArr image, CvArr eigenvv, int block_size, int aperture_size = 3)"""
  return _cv.cvCornerEigenValsAndVecs(*args)

def cvCornerMinEigenVal(*args):
  """cvCornerMinEigenVal(CvArr image, CvArr eigenval, int block_size, int aperture_size = 3)"""
  return _cv.cvCornerMinEigenVal(*args)

def cvCornerHarris(*args):
  """
    cvCornerHarris(CvArr image, CvArr harris_responce, int block_size, 
        int aperture_size = 3, double k = 0.04)
    """
  return _cv.cvCornerHarris(*args)

def cvFindCornerSubPix(*args):
  """
    cvFindCornerSubPix(CvArr image, CvPoint2D32f corners, CvSize win, CvSize zero_zone, 
        CvTermCriteria criteria)
    """
  return _cv.cvFindCornerSubPix(*args)

def cvGoodFeaturesToTrack(*args):
  """
    cvGoodFeaturesToTrack(CvArr image, CvArr eig_image, CvArr temp_image, CvPoint2D32f corners, 
        double quality_level, double min_distance, 
        CvArr mask = None, int block_size = 3, 
        int use_harris = 0, double k = 0.04)
    """
  return _cv.cvGoodFeaturesToTrack(*args)

def cvHoughLinesUntyped(*args):
  """
    cvHoughLinesUntyped(CvArr image, void line_storage, int method, double rho, 
        double theta, int threshold, double param1 = 0, 
        double param2 = 0) -> CvSeq
    """
  return _cv.cvHoughLinesUntyped(*args)

def cvHoughCirclesUntyped(*args):
  """
    cvHoughCirclesUntyped(CvArr image, void circle_storage, int method, double dp, 
        double min_dist, double param1 = 100, double param2 = 100, 
        int min_radius = 0, int max_radius = 0) -> CvSeq
    """
  return _cv.cvHoughCirclesUntyped(*args)

def cvFitLine(*args):
  """
    cvFitLine(CvArr points, int dist_type, double param, double reps, 
        double aeps, float line)
    """
  return _cv.cvFitLine(*args)

def cvCreateKDTree(*args):
  """cvCreateKDTree(CvMat desc) -> CvFeatureTree"""
  return _cv.cvCreateKDTree(*args)

def cvCreateSpillTree(*args):
  """cvCreateSpillTree(CvMat raw_data, int naive = 50, double rho = .7, double tau = .1) -> CvFeatureTree"""
  return _cv.cvCreateSpillTree(*args)

def cvReleaseFeatureTree(*args):
  """cvReleaseFeatureTree(CvFeatureTree tr)"""
  return _cv.cvReleaseFeatureTree(*args)

def cvFindFeatures(*args):
  """
    cvFindFeatures(CvFeatureTree tr, CvMat query_points, CvMat indices, 
        int emax = 20)
    """
  return _cv.cvFindFeatures(*args)

def cvFindFeaturesBoxed(*args):
  """
    cvFindFeaturesBoxed(CvFeatureTree tr, CvMat bounds_min, CvMat bounds_max, 
        CvMat out_indices) -> int
    """
  return _cv.cvFindFeaturesBoxed(*args)

def cvCreateLSH(*args):
  """
    cvCreateLSH(CvLSHOperations ops, int d, int L = 10, int k = 10, 
        int type = (((6) &((1 << 3) -1)) +(((1) -1) << 3)), 
        double r = 4, int64 seed = -1) -> CvLSH
    """
  return _cv.cvCreateLSH(*args)

def cvCreateMemoryLSH(*args):
  """
    cvCreateMemoryLSH(int d, int n, int L = 10, int k = 10, int type = (((6) &((1 << 3) -1)) +(((1) -1) << 3)), 
        double r = 4, 
        int64 seed = -1) -> CvLSH
    """
  return _cv.cvCreateMemoryLSH(*args)

def cvReleaseLSH(*args):
  """cvReleaseLSH(CvLSH lsh)"""
  return _cv.cvReleaseLSH(*args)

def LSHSize(*args):
  """LSHSize(CvLSH lsh) -> unsigned int"""
  return _cv.LSHSize(*args)

def cvLSHAdd(*args):
  """cvLSHAdd(CvLSH lsh, CvMat data)"""
  return _cv.cvLSHAdd(*args)

def cvLSHRemove(*args):
  """cvLSHRemove(CvLSH lsh, CvMat indices)"""
  return _cv.cvLSHRemove(*args)

def cvLSHQuery(*args):
  """cvLSHQuery(CvLSH lsh, CvMat query_points, CvMat indices, int emax)"""
  return _cv.cvLSHQuery(*args)
class CvSURFPoint(_object):
    """Proxy of C++ CvSURFPoint class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSURFPoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSURFPoint, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pt"] = _cv.CvSURFPoint_pt_set
    __swig_getmethods__["pt"] = _cv.CvSURFPoint_pt_get
    if _newclass:pt = _swig_property(_cv.CvSURFPoint_pt_get, _cv.CvSURFPoint_pt_set)
    __swig_setmethods__["laplacian"] = _cv.CvSURFPoint_laplacian_set
    __swig_getmethods__["laplacian"] = _cv.CvSURFPoint_laplacian_get
    if _newclass:laplacian = _swig_property(_cv.CvSURFPoint_laplacian_get, _cv.CvSURFPoint_laplacian_set)
    __swig_setmethods__["size"] = _cv.CvSURFPoint_size_set
    __swig_getmethods__["size"] = _cv.CvSURFPoint_size_get
    if _newclass:size = _swig_property(_cv.CvSURFPoint_size_get, _cv.CvSURFPoint_size_set)
    __swig_setmethods__["dir"] = _cv.CvSURFPoint_dir_set
    __swig_getmethods__["dir"] = _cv.CvSURFPoint_dir_get
    if _newclass:dir = _swig_property(_cv.CvSURFPoint_dir_get, _cv.CvSURFPoint_dir_set)
    __swig_setmethods__["hessian"] = _cv.CvSURFPoint_hessian_set
    __swig_getmethods__["hessian"] = _cv.CvSURFPoint_hessian_get
    if _newclass:hessian = _swig_property(_cv.CvSURFPoint_hessian_get, _cv.CvSURFPoint_hessian_set)
    def __init__(self): 
        """__init__(self) -> CvSURFPoint"""
        this = _cv.new_CvSURFPoint()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSURFPoint
    __del__ = lambda self : None;
CvSURFPoint_swigregister = _cv.CvSURFPoint_swigregister
CvSURFPoint_swigregister(CvSURFPoint)


def cvSURFPoint(*args):
  """
    cvSURFPoint(CvPoint2D32f pt, int laplacian, int size, float dir = 0, 
        float hessian = 0) -> CvSURFPoint
    """
  return _cv.cvSURFPoint(*args)
class CvSURFParams(_object):
    """Proxy of C++ CvSURFParams class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSURFParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvSURFParams, name)
    __repr__ = _swig_repr
    __swig_setmethods__["extended"] = _cv.CvSURFParams_extended_set
    __swig_getmethods__["extended"] = _cv.CvSURFParams_extended_get
    if _newclass:extended = _swig_property(_cv.CvSURFParams_extended_get, _cv.CvSURFParams_extended_set)
    __swig_setmethods__["hessianThreshold"] = _cv.CvSURFParams_hessianThreshold_set
    __swig_getmethods__["hessianThreshold"] = _cv.CvSURFParams_hessianThreshold_get
    if _newclass:hessianThreshold = _swig_property(_cv.CvSURFParams_hessianThreshold_get, _cv.CvSURFParams_hessianThreshold_set)
    __swig_setmethods__["nOctaves"] = _cv.CvSURFParams_nOctaves_set
    __swig_getmethods__["nOctaves"] = _cv.CvSURFParams_nOctaves_get
    if _newclass:nOctaves = _swig_property(_cv.CvSURFParams_nOctaves_get, _cv.CvSURFParams_nOctaves_set)
    __swig_setmethods__["nOctaveLayers"] = _cv.CvSURFParams_nOctaveLayers_set
    __swig_getmethods__["nOctaveLayers"] = _cv.CvSURFParams_nOctaveLayers_get
    if _newclass:nOctaveLayers = _swig_property(_cv.CvSURFParams_nOctaveLayers_get, _cv.CvSURFParams_nOctaveLayers_set)
    def __init__(self): 
        """__init__(self) -> CvSURFParams"""
        this = _cv.new_CvSURFParams()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSURFParams
    __del__ = lambda self : None;
CvSURFParams_swigregister = _cv.CvSURFParams_swigregister
CvSURFParams_swigregister(CvSURFParams)


def cvSURFParams(*args):
  """cvSURFParams(double hessianThreshold, int extended = 0) -> CvSURFParams"""
  return _cv.cvSURFParams(*args)

def cvExtractSURF(*args):
  """cvExtractSURF(CvArr img, CvArr mask, CvSURFParams params, int useProvidedKeyPts = 0)"""
  return _cv.cvExtractSURF(*args)
class CvMSERParams(_object):
    """Proxy of C++ CvMSERParams class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvMSERParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvMSERParams, name)
    __repr__ = _swig_repr
    __swig_setmethods__["delta"] = _cv.CvMSERParams_delta_set
    __swig_getmethods__["delta"] = _cv.CvMSERParams_delta_get
    if _newclass:delta = _swig_property(_cv.CvMSERParams_delta_get, _cv.CvMSERParams_delta_set)
    __swig_setmethods__["maxArea"] = _cv.CvMSERParams_maxArea_set
    __swig_getmethods__["maxArea"] = _cv.CvMSERParams_maxArea_get
    if _newclass:maxArea = _swig_property(_cv.CvMSERParams_maxArea_get, _cv.CvMSERParams_maxArea_set)
    __swig_setmethods__["minArea"] = _cv.CvMSERParams_minArea_set
    __swig_getmethods__["minArea"] = _cv.CvMSERParams_minArea_get
    if _newclass:minArea = _swig_property(_cv.CvMSERParams_minArea_get, _cv.CvMSERParams_minArea_set)
    __swig_setmethods__["maxVariation"] = _cv.CvMSERParams_maxVariation_set
    __swig_getmethods__["maxVariation"] = _cv.CvMSERParams_maxVariation_get
    if _newclass:maxVariation = _swig_property(_cv.CvMSERParams_maxVariation_get, _cv.CvMSERParams_maxVariation_set)
    __swig_setmethods__["minDiversity"] = _cv.CvMSERParams_minDiversity_set
    __swig_getmethods__["minDiversity"] = _cv.CvMSERParams_minDiversity_get
    if _newclass:minDiversity = _swig_property(_cv.CvMSERParams_minDiversity_get, _cv.CvMSERParams_minDiversity_set)
    __swig_setmethods__["maxEvolution"] = _cv.CvMSERParams_maxEvolution_set
    __swig_getmethods__["maxEvolution"] = _cv.CvMSERParams_maxEvolution_get
    if _newclass:maxEvolution = _swig_property(_cv.CvMSERParams_maxEvolution_get, _cv.CvMSERParams_maxEvolution_set)
    __swig_setmethods__["areaThreshold"] = _cv.CvMSERParams_areaThreshold_set
    __swig_getmethods__["areaThreshold"] = _cv.CvMSERParams_areaThreshold_get
    if _newclass:areaThreshold = _swig_property(_cv.CvMSERParams_areaThreshold_get, _cv.CvMSERParams_areaThreshold_set)
    __swig_setmethods__["minMargin"] = _cv.CvMSERParams_minMargin_set
    __swig_getmethods__["minMargin"] = _cv.CvMSERParams_minMargin_get
    if _newclass:minMargin = _swig_property(_cv.CvMSERParams_minMargin_get, _cv.CvMSERParams_minMargin_set)
    __swig_setmethods__["edgeBlurSize"] = _cv.CvMSERParams_edgeBlurSize_set
    __swig_getmethods__["edgeBlurSize"] = _cv.CvMSERParams_edgeBlurSize_get
    if _newclass:edgeBlurSize = _swig_property(_cv.CvMSERParams_edgeBlurSize_get, _cv.CvMSERParams_edgeBlurSize_set)
    def __init__(self): 
        """__init__(self) -> CvMSERParams"""
        this = _cv.new_CvMSERParams()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvMSERParams
    __del__ = lambda self : None;
CvMSERParams_swigregister = _cv.CvMSERParams_swigregister
CvMSERParams_swigregister(CvMSERParams)


def cvMSERParams(*args):
  """
    cvMSERParams(int delta = 5, int min_area = 60, int max_area = 14400, 
        float max_variation = .25, float min_diversity = .2, 
        int max_evolution = 200, double area_threshold = 1.01, 
        double min_margin = .003, 
        int edge_blur_size = 5) -> CvMSERParams
    """
  return _cv.cvMSERParams(*args)

def cvExtractMSER(*args):
  """
    cvExtractMSER(CvArr _img, CvArr _mask, CvSeq contours, CvMemStorage storage, 
        CvMSERParams params)
    """
  return _cv.cvExtractMSER(*args)
class CvStarKeypoint(_object):
    """Proxy of C++ CvStarKeypoint class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvStarKeypoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvStarKeypoint, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pt"] = _cv.CvStarKeypoint_pt_set
    __swig_getmethods__["pt"] = _cv.CvStarKeypoint_pt_get
    if _newclass:pt = _swig_property(_cv.CvStarKeypoint_pt_get, _cv.CvStarKeypoint_pt_set)
    __swig_setmethods__["size"] = _cv.CvStarKeypoint_size_set
    __swig_getmethods__["size"] = _cv.CvStarKeypoint_size_get
    if _newclass:size = _swig_property(_cv.CvStarKeypoint_size_get, _cv.CvStarKeypoint_size_set)
    __swig_setmethods__["response"] = _cv.CvStarKeypoint_response_set
    __swig_getmethods__["response"] = _cv.CvStarKeypoint_response_get
    if _newclass:response = _swig_property(_cv.CvStarKeypoint_response_get, _cv.CvStarKeypoint_response_set)
    def __init__(self): 
        """__init__(self) -> CvStarKeypoint"""
        this = _cv.new_CvStarKeypoint()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvStarKeypoint
    __del__ = lambda self : None;
CvStarKeypoint_swigregister = _cv.CvStarKeypoint_swigregister
CvStarKeypoint_swigregister(CvStarKeypoint)


def cvStarKeypoint(*args):
  """cvStarKeypoint(CvPoint pt, int size, float response) -> CvStarKeypoint"""
  return _cv.cvStarKeypoint(*args)
class CvStarDetectorParams(_object):
    """Proxy of C++ CvStarDetectorParams class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvStarDetectorParams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvStarDetectorParams, name)
    __repr__ = _swig_repr
    __swig_setmethods__["maxSize"] = _cv.CvStarDetectorParams_maxSize_set
    __swig_getmethods__["maxSize"] = _cv.CvStarDetectorParams_maxSize_get
    if _newclass:maxSize = _swig_property(_cv.CvStarDetectorParams_maxSize_get, _cv.CvStarDetectorParams_maxSize_set)
    __swig_setmethods__["responseThreshold"] = _cv.CvStarDetectorParams_responseThreshold_set
    __swig_getmethods__["responseThreshold"] = _cv.CvStarDetectorParams_responseThreshold_get
    if _newclass:responseThreshold = _swig_property(_cv.CvStarDetectorParams_responseThreshold_get, _cv.CvStarDetectorParams_responseThreshold_set)
    __swig_setmethods__["lineThresholdProjected"] = _cv.CvStarDetectorParams_lineThresholdProjected_set
    __swig_getmethods__["lineThresholdProjected"] = _cv.CvStarDetectorParams_lineThresholdProjected_get
    if _newclass:lineThresholdProjected = _swig_property(_cv.CvStarDetectorParams_lineThresholdProjected_get, _cv.CvStarDetectorParams_lineThresholdProjected_set)
    __swig_setmethods__["lineThresholdBinarized"] = _cv.CvStarDetectorParams_lineThresholdBinarized_set
    __swig_getmethods__["lineThresholdBinarized"] = _cv.CvStarDetectorParams_lineThresholdBinarized_get
    if _newclass:lineThresholdBinarized = _swig_property(_cv.CvStarDetectorParams_lineThresholdBinarized_get, _cv.CvStarDetectorParams_lineThresholdBinarized_set)
    __swig_setmethods__["suppressNonmaxSize"] = _cv.CvStarDetectorParams_suppressNonmaxSize_set
    __swig_getmethods__["suppressNonmaxSize"] = _cv.CvStarDetectorParams_suppressNonmaxSize_get
    if _newclass:suppressNonmaxSize = _swig_property(_cv.CvStarDetectorParams_suppressNonmaxSize_get, _cv.CvStarDetectorParams_suppressNonmaxSize_set)
    def __init__(self): 
        """__init__(self) -> CvStarDetectorParams"""
        this = _cv.new_CvStarDetectorParams()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvStarDetectorParams
    __del__ = lambda self : None;
CvStarDetectorParams_swigregister = _cv.CvStarDetectorParams_swigregister
CvStarDetectorParams_swigregister(CvStarDetectorParams)


def cvStarDetectorParams(maxSize = 45, responseThreshold = 30, lineThresholdProjected = 10, 
    lineThresholdBinarized = 8, suppressNonmaxSize = 5):
  """
    cvStarDetectorParams(int maxSize = 45, int responseThreshold = 30, int lineThresholdProjected = 10, 
        int lineThresholdBinarized = 8, 
        int suppressNonmaxSize = 5) -> CvStarDetectorParams
    """
  return _cv.cvStarDetectorParams(maxSize, responseThreshold, lineThresholdProjected, 
    lineThresholdBinarized, suppressNonmaxSize)

def cvGetStarKeypoints(*args):
  """cvGetStarKeypoints(CvArr img, CvMemStorage storage, CvStarDetectorParams params = cvStarDetectorParams()) -> CvSeq"""
  return _cv.cvGetStarKeypoints(*args)

def cvLoadHaarClassifierCascade(*args):
  """cvLoadHaarClassifierCascade(char directory, CvSize orig_window_size) -> CvHaarClassifierCascade"""
  return _cv.cvLoadHaarClassifierCascade(*args)

def cvSetImagesForHaarClassifierCascade(*args):
  """
    cvSetImagesForHaarClassifierCascade(CvHaarClassifierCascade cascade, CvArr sum, CvArr sqsum, 
        CvArr tilted_sum, double scale)
    """
  return _cv.cvSetImagesForHaarClassifierCascade(*args)

def cvRunHaarClassifierCascade(*args):
  """cvRunHaarClassifierCascade(CvHaarClassifierCascade cascade, CvPoint pt, int start_stage = 0) -> int"""
  return _cv.cvRunHaarClassifierCascade(*args)

def cvUndistort2(*args):
  """cvUndistort2(CvArr src, CvArr dst, CvMat camera_matrix, CvMat distortion_coeffs)"""
  return _cv.cvUndistort2(*args)

def cvInitUndistortMap(*args):
  """
    cvInitUndistortMap(CvMat camera_matrix, CvMat distortion_coeffs, CvArr mapx, 
        CvArr mapy)
    """
  return _cv.cvInitUndistortMap(*args)

def cvInitUndistortRectifyMap(*args):
  """
    cvInitUndistortRectifyMap(CvMat camera_matrix, CvMat dist_coeffs, CvMat R, CvMat new_camera_matrix, 
        CvArr mapx, CvArr mapy)
    """
  return _cv.cvInitUndistortRectifyMap(*args)

def cvUndistortPoints(*args):
  """
    cvUndistortPoints(CvMat src, CvMat dst, CvMat camera_matrix, CvMat dist_coeffs, 
        CvMat R = None, CvMat P = None)
    """
  return _cv.cvUndistortPoints(*args)

def cvRodrigues2(*args):
  """cvRodrigues2(CvMat src, CvMat dst, CvMat jacobian = None) -> int"""
  return _cv.cvRodrigues2(*args)

def cvFindHomography(*args):
  """
    cvFindHomography(CvMat src_points, CvMat dst_points, int method = 0, 
        double ransacReprojThreshold = 0, CvMat mask = None) -> int
    """
  return _cv.cvFindHomography(*args)

def cvRQDecomp3x3(*args):
  """
    cvRQDecomp3x3(CvMat matrixM, CvMat matrixR, CvMat matrixQ, CvMat matrixQx = None, 
        CvMat matrixQy = None, CvMat matrixQz = None, 
        CvPoint3D64f eulerAngles = None)
    """
  return _cv.cvRQDecomp3x3(*args)

def cvDecomposeProjectionMatrix(*args):
  """
    cvDecomposeProjectionMatrix(CvMat projMatr, CvMat calibMatr, CvMat rotMatr, CvMat posVect, 
        CvMat rotMatrX = None, CvMat rotMatrY = None, 
        CvMat rotMatrZ = None, CvPoint3D64f eulerAngles = None)
    """
  return _cv.cvDecomposeProjectionMatrix(*args)

def cvCalcMatMulDeriv(*args):
  """cvCalcMatMulDeriv(CvMat A, CvMat B, CvMat dABdA, CvMat dABdB)"""
  return _cv.cvCalcMatMulDeriv(*args)

def cvComposeRT(*args):
  """
    cvComposeRT(CvMat _rvec1, CvMat _tvec1, CvMat _rvec2, CvMat _tvec2, 
        CvMat _rvec3, CvMat _tvec3, CvMat dr3dr1 = None, 
        CvMat dr3dt1 = None, CvMat dr3dr2 = None, 
        CvMat dr3dt2 = None, CvMat dt3dr1 = None, 
        CvMat dt3dt1 = None, CvMat dt3dr2 = None, 
        CvMat dt3dt2 = None)
    """
  return _cv.cvComposeRT(*args)

def cvProjectPoints2(*args):
  """
    cvProjectPoints2(CvMat object_points, CvMat rotation_vector, CvMat translation_vector, 
        CvMat camera_matrix, CvMat distortion_coeffs, 
        CvMat image_points, CvMat dpdrot = None, 
        CvMat dpdt = None, CvMat dpdf = None, 
        CvMat dpdc = None, CvMat dpddist = None, 
        double aspect_ratio = 0)
    """
  return _cv.cvProjectPoints2(*args)

def cvFindExtrinsicCameraParams2(*args):
  """
    cvFindExtrinsicCameraParams2(CvMat object_points, CvMat image_points, CvMat camera_matrix, 
        CvMat distortion_coeffs, CvMat rotation_vector, 
        CvMat translation_vector, int use_extrinsic_guess = 0)
    """
  return _cv.cvFindExtrinsicCameraParams2(*args)

def cvInitIntrinsicParams2D(*args):
  """
    cvInitIntrinsicParams2D(CvMat object_points, CvMat image_points, CvMat npoints, 
        CvSize image_size, CvMat camera_matrix, 
        double aspect_ratio = 1.)
    """
  return _cv.cvInitIntrinsicParams2D(*args)

def cvFindChessboardCorners(*args):
  """cvFindChessboardCorners(void image, CvSize pattern_size, int flags = 1+2) -> int"""
  return _cv.cvFindChessboardCorners(*args)

def cvDrawChessboardCorners(*args):
  """
    cvDrawChessboardCorners(CvArr image, CvSize pattern_size, CvPoint2D32f corners, 
        int pattern_was_found)
    """
  return _cv.cvDrawChessboardCorners(*args)

def cvCalibrateCamera2(*args):
  """
    cvCalibrateCamera2(CvMat object_points, CvMat image_points, CvMat point_counts, 
        CvSize image_size, CvMat camera_matrix, 
        CvMat distortion_coeffs, CvMat rotation_vectors = None, 
        CvMat translation_vectors = None, 
        int flags = 0)
    """
  return _cv.cvCalibrateCamera2(*args)

def cvCalibrationMatrixValues(*args):
  """
    cvCalibrationMatrixValues(CvMat camera_matrix, CvSize image_size, double aperture_width = 0, 
        double aperture_height = 0, double fovx = None, 
        double fovy = None, double focal_length = None, 
        CvPoint2D64f principal_point = None, 
        double pixel_aspect_ratio = None)
    """
  return _cv.cvCalibrationMatrixValues(*args)

def cvStereoCalibrate(*args):
  """
    cvStereoCalibrate(CvMat object_points, CvMat image_points1, CvMat image_points2, 
        CvMat npoints, CvMat camera_matrix1, 
        CvMat dist_coeffs1, CvMat camera_matrix2, 
        CvMat dist_coeffs2, CvSize image_size, CvMat R, 
        CvMat T, CvMat E = None, CvMat F = None, 
        CvTermCriteria term_crit = cvTermCriteria( 1 +2,30,1e-6), 
        int flags = 256)
    """
  return _cv.cvStereoCalibrate(*args)

def cvStereoRectify(*args):
  """
    cvStereoRectify(CvMat camera_matrix1, CvMat camera_matrix2, CvMat dist_coeffs1, 
        CvMat dist_coeffs2, CvSize image_size, 
        CvMat R, CvMat T, CvMat R1, CvMat R2, 
        CvMat P1, CvMat P2, CvMat Q = None, int flags = 1024)
    """
  return _cv.cvStereoRectify(*args)

def cvStereoRectifyUncalibrated(*args):
  """
    cvStereoRectifyUncalibrated(CvMat points1, CvMat points2, CvMat F, CvSize img_size, 
        CvMat H1, CvMat H2, double threshold = 5) -> int
    """
  return _cv.cvStereoRectifyUncalibrated(*args)

def cvCreatePOSITObject(*args):
  """cvCreatePOSITObject(CvPoint3D32f points, int point_count) -> CvPOSITObject"""
  return _cv.cvCreatePOSITObject(*args)

def cvPOSIT(*args):
  """
    cvPOSIT(CvPOSITObject posit_object, CvPoint2D32f image_points, 
        double focal_length, CvTermCriteria criteria, 
        CvMatr32f rotation_matrix, CvVect32f translation_vector)
    """
  return _cv.cvPOSIT(*args)

def cvReleasePOSITObject(*args):
  """cvReleasePOSITObject(CvPOSITObject posit_object)"""
  return _cv.cvReleasePOSITObject(*args)

def cvRANSACUpdateNumIters(*args):
  """cvRANSACUpdateNumIters(double p, double err_prob, int model_points, int max_iters) -> int"""
  return _cv.cvRANSACUpdateNumIters(*args)

def cvConvertPointsHomogeneous(*args):
  """cvConvertPointsHomogeneous(CvMat src, CvMat dst)"""
  return _cv.cvConvertPointsHomogeneous(*args)

def cvFindFundamentalMat(*args):
  """
    cvFindFundamentalMat(CvMat points1, CvMat points2, CvMat fundamental_matrix, 
        int method = 8, double param1 = 3., double param2 = 0.99, 
        CvMat status = None) -> int
    """
  return _cv.cvFindFundamentalMat(*args)

def cvComputeCorrespondEpilines(*args):
  """
    cvComputeCorrespondEpilines(CvMat points, int which_image, CvMat fundamental_matrix, 
        CvMat correspondent_lines)
    """
  return _cv.cvComputeCorrespondEpilines(*args)

def cvTriangulatePoints(*args):
  """
    cvTriangulatePoints(CvMat projMatr1, CvMat projMatr2, CvMat projPoints1, 
        CvMat projPoints2, CvMat points4D)
    """
  return _cv.cvTriangulatePoints(*args)

def cvCorrectMatches(*args):
  """
    cvCorrectMatches(CvMat F, CvMat points1, CvMat points2, CvMat new_points1, 
        CvMat new_points2)
    """
  return _cv.cvCorrectMatches(*args)
class CvStereoBMState(_object):
    """Proxy of C++ CvStereoBMState class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvStereoBMState, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvStereoBMState, name)
    __repr__ = _swig_repr
    __swig_setmethods__["preFilterType"] = _cv.CvStereoBMState_preFilterType_set
    __swig_getmethods__["preFilterType"] = _cv.CvStereoBMState_preFilterType_get
    if _newclass:preFilterType = _swig_property(_cv.CvStereoBMState_preFilterType_get, _cv.CvStereoBMState_preFilterType_set)
    __swig_setmethods__["preFilterSize"] = _cv.CvStereoBMState_preFilterSize_set
    __swig_getmethods__["preFilterSize"] = _cv.CvStereoBMState_preFilterSize_get
    if _newclass:preFilterSize = _swig_property(_cv.CvStereoBMState_preFilterSize_get, _cv.CvStereoBMState_preFilterSize_set)
    __swig_setmethods__["preFilterCap"] = _cv.CvStereoBMState_preFilterCap_set
    __swig_getmethods__["preFilterCap"] = _cv.CvStereoBMState_preFilterCap_get
    if _newclass:preFilterCap = _swig_property(_cv.CvStereoBMState_preFilterCap_get, _cv.CvStereoBMState_preFilterCap_set)
    __swig_setmethods__["SADWindowSize"] = _cv.CvStereoBMState_SADWindowSize_set
    __swig_getmethods__["SADWindowSize"] = _cv.CvStereoBMState_SADWindowSize_get
    if _newclass:SADWindowSize = _swig_property(_cv.CvStereoBMState_SADWindowSize_get, _cv.CvStereoBMState_SADWindowSize_set)
    __swig_setmethods__["minDisparity"] = _cv.CvStereoBMState_minDisparity_set
    __swig_getmethods__["minDisparity"] = _cv.CvStereoBMState_minDisparity_get
    if _newclass:minDisparity = _swig_property(_cv.CvStereoBMState_minDisparity_get, _cv.CvStereoBMState_minDisparity_set)
    __swig_setmethods__["numberOfDisparities"] = _cv.CvStereoBMState_numberOfDisparities_set
    __swig_getmethods__["numberOfDisparities"] = _cv.CvStereoBMState_numberOfDisparities_get
    if _newclass:numberOfDisparities = _swig_property(_cv.CvStereoBMState_numberOfDisparities_get, _cv.CvStereoBMState_numberOfDisparities_set)
    __swig_setmethods__["textureThreshold"] = _cv.CvStereoBMState_textureThreshold_set
    __swig_getmethods__["textureThreshold"] = _cv.CvStereoBMState_textureThreshold_get
    if _newclass:textureThreshold = _swig_property(_cv.CvStereoBMState_textureThreshold_get, _cv.CvStereoBMState_textureThreshold_set)
    __swig_setmethods__["uniquenessRatio"] = _cv.CvStereoBMState_uniquenessRatio_set
    __swig_getmethods__["uniquenessRatio"] = _cv.CvStereoBMState_uniquenessRatio_get
    if _newclass:uniquenessRatio = _swig_property(_cv.CvStereoBMState_uniquenessRatio_get, _cv.CvStereoBMState_uniquenessRatio_set)
    __swig_setmethods__["speckleWindowSize"] = _cv.CvStereoBMState_speckleWindowSize_set
    __swig_getmethods__["speckleWindowSize"] = _cv.CvStereoBMState_speckleWindowSize_get
    if _newclass:speckleWindowSize = _swig_property(_cv.CvStereoBMState_speckleWindowSize_get, _cv.CvStereoBMState_speckleWindowSize_set)
    __swig_setmethods__["speckleRange"] = _cv.CvStereoBMState_speckleRange_set
    __swig_getmethods__["speckleRange"] = _cv.CvStereoBMState_speckleRange_get
    if _newclass:speckleRange = _swig_property(_cv.CvStereoBMState_speckleRange_get, _cv.CvStereoBMState_speckleRange_set)
    __swig_setmethods__["trySmallerWindows"] = _cv.CvStereoBMState_trySmallerWindows_set
    __swig_getmethods__["trySmallerWindows"] = _cv.CvStereoBMState_trySmallerWindows_get
    if _newclass:trySmallerWindows = _swig_property(_cv.CvStereoBMState_trySmallerWindows_get, _cv.CvStereoBMState_trySmallerWindows_set)
    __swig_setmethods__["preFilteredImg0"] = _cv.CvStereoBMState_preFilteredImg0_set
    __swig_getmethods__["preFilteredImg0"] = _cv.CvStereoBMState_preFilteredImg0_get
    if _newclass:preFilteredImg0 = _swig_property(_cv.CvStereoBMState_preFilteredImg0_get, _cv.CvStereoBMState_preFilteredImg0_set)
    __swig_setmethods__["preFilteredImg1"] = _cv.CvStereoBMState_preFilteredImg1_set
    __swig_getmethods__["preFilteredImg1"] = _cv.CvStereoBMState_preFilteredImg1_get
    if _newclass:preFilteredImg1 = _swig_property(_cv.CvStereoBMState_preFilteredImg1_get, _cv.CvStereoBMState_preFilteredImg1_set)
    __swig_setmethods__["slidingSumBuf"] = _cv.CvStereoBMState_slidingSumBuf_set
    __swig_getmethods__["slidingSumBuf"] = _cv.CvStereoBMState_slidingSumBuf_get
    if _newclass:slidingSumBuf = _swig_property(_cv.CvStereoBMState_slidingSumBuf_get, _cv.CvStereoBMState_slidingSumBuf_set)
    __swig_setmethods__["dbmin"] = _cv.CvStereoBMState_dbmin_set
    __swig_getmethods__["dbmin"] = _cv.CvStereoBMState_dbmin_get
    if _newclass:dbmin = _swig_property(_cv.CvStereoBMState_dbmin_get, _cv.CvStereoBMState_dbmin_set)
    __swig_setmethods__["dbmax"] = _cv.CvStereoBMState_dbmax_set
    __swig_getmethods__["dbmax"] = _cv.CvStereoBMState_dbmax_get
    if _newclass:dbmax = _swig_property(_cv.CvStereoBMState_dbmax_get, _cv.CvStereoBMState_dbmax_set)
    def __init__(self): 
        """__init__(self) -> CvStereoBMState"""
        this = _cv.new_CvStereoBMState()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvStereoBMState
    __del__ = lambda self : None;
CvStereoBMState_swigregister = _cv.CvStereoBMState_swigregister
CvStereoBMState_swigregister(CvStereoBMState)


def cvCreateStereoBMState(preset = 0, numberOfDisparities = 0):
  """cvCreateStereoBMState(int preset = 0, int numberOfDisparities = 0) -> CvStereoBMState"""
  return _cv.cvCreateStereoBMState(preset, numberOfDisparities)

def cvReleaseStereoBMState(*args):
  """cvReleaseStereoBMState(CvStereoBMState state)"""
  return _cv.cvReleaseStereoBMState(*args)

def cvFindStereoCorrespondenceBM(*args):
  """cvFindStereoCorrespondenceBM(CvArr left, CvArr right, CvArr disparity, CvStereoBMState state)"""
  return _cv.cvFindStereoCorrespondenceBM(*args)
class CvStereoGCState(_object):
    """Proxy of C++ CvStereoGCState class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvStereoGCState, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvStereoGCState, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Ithreshold"] = _cv.CvStereoGCState_Ithreshold_set
    __swig_getmethods__["Ithreshold"] = _cv.CvStereoGCState_Ithreshold_get
    if _newclass:Ithreshold = _swig_property(_cv.CvStereoGCState_Ithreshold_get, _cv.CvStereoGCState_Ithreshold_set)
    __swig_setmethods__["interactionRadius"] = _cv.CvStereoGCState_interactionRadius_set
    __swig_getmethods__["interactionRadius"] = _cv.CvStereoGCState_interactionRadius_get
    if _newclass:interactionRadius = _swig_property(_cv.CvStereoGCState_interactionRadius_get, _cv.CvStereoGCState_interactionRadius_set)
    __swig_setmethods__["K"] = _cv.CvStereoGCState_K_set
    __swig_getmethods__["K"] = _cv.CvStereoGCState_K_get
    if _newclass:K = _swig_property(_cv.CvStereoGCState_K_get, _cv.CvStereoGCState_K_set)
    __swig_setmethods__["_lambda"] = _cv.CvStereoGCState__lambda_set
    __swig_getmethods__["_lambda"] = _cv.CvStereoGCState__lambda_get
    if _newclass:_lambda = _swig_property(_cv.CvStereoGCState__lambda_get, _cv.CvStereoGCState__lambda_set)
    __swig_setmethods__["lambda1"] = _cv.CvStereoGCState_lambda1_set
    __swig_getmethods__["lambda1"] = _cv.CvStereoGCState_lambda1_get
    if _newclass:lambda1 = _swig_property(_cv.CvStereoGCState_lambda1_get, _cv.CvStereoGCState_lambda1_set)
    __swig_setmethods__["lambda2"] = _cv.CvStereoGCState_lambda2_set
    __swig_getmethods__["lambda2"] = _cv.CvStereoGCState_lambda2_get
    if _newclass:lambda2 = _swig_property(_cv.CvStereoGCState_lambda2_get, _cv.CvStereoGCState_lambda2_set)
    __swig_setmethods__["occlusionCost"] = _cv.CvStereoGCState_occlusionCost_set
    __swig_getmethods__["occlusionCost"] = _cv.CvStereoGCState_occlusionCost_get
    if _newclass:occlusionCost = _swig_property(_cv.CvStereoGCState_occlusionCost_get, _cv.CvStereoGCState_occlusionCost_set)
    __swig_setmethods__["minDisparity"] = _cv.CvStereoGCState_minDisparity_set
    __swig_getmethods__["minDisparity"] = _cv.CvStereoGCState_minDisparity_get
    if _newclass:minDisparity = _swig_property(_cv.CvStereoGCState_minDisparity_get, _cv.CvStereoGCState_minDisparity_set)
    __swig_setmethods__["numberOfDisparities"] = _cv.CvStereoGCState_numberOfDisparities_set
    __swig_getmethods__["numberOfDisparities"] = _cv.CvStereoGCState_numberOfDisparities_get
    if _newclass:numberOfDisparities = _swig_property(_cv.CvStereoGCState_numberOfDisparities_get, _cv.CvStereoGCState_numberOfDisparities_set)
    __swig_setmethods__["maxIters"] = _cv.CvStereoGCState_maxIters_set
    __swig_getmethods__["maxIters"] = _cv.CvStereoGCState_maxIters_get
    if _newclass:maxIters = _swig_property(_cv.CvStereoGCState_maxIters_get, _cv.CvStereoGCState_maxIters_set)
    __swig_setmethods__["left"] = _cv.CvStereoGCState_left_set
    __swig_getmethods__["left"] = _cv.CvStereoGCState_left_get
    if _newclass:left = _swig_property(_cv.CvStereoGCState_left_get, _cv.CvStereoGCState_left_set)
    __swig_setmethods__["right"] = _cv.CvStereoGCState_right_set
    __swig_getmethods__["right"] = _cv.CvStereoGCState_right_get
    if _newclass:right = _swig_property(_cv.CvStereoGCState_right_get, _cv.CvStereoGCState_right_set)
    __swig_setmethods__["dispLeft"] = _cv.CvStereoGCState_dispLeft_set
    __swig_getmethods__["dispLeft"] = _cv.CvStereoGCState_dispLeft_get
    if _newclass:dispLeft = _swig_property(_cv.CvStereoGCState_dispLeft_get, _cv.CvStereoGCState_dispLeft_set)
    __swig_setmethods__["dispRight"] = _cv.CvStereoGCState_dispRight_set
    __swig_getmethods__["dispRight"] = _cv.CvStereoGCState_dispRight_get
    if _newclass:dispRight = _swig_property(_cv.CvStereoGCState_dispRight_get, _cv.CvStereoGCState_dispRight_set)
    __swig_setmethods__["ptrLeft"] = _cv.CvStereoGCState_ptrLeft_set
    __swig_getmethods__["ptrLeft"] = _cv.CvStereoGCState_ptrLeft_get
    if _newclass:ptrLeft = _swig_property(_cv.CvStereoGCState_ptrLeft_get, _cv.CvStereoGCState_ptrLeft_set)
    __swig_setmethods__["ptrRight"] = _cv.CvStereoGCState_ptrRight_set
    __swig_getmethods__["ptrRight"] = _cv.CvStereoGCState_ptrRight_get
    if _newclass:ptrRight = _swig_property(_cv.CvStereoGCState_ptrRight_get, _cv.CvStereoGCState_ptrRight_set)
    __swig_setmethods__["vtxBuf"] = _cv.CvStereoGCState_vtxBuf_set
    __swig_getmethods__["vtxBuf"] = _cv.CvStereoGCState_vtxBuf_get
    if _newclass:vtxBuf = _swig_property(_cv.CvStereoGCState_vtxBuf_get, _cv.CvStereoGCState_vtxBuf_set)
    __swig_setmethods__["edgeBuf"] = _cv.CvStereoGCState_edgeBuf_set
    __swig_getmethods__["edgeBuf"] = _cv.CvStereoGCState_edgeBuf_get
    if _newclass:edgeBuf = _swig_property(_cv.CvStereoGCState_edgeBuf_get, _cv.CvStereoGCState_edgeBuf_set)
    def __init__(self): 
        """__init__(self) -> CvStereoGCState"""
        this = _cv.new_CvStereoGCState()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvStereoGCState
    __del__ = lambda self : None;
CvStereoGCState_swigregister = _cv.CvStereoGCState_swigregister
CvStereoGCState_swigregister(CvStereoGCState)


def cvCreateStereoGCState(*args):
  """cvCreateStereoGCState(int numberOfDisparities, int maxIters) -> CvStereoGCState"""
  return _cv.cvCreateStereoGCState(*args)

def cvReleaseStereoGCState(*args):
  """cvReleaseStereoGCState(CvStereoGCState state)"""
  return _cv.cvReleaseStereoGCState(*args)

def cvFindStereoCorrespondenceGC(*args):
  """
    cvFindStereoCorrespondenceGC(CvArr left, CvArr right, CvArr disparityLeft, CvArr disparityRight, 
        CvStereoGCState state, int useDisparityGuess = 0)
    """
  return _cv.cvFindStereoCorrespondenceGC(*args)

def cvReprojectImageTo3D(*args):
  """cvReprojectImageTo3D(CvArr disparityImage, CvArr _3dImage, CvMat Q, int handleMissingValues = 0)"""
  return _cv.cvReprojectImageTo3D(*args)
class CvLSH(_object):
    """Proxy of C++ CvLSH class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvLSH, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvLSH, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _cv.delete_CvLSH
    __del__ = lambda self : None;
CvLSH_swigregister = _cv.CvLSH_swigregister
CvLSH_swigregister(CvLSH)

class CvTuple_CvPoint_2(_object):
    """Proxy of C++ CvTuple<(CvPoint,2)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvTuple_CvPoint_2, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvTuple_CvPoint_2, name)
    __repr__ = _swig_repr
    __swig_setmethods__["val"] = _cv.CvTuple_CvPoint_2_val_set
    __swig_getmethods__["val"] = _cv.CvTuple_CvPoint_2_val_get
    if _newclass:val = _swig_property(_cv.CvTuple_CvPoint_2_val_get, _cv.CvTuple_CvPoint_2_val_set)
    def __setitem__(self, *args):
        """__setitem__(self, int i, CvPoint obj)"""
        return _cv.CvTuple_CvPoint_2___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> CvPoint"""
        return _cv.CvTuple_CvPoint_2___getitem__(self, *args)

    def __init__(self): 
        """__init__(self) -> CvTuple_CvPoint_2"""
        this = _cv.new_CvTuple_CvPoint_2()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvTuple_CvPoint_2
    __del__ = lambda self : None;
CvTuple_CvPoint_2_swigregister = _cv.CvTuple_CvPoint_2_swigregister
CvTuple_CvPoint_2_swigregister(CvTuple_CvPoint_2)

class CvTuple_float_2(_object):
    """Proxy of C++ CvTuple<(float,2)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvTuple_float_2, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvTuple_float_2, name)
    __repr__ = _swig_repr
    __swig_setmethods__["val"] = _cv.CvTuple_float_2_val_set
    __swig_getmethods__["val"] = _cv.CvTuple_float_2_val_get
    if _newclass:val = _swig_property(_cv.CvTuple_float_2_val_get, _cv.CvTuple_float_2_val_set)
    def __setitem__(self, *args):
        """__setitem__(self, int i, float obj)"""
        return _cv.CvTuple_float_2___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> float"""
        return _cv.CvTuple_float_2___getitem__(self, *args)

    def __init__(self): 
        """__init__(self) -> CvTuple_float_2"""
        this = _cv.new_CvTuple_float_2()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvTuple_float_2
    __del__ = lambda self : None;
CvTuple_float_2_swigregister = _cv.CvTuple_float_2_swigregister
CvTuple_float_2_swigregister(CvTuple_float_2)

class CvTuple_float_3(_object):
    """Proxy of C++ CvTuple<(float,3)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvTuple_float_3, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CvTuple_float_3, name)
    __repr__ = _swig_repr
    __swig_setmethods__["val"] = _cv.CvTuple_float_3_val_set
    __swig_getmethods__["val"] = _cv.CvTuple_float_3_val_get
    if _newclass:val = _swig_property(_cv.CvTuple_float_3_val_get, _cv.CvTuple_float_3_val_set)
    def __setitem__(self, *args):
        """__setitem__(self, int i, float obj)"""
        return _cv.CvTuple_float_3___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, int i) -> float"""
        return _cv.CvTuple_float_3___getitem__(self, *args)

    def __init__(self): 
        """__init__(self) -> CvTuple_float_3"""
        this = _cv.new_CvTuple_float_3()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvTuple_float_3
    __del__ = lambda self : None;
CvTuple_float_3_swigregister = _cv.CvTuple_float_3_swigregister
CvTuple_float_3_swigregister(CvTuple_float_3)

class CvSeq_CvPoint(CvSeq):
    """Proxy of C++ CvTypedSeq<(CvPoint)> class"""
    __swig_setmethods__ = {}
    for _s in [CvSeq]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSeq_CvPoint, name, value)
    __swig_getmethods__ = {}
    for _s in [CvSeq]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CvSeq_CvPoint, name)
    __repr__ = _swig_repr
    def cast(*args):
        """cast(CvSeq seq) -> CvSeq_CvPoint"""
        return _cv.CvSeq_CvPoint_cast(*args)

    if _newclass:cast = staticmethod(cast)
    __swig_getmethods__["cast"] = lambda x: cast
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> CvPoint"""
        return _cv.CvSeq_CvPoint___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, CvPoint obj)"""
        return _cv.CvSeq_CvPoint___setitem__(self, *args)

    def append(self, *args):
        """append(self, CvPoint obj)"""
        return _cv.CvSeq_CvPoint_append(self, *args)

    def pop(self):
        """pop(self) -> CvPoint"""
        return _cv.CvSeq_CvPoint_pop(self)

    def __init__(self): 
        """__init__(self) -> CvSeq_CvPoint"""
        this = _cv.new_CvSeq_CvPoint()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSeq_CvPoint
    __del__ = lambda self : None;
CvSeq_CvPoint_swigregister = _cv.CvSeq_CvPoint_swigregister
CvSeq_CvPoint_swigregister(CvSeq_CvPoint)

def CvSeq_CvPoint_cast(*args):
  """CvSeq_CvPoint_cast(CvSeq seq) -> CvSeq_CvPoint"""
  return _cv.CvSeq_CvPoint_cast(*args)

class CvSeq_CvPoint2D32f(CvSeq):
    """Proxy of C++ CvTypedSeq<(CvPoint2D32f)> class"""
    __swig_setmethods__ = {}
    for _s in [CvSeq]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSeq_CvPoint2D32f, name, value)
    __swig_getmethods__ = {}
    for _s in [CvSeq]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CvSeq_CvPoint2D32f, name)
    __repr__ = _swig_repr
    def cast(*args):
        """cast(CvSeq seq) -> CvSeq_CvPoint2D32f"""
        return _cv.CvSeq_CvPoint2D32f_cast(*args)

    if _newclass:cast = staticmethod(cast)
    __swig_getmethods__["cast"] = lambda x: cast
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> CvPoint2D32f"""
        return _cv.CvSeq_CvPoint2D32f___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, CvPoint2D32f obj)"""
        return _cv.CvSeq_CvPoint2D32f___setitem__(self, *args)

    def append(self, *args):
        """append(self, CvPoint2D32f obj)"""
        return _cv.CvSeq_CvPoint2D32f_append(self, *args)

    def pop(self):
        """pop(self) -> CvPoint2D32f"""
        return _cv.CvSeq_CvPoint2D32f_pop(self)

    def __init__(self): 
        """__init__(self) -> CvSeq_CvPoint2D32f"""
        this = _cv.new_CvSeq_CvPoint2D32f()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSeq_CvPoint2D32f
    __del__ = lambda self : None;
CvSeq_CvPoint2D32f_swigregister = _cv.CvSeq_CvPoint2D32f_swigregister
CvSeq_CvPoint2D32f_swigregister(CvSeq_CvPoint2D32f)

def CvSeq_CvPoint2D32f_cast(*args):
  """CvSeq_CvPoint2D32f_cast(CvSeq seq) -> CvSeq_CvPoint2D32f"""
  return _cv.CvSeq_CvPoint2D32f_cast(*args)

class CvSeq_CvRect(CvSeq):
    """Proxy of C++ CvTypedSeq<(CvRect)> class"""
    __swig_setmethods__ = {}
    for _s in [CvSeq]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSeq_CvRect, name, value)
    __swig_getmethods__ = {}
    for _s in [CvSeq]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CvSeq_CvRect, name)
    __repr__ = _swig_repr
    def cast(*args):
        """cast(CvSeq seq) -> CvSeq_CvRect"""
        return _cv.CvSeq_CvRect_cast(*args)

    if _newclass:cast = staticmethod(cast)
    __swig_getmethods__["cast"] = lambda x: cast
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> CvRect"""
        return _cv.CvSeq_CvRect___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, CvRect obj)"""
        return _cv.CvSeq_CvRect___setitem__(self, *args)

    def append(self, *args):
        """append(self, CvRect obj)"""
        return _cv.CvSeq_CvRect_append(self, *args)

    def pop(self):
        """pop(self) -> CvRect"""
        return _cv.CvSeq_CvRect_pop(self)

    def __init__(self): 
        """__init__(self) -> CvSeq_CvRect"""
        this = _cv.new_CvSeq_CvRect()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSeq_CvRect
    __del__ = lambda self : None;
CvSeq_CvRect_swigregister = _cv.CvSeq_CvRect_swigregister
CvSeq_CvRect_swigregister(CvSeq_CvRect)

def CvSeq_CvRect_cast(*args):
  """CvSeq_CvRect_cast(CvSeq seq) -> CvSeq_CvRect"""
  return _cv.CvSeq_CvRect_cast(*args)

class CvSeq_CvSeq(CvSeq):
    """Proxy of C++ CvTypedSeq<(p.CvSeq)> class"""
    __swig_setmethods__ = {}
    for _s in [CvSeq]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSeq_CvSeq, name, value)
    __swig_getmethods__ = {}
    for _s in [CvSeq]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CvSeq_CvSeq, name)
    __repr__ = _swig_repr
    def cast(*args):
        """cast(CvSeq seq) -> CvSeq_CvSeq"""
        return _cv.CvSeq_CvSeq_cast(*args)

    if _newclass:cast = staticmethod(cast)
    __swig_getmethods__["cast"] = lambda x: cast
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> CvSeq"""
        return _cv.CvSeq_CvSeq___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, CvSeq obj)"""
        return _cv.CvSeq_CvSeq___setitem__(self, *args)

    def append(self, *args):
        """append(self, CvSeq obj)"""
        return _cv.CvSeq_CvSeq_append(self, *args)

    def pop(self):
        """pop(self) -> CvSeq"""
        return _cv.CvSeq_CvSeq_pop(self)

    def __init__(self): 
        """__init__(self) -> CvSeq_CvSeq"""
        this = _cv.new_CvSeq_CvSeq()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSeq_CvSeq
    __del__ = lambda self : None;
CvSeq_CvSeq_swigregister = _cv.CvSeq_CvSeq_swigregister
CvSeq_CvSeq_swigregister(CvSeq_CvSeq)

def CvSeq_CvSeq_cast(*args):
  """CvSeq_CvSeq_cast(CvSeq seq) -> CvSeq_CvSeq"""
  return _cv.CvSeq_CvSeq_cast(*args)

class CvSeq_CvQuadEdge2D(CvSeq):
    """Proxy of C++ CvTypedSeq<(CvQuadEdge2D)> class"""
    __swig_setmethods__ = {}
    for _s in [CvSeq]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSeq_CvQuadEdge2D, name, value)
    __swig_getmethods__ = {}
    for _s in [CvSeq]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CvSeq_CvQuadEdge2D, name)
    __repr__ = _swig_repr
    def cast(*args):
        """cast(CvSeq seq) -> CvSeq_CvQuadEdge2D"""
        return _cv.CvSeq_CvQuadEdge2D_cast(*args)

    if _newclass:cast = staticmethod(cast)
    __swig_getmethods__["cast"] = lambda x: cast
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> CvQuadEdge2D"""
        return _cv.CvSeq_CvQuadEdge2D___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, CvQuadEdge2D obj)"""
        return _cv.CvSeq_CvQuadEdge2D___setitem__(self, *args)

    def append(self, *args):
        """append(self, CvQuadEdge2D obj)"""
        return _cv.CvSeq_CvQuadEdge2D_append(self, *args)

    def pop(self):
        """pop(self) -> CvQuadEdge2D"""
        return _cv.CvSeq_CvQuadEdge2D_pop(self)

    def __init__(self): 
        """__init__(self) -> CvSeq_CvQuadEdge2D"""
        this = _cv.new_CvSeq_CvQuadEdge2D()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSeq_CvQuadEdge2D
    __del__ = lambda self : None;
CvSeq_CvQuadEdge2D_swigregister = _cv.CvSeq_CvQuadEdge2D_swigregister
CvSeq_CvQuadEdge2D_swigregister(CvSeq_CvQuadEdge2D)

def CvSeq_CvQuadEdge2D_cast(*args):
  """CvSeq_CvQuadEdge2D_cast(CvSeq seq) -> CvSeq_CvQuadEdge2D"""
  return _cv.CvSeq_CvQuadEdge2D_cast(*args)

class CvSeq_CvConnectedComp(CvSeq):
    """Proxy of C++ CvTypedSeq<(CvConnectedComp)> class"""
    __swig_setmethods__ = {}
    for _s in [CvSeq]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSeq_CvConnectedComp, name, value)
    __swig_getmethods__ = {}
    for _s in [CvSeq]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CvSeq_CvConnectedComp, name)
    __repr__ = _swig_repr
    def cast(*args):
        """cast(CvSeq seq) -> CvSeq_CvConnectedComp"""
        return _cv.CvSeq_CvConnectedComp_cast(*args)

    if _newclass:cast = staticmethod(cast)
    __swig_getmethods__["cast"] = lambda x: cast
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> CvConnectedComp"""
        return _cv.CvSeq_CvConnectedComp___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, CvConnectedComp obj)"""
        return _cv.CvSeq_CvConnectedComp___setitem__(self, *args)

    def append(self, *args):
        """append(self, CvConnectedComp obj)"""
        return _cv.CvSeq_CvConnectedComp_append(self, *args)

    def pop(self):
        """pop(self) -> CvConnectedComp"""
        return _cv.CvSeq_CvConnectedComp_pop(self)

    def __init__(self): 
        """__init__(self) -> CvSeq_CvConnectedComp"""
        this = _cv.new_CvSeq_CvConnectedComp()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSeq_CvConnectedComp
    __del__ = lambda self : None;
CvSeq_CvConnectedComp_swigregister = _cv.CvSeq_CvConnectedComp_swigregister
CvSeq_CvConnectedComp_swigregister(CvSeq_CvConnectedComp)

def CvSeq_CvConnectedComp_cast(*args):
  """CvSeq_CvConnectedComp_cast(CvSeq seq) -> CvSeq_CvConnectedComp"""
  return _cv.CvSeq_CvConnectedComp_cast(*args)

class CvSeq_CvPoint_2(CvSeq):
    """Proxy of C++ CvTypedSeq<(CvTuple<(CvPoint,2)>)> class"""
    __swig_setmethods__ = {}
    for _s in [CvSeq]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSeq_CvPoint_2, name, value)
    __swig_getmethods__ = {}
    for _s in [CvSeq]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CvSeq_CvPoint_2, name)
    __repr__ = _swig_repr
    def cast(*args):
        """cast(CvSeq seq) -> CvSeq_CvPoint_2"""
        return _cv.CvSeq_CvPoint_2_cast(*args)

    if _newclass:cast = staticmethod(cast)
    __swig_getmethods__["cast"] = lambda x: cast
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> CvTuple_CvPoint_2"""
        return _cv.CvSeq_CvPoint_2___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, CvTuple_CvPoint_2 obj)"""
        return _cv.CvSeq_CvPoint_2___setitem__(self, *args)

    def append(self, *args):
        """append(self, CvTuple_CvPoint_2 obj)"""
        return _cv.CvSeq_CvPoint_2_append(self, *args)

    def pop(self):
        """pop(self) -> CvTuple_CvPoint_2"""
        return _cv.CvSeq_CvPoint_2_pop(self)

    def __init__(self): 
        """__init__(self) -> CvSeq_CvPoint_2"""
        this = _cv.new_CvSeq_CvPoint_2()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSeq_CvPoint_2
    __del__ = lambda self : None;
CvSeq_CvPoint_2_swigregister = _cv.CvSeq_CvPoint_2_swigregister
CvSeq_CvPoint_2_swigregister(CvSeq_CvPoint_2)

def CvSeq_CvPoint_2_cast(*args):
  """CvSeq_CvPoint_2_cast(CvSeq seq) -> CvSeq_CvPoint_2"""
  return _cv.CvSeq_CvPoint_2_cast(*args)

class CvSeq_float_2(CvSeq):
    """Proxy of C++ CvTypedSeq<(CvTuple<(float,2)>)> class"""
    __swig_setmethods__ = {}
    for _s in [CvSeq]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSeq_float_2, name, value)
    __swig_getmethods__ = {}
    for _s in [CvSeq]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CvSeq_float_2, name)
    __repr__ = _swig_repr
    def cast(*args):
        """cast(CvSeq seq) -> CvSeq_float_2"""
        return _cv.CvSeq_float_2_cast(*args)

    if _newclass:cast = staticmethod(cast)
    __swig_getmethods__["cast"] = lambda x: cast
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> CvTuple_float_2"""
        return _cv.CvSeq_float_2___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, CvTuple_float_2 obj)"""
        return _cv.CvSeq_float_2___setitem__(self, *args)

    def append(self, *args):
        """append(self, CvTuple_float_2 obj)"""
        return _cv.CvSeq_float_2_append(self, *args)

    def pop(self):
        """pop(self) -> CvTuple_float_2"""
        return _cv.CvSeq_float_2_pop(self)

    def __init__(self): 
        """__init__(self) -> CvSeq_float_2"""
        this = _cv.new_CvSeq_float_2()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSeq_float_2
    __del__ = lambda self : None;
CvSeq_float_2_swigregister = _cv.CvSeq_float_2_swigregister
CvSeq_float_2_swigregister(CvSeq_float_2)

def CvSeq_float_2_cast(*args):
  """CvSeq_float_2_cast(CvSeq seq) -> CvSeq_float_2"""
  return _cv.CvSeq_float_2_cast(*args)

class CvSeq_float_3(CvSeq):
    """Proxy of C++ CvTypedSeq<(CvTuple<(float,3)>)> class"""
    __swig_setmethods__ = {}
    for _s in [CvSeq]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CvSeq_float_3, name, value)
    __swig_getmethods__ = {}
    for _s in [CvSeq]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CvSeq_float_3, name)
    __repr__ = _swig_repr
    def cast(*args):
        """cast(CvSeq seq) -> CvSeq_float_3"""
        return _cv.CvSeq_float_3_cast(*args)

    if _newclass:cast = staticmethod(cast)
    __swig_getmethods__["cast"] = lambda x: cast
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> CvTuple_float_3"""
        return _cv.CvSeq_float_3___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(self, int i, CvTuple_float_3 obj)"""
        return _cv.CvSeq_float_3___setitem__(self, *args)

    def append(self, *args):
        """append(self, CvTuple_float_3 obj)"""
        return _cv.CvSeq_float_3_append(self, *args)

    def pop(self):
        """pop(self) -> CvTuple_float_3"""
        return _cv.CvSeq_float_3_pop(self)

    def __init__(self): 
        """__init__(self) -> CvSeq_float_3"""
        this = _cv.new_CvSeq_float_3()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _cv.delete_CvSeq_float_3
    __del__ = lambda self : None;
CvSeq_float_3_swigregister = _cv.CvSeq_float_3_swigregister
CvSeq_float_3_swigregister(CvSeq_float_3)

def CvSeq_float_3_cast(*args):
  """CvSeq_float_3_cast(CvSeq seq) -> CvSeq_float_3"""
  return _cv.CvSeq_float_3_cast(*args)


def SendErrorToPython(*args):
  """
    SendErrorToPython(int status, char func_name, char err_msg, char file_name, 
        int line, void arg5) -> int
    """
  return _cv.SendErrorToPython(*args)

def function_ptr_generator():
  """function_ptr_generator() -> CvErrorCallback"""
  return _cv.function_ptr_generator()

def void_ptr_generator():
  """void_ptr_generator() -> void"""
  return _cv.void_ptr_generator()

def void_ptrptr_generator():
  """void_ptrptr_generator() -> void"""
  return _cv.void_ptrptr_generator()
IPL_ALIGN_DWORD=IPL_ALIGN_4BYTES
IPL_ALIGN_QWORD=IPL_ALIGN_8BYTES
CV_MAKE_TYPE=CV_MAKETYPE
CV_IS_CONT_MAT=CV_IS_MAT_CONT
CV_HIST_TREE=CV_HIST_SPARSE
CV_TERMCRIT_NUMBER=CV_TERMCRIT_ITER
CV_SEQ_ELTYPE_PTR=CV_USRTYPE1
CV_GRAPH=CV_SEQ_KIND_GRAPH
CV_SEQ_CONTOUR=CV_SEQ_POLYGON
CV_STORAGE_WRITE_TEXT=CV_STORAGE_WRITE
CV_STORAGE_WRITE_BINARY=CV_STORAGE_WRITE
CV_NODE_INTEGER=CV_NODE_INT
CV_NODE_FLOAT=CV_NODE_REAL
CV_NODE_STRING=CV_NODE_STR
cvGetSubArr=cvGetSubRect
cvZero=cvSetZero
cvCvtScale=cvConvertScale
cvScale=cvConvertScale
cvCvtScaleAbs=cvConvertScaleAbs
cvCheckArray=cvCheckArr
cvMatMulAddEx=cvGEMM
cvMatMulAddS=cvTransform
cvT=cvTranspose
cvMirror=cvFlip
cvInv=cvInvert
cvMahalonobis=cvMahalanobis
CV_DXT_INVERSE_SCALE=CV_DXT_INV_SCALE
cvFFT=cvDFT
cvGraphFindEdge=cvFindGraphEdge
cvGraphFindEdgeByPtr=cvFindGraphEdgeByPtr
cvDrawRect=cvRectangle
cvDrawLine=cvLine
cvDrawCircle=cvCircle
cvDrawEllipse=cvEllipse
cvDrawPolyLine=cvPolyLine
CV_FONT_VECTOR0=CV_FONT_HERSHEY_SIMPLEX
CV_RGB2RGBA=CV_BGR2BGRA
CV_RGBA2RGB=CV_BGRA2BGR
CV_RGB2BGRA=CV_BGR2RGBA
CV_BGRA2RGB=CV_RGBA2BGR
CV_RGB2BGR=CV_BGR2RGB
CV_RGBA2BGRA=CV_BGRA2RGBA
CV_GRAY2RGB=CV_GRAY2BGR
CV_GRAY2RGBA=CV_GRAY2BGRA
CV_BayerBG2RGB=CV_BayerRG2BGR
CV_BayerGB2RGB=CV_BayerGR2BGR
CV_BayerRG2RGB=CV_BayerBG2BGR
CV_BayerGR2RGB=CV_BayerGB2BGR
CV_FM_LMEDS_ONLY=CV_LMEDS
CV_FM_RANSAC_ONLY=CV_RANSAC
CV_FM_LMEDS=CV_LMEDS
CV_FM_RANSAC=CV_RANSAC

cvCalcBackProject = cvCalcArrBackProject;

cvCalcBackProjectPatch = cvCalcArrBackProjectPatch;

cvCalcImageHist = cvCalcArrHist;

cvCalcHist = cvCalcArrHist;

__doc__ = """
OpenCV is the Intel Open CV library, an open source effort to provide
computer vision algorithms for standard PC hardware.

This wrapper was semi-automatically created from the C/C++ headers and therefore
contains no Python documentation. Because all identifiers are identical to their
C/C++ counterparts, you can consult the standard manuals that come with OpenCV.
"""

# this tells OpenCV not to call exit() on errors but throw a python exception instead
cvRedirectError(function_ptr_generator(), void_ptr_generator(), void_ptrptr_generator())