# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.1
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

"""LibCCV bindings for python"""

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _libccv
else:
    import _libccv

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class doubleArray(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, nelements):
        _libccv.doubleArray_swiginit(self, _libccv.new_doubleArray(nelements))
    __swig_destroy__ = _libccv.delete_doubleArray

    def __getitem__(self, index):
        return _libccv.doubleArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _libccv.doubleArray___setitem__(self, index, value)

    def cast(self):
        return _libccv.doubleArray_cast(self)

    @staticmethod
    def frompointer(t):
        return _libccv.doubleArray_frompointer(t)

# Register doubleArray in _libccv:
_libccv.doubleArray_swigregister(doubleArray)

def doubleArray_frompointer(t):
    return _libccv.doubleArray_frompointer(t)

CCV_PI = _libccv.CCV_PI
CCV_8U = _libccv.CCV_8U
CCV_32S = _libccv.CCV_32S
CCV_32F = _libccv.CCV_32F
CCV_64S = _libccv.CCV_64S
CCV_64F = _libccv.CCV_64F
CCV_C1 = _libccv.CCV_C1
CCV_C2 = _libccv.CCV_C2
CCV_C3 = _libccv.CCV_C3
CCV_C4 = _libccv.CCV_C4
CCV_MAX_CHANNEL = _libccv.CCV_MAX_CHANNEL
CCV_MATRIX_DENSE = _libccv.CCV_MATRIX_DENSE
CCV_MATRIX_SPARSE = _libccv.CCV_MATRIX_SPARSE
CCV_MATRIX_CSR = _libccv.CCV_MATRIX_CSR
CCV_MATRIX_CSC = _libccv.CCV_MATRIX_CSC
CCV_GARBAGE = _libccv.CCV_GARBAGE
CCV_REUSABLE = _libccv.CCV_REUSABLE
CCV_UNMANAGED = _libccv.CCV_UNMANAGED
CCV_NO_DATA_ALLOC = _libccv.CCV_NO_DATA_ALLOC
class ccv_matrix_cell_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    u8 = property(_libccv.ccv_matrix_cell_t_u8_get, _libccv.ccv_matrix_cell_t_u8_set)
    i32 = property(_libccv.ccv_matrix_cell_t_i32_get, _libccv.ccv_matrix_cell_t_i32_set)
    f32 = property(_libccv.ccv_matrix_cell_t_f32_get, _libccv.ccv_matrix_cell_t_f32_set)
    i64 = property(_libccv.ccv_matrix_cell_t_i64_get, _libccv.ccv_matrix_cell_t_i64_set)
    f64 = property(_libccv.ccv_matrix_cell_t_f64_get, _libccv.ccv_matrix_cell_t_f64_set)

    def __init__(self):
        _libccv.ccv_matrix_cell_t_swiginit(self, _libccv.new_ccv_matrix_cell_t())
    __swig_destroy__ = _libccv.delete_ccv_matrix_cell_t

# Register ccv_matrix_cell_t in _libccv:
_libccv.ccv_matrix_cell_t_swigregister(ccv_matrix_cell_t)
cvar = _libccv.cvar
_ccv_get_data_type_size = cvar._ccv_get_data_type_size

class ccv_dense_matrix_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type = property(_libccv.ccv_dense_matrix_t_type_get, _libccv.ccv_dense_matrix_t_type_set)
    sig = property(_libccv.ccv_dense_matrix_t_sig_get, _libccv.ccv_dense_matrix_t_sig_set)
    refcount = property(_libccv.ccv_dense_matrix_t_refcount_get, _libccv.ccv_dense_matrix_t_refcount_set)
    rows = property(_libccv.ccv_dense_matrix_t_rows_get, _libccv.ccv_dense_matrix_t_rows_set)
    cols = property(_libccv.ccv_dense_matrix_t_cols_get, _libccv.ccv_dense_matrix_t_cols_set)
    step = property(_libccv.ccv_dense_matrix_t_step_get, _libccv.ccv_dense_matrix_t_step_set)
    tag = property(_libccv.ccv_dense_matrix_t_tag_get)
    data = property(_libccv.ccv_dense_matrix_t_data_get, _libccv.ccv_dense_matrix_t_data_set)

    def __init__(self):
        _libccv.ccv_dense_matrix_t_swiginit(self, _libccv.new_ccv_dense_matrix_t())
    __swig_destroy__ = _libccv.delete_ccv_dense_matrix_t

# Register ccv_dense_matrix_t in _libccv:
_libccv.ccv_dense_matrix_t_swigregister(ccv_dense_matrix_t)

class ccv_dense_matrix_t_tag(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    u8 = property(_libccv.ccv_dense_matrix_t_tag_u8_get, _libccv.ccv_dense_matrix_t_tag_u8_set)
    i32 = property(_libccv.ccv_dense_matrix_t_tag_i32_get, _libccv.ccv_dense_matrix_t_tag_i32_set)
    f32 = property(_libccv.ccv_dense_matrix_t_tag_f32_get, _libccv.ccv_dense_matrix_t_tag_f32_set)
    i64 = property(_libccv.ccv_dense_matrix_t_tag_i64_get, _libccv.ccv_dense_matrix_t_tag_i64_set)
    f64 = property(_libccv.ccv_dense_matrix_t_tag_f64_get, _libccv.ccv_dense_matrix_t_tag_f64_set)
    p = property(_libccv.ccv_dense_matrix_t_tag_p_get, _libccv.ccv_dense_matrix_t_tag_p_set)

    def __init__(self):
        _libccv.ccv_dense_matrix_t_tag_swiginit(self, _libccv.new_ccv_dense_matrix_t_tag())
    __swig_destroy__ = _libccv.delete_ccv_dense_matrix_t_tag

# Register ccv_dense_matrix_t_tag in _libccv:
_libccv.ccv_dense_matrix_t_tag_swigregister(ccv_dense_matrix_t_tag)

CCV_SPARSE_VECTOR = _libccv.CCV_SPARSE_VECTOR
CCV_DENSE_VECTOR = _libccv.CCV_DENSE_VECTOR
class ccv_dense_vector_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    step = property(_libccv.ccv_dense_vector_t_step_get, _libccv.ccv_dense_vector_t_step_set)
    length = property(_libccv.ccv_dense_vector_t_length_get, _libccv.ccv_dense_vector_t_length_set)
    index = property(_libccv.ccv_dense_vector_t_index_get, _libccv.ccv_dense_vector_t_index_set)
    prime = property(_libccv.ccv_dense_vector_t_prime_get, _libccv.ccv_dense_vector_t_prime_set)
    load_factor = property(_libccv.ccv_dense_vector_t_load_factor_get, _libccv.ccv_dense_vector_t_load_factor_set)
    data = property(_libccv.ccv_dense_vector_t_data_get, _libccv.ccv_dense_vector_t_data_set)
    indice = property(_libccv.ccv_dense_vector_t_indice_get, _libccv.ccv_dense_vector_t_indice_set)
    next = property(_libccv.ccv_dense_vector_t_next_get, _libccv.ccv_dense_vector_t_next_set)

    def __init__(self):
        _libccv.ccv_dense_vector_t_swiginit(self, _libccv.new_ccv_dense_vector_t())
    __swig_destroy__ = _libccv.delete_ccv_dense_vector_t

# Register ccv_dense_vector_t in _libccv:
_libccv.ccv_dense_vector_t_swigregister(ccv_dense_vector_t)

CCV_SPARSE_ROW_MAJOR = _libccv.CCV_SPARSE_ROW_MAJOR
CCV_SPARSE_COL_MAJOR = _libccv.CCV_SPARSE_COL_MAJOR
class ccv_sparse_matrix_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type = property(_libccv.ccv_sparse_matrix_t_type_get, _libccv.ccv_sparse_matrix_t_type_set)
    sig = property(_libccv.ccv_sparse_matrix_t_sig_get, _libccv.ccv_sparse_matrix_t_sig_set)
    refcount = property(_libccv.ccv_sparse_matrix_t_refcount_get, _libccv.ccv_sparse_matrix_t_refcount_set)
    rows = property(_libccv.ccv_sparse_matrix_t_rows_get, _libccv.ccv_sparse_matrix_t_rows_set)
    cols = property(_libccv.ccv_sparse_matrix_t_cols_get, _libccv.ccv_sparse_matrix_t_cols_set)
    major = property(_libccv.ccv_sparse_matrix_t_major_get, _libccv.ccv_sparse_matrix_t_major_set)
    prime = property(_libccv.ccv_sparse_matrix_t_prime_get, _libccv.ccv_sparse_matrix_t_prime_set)
    load_factor = property(_libccv.ccv_sparse_matrix_t_load_factor_get, _libccv.ccv_sparse_matrix_t_load_factor_set)
    tag = property(_libccv.ccv_sparse_matrix_t_tag_get)
    vector = property(_libccv.ccv_sparse_matrix_t_vector_get, _libccv.ccv_sparse_matrix_t_vector_set)

    def __init__(self):
        _libccv.ccv_sparse_matrix_t_swiginit(self, _libccv.new_ccv_sparse_matrix_t())
    __swig_destroy__ = _libccv.delete_ccv_sparse_matrix_t

# Register ccv_sparse_matrix_t in _libccv:
_libccv.ccv_sparse_matrix_t_swigregister(ccv_sparse_matrix_t)

class ccv_sparse_matrix_t_tag(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    chr = property(_libccv.ccv_sparse_matrix_t_tag_chr_get, _libccv.ccv_sparse_matrix_t_tag_chr_set)
    i = property(_libccv.ccv_sparse_matrix_t_tag_i_get, _libccv.ccv_sparse_matrix_t_tag_i_set)
    fl = property(_libccv.ccv_sparse_matrix_t_tag_fl_get, _libccv.ccv_sparse_matrix_t_tag_fl_set)
    l = property(_libccv.ccv_sparse_matrix_t_tag_l_get, _libccv.ccv_sparse_matrix_t_tag_l_set)
    db = property(_libccv.ccv_sparse_matrix_t_tag_db_get, _libccv.ccv_sparse_matrix_t_tag_db_set)

    def __init__(self):
        _libccv.ccv_sparse_matrix_t_tag_swiginit(self, _libccv.new_ccv_sparse_matrix_t_tag())
    __swig_destroy__ = _libccv.delete_ccv_sparse_matrix_t_tag

# Register ccv_sparse_matrix_t_tag in _libccv:
_libccv.ccv_sparse_matrix_t_tag_swigregister(ccv_sparse_matrix_t_tag)

class ccv_cache_index_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    branch = property(_libccv.ccv_cache_index_t_branch_get)
    terminal = property(_libccv.ccv_cache_index_t_terminal_get)

    def __init__(self):
        _libccv.ccv_cache_index_t_swiginit(self, _libccv.new_ccv_cache_index_t())
    __swig_destroy__ = _libccv.delete_ccv_cache_index_t

# Register ccv_cache_index_t in _libccv:
_libccv.ccv_cache_index_t_swigregister(ccv_cache_index_t)

class ccv_cache_index_t_terminal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    sign = property(_libccv.ccv_cache_index_t_terminal_sign_get, _libccv.ccv_cache_index_t_terminal_sign_set)
    off = property(_libccv.ccv_cache_index_t_terminal_off_get, _libccv.ccv_cache_index_t_terminal_off_set)
    type = property(_libccv.ccv_cache_index_t_terminal_type_get, _libccv.ccv_cache_index_t_terminal_type_set)

    def __init__(self):
        _libccv.ccv_cache_index_t_terminal_swiginit(self, _libccv.new_ccv_cache_index_t_terminal())
    __swig_destroy__ = _libccv.delete_ccv_cache_index_t_terminal

# Register ccv_cache_index_t_terminal in _libccv:
_libccv.ccv_cache_index_t_terminal_swigregister(ccv_cache_index_t_terminal)

class ccv_cache_index_t_branch(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    bitmap = property(_libccv.ccv_cache_index_t_branch_bitmap_get, _libccv.ccv_cache_index_t_branch_bitmap_set)
    set = property(_libccv.ccv_cache_index_t_branch_set_get, _libccv.ccv_cache_index_t_branch_set_set)
    age = property(_libccv.ccv_cache_index_t_branch_age_get, _libccv.ccv_cache_index_t_branch_age_set)

    def __init__(self):
        _libccv.ccv_cache_index_t_branch_swiginit(self, _libccv.new_ccv_cache_index_t_branch())
    __swig_destroy__ = _libccv.delete_ccv_cache_index_t_branch

# Register ccv_cache_index_t_branch in _libccv:
_libccv.ccv_cache_index_t_branch_swigregister(ccv_cache_index_t_branch)

class ccv_cache_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    origin = property(_libccv.ccv_cache_t_origin_get, _libccv.ccv_cache_t_origin_set)
    rnum = property(_libccv.ccv_cache_t_rnum_get, _libccv.ccv_cache_t_rnum_set)
    age = property(_libccv.ccv_cache_t_age_get, _libccv.ccv_cache_t_age_set)
    up = property(_libccv.ccv_cache_t_up_get, _libccv.ccv_cache_t_up_set)
    size = property(_libccv.ccv_cache_t_size_get, _libccv.ccv_cache_t_size_set)
    ffree = property(_libccv.ccv_cache_t_ffree_get, _libccv.ccv_cache_t_ffree_set)

    def __init__(self):
        _libccv.ccv_cache_t_swiginit(self, _libccv.new_ccv_cache_t())
    __swig_destroy__ = _libccv.delete_ccv_cache_t

# Register ccv_cache_t in _libccv:
_libccv.ccv_cache_t_swigregister(ccv_cache_t)


def ccv_cache_init(*args):
    return _libccv.ccv_cache_init(*args)

def ccv_cache_get(cache, sign, type):
    return _libccv.ccv_cache_get(cache, sign, type)

def ccv_cache_put(cache, sign, x, size, type):
    return _libccv.ccv_cache_put(cache, sign, x, size, type)

def ccv_cache_out(cache, sign, type):
    return _libccv.ccv_cache_out(cache, sign, type)

def ccv_cache_delete(cache, sign):
    return _libccv.ccv_cache_delete(cache, sign)

def ccv_cache_cleanup(cache):
    return _libccv.ccv_cache_cleanup(cache)

def ccv_cache_close(cache):
    return _libccv.ccv_cache_close(cache)
class ccv_compressed_sparse_matrix_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type = property(_libccv.ccv_compressed_sparse_matrix_t_type_get, _libccv.ccv_compressed_sparse_matrix_t_type_set)
    sig = property(_libccv.ccv_compressed_sparse_matrix_t_sig_get, _libccv.ccv_compressed_sparse_matrix_t_sig_set)
    refcount = property(_libccv.ccv_compressed_sparse_matrix_t_refcount_get, _libccv.ccv_compressed_sparse_matrix_t_refcount_set)
    rows = property(_libccv.ccv_compressed_sparse_matrix_t_rows_get, _libccv.ccv_compressed_sparse_matrix_t_rows_set)
    cols = property(_libccv.ccv_compressed_sparse_matrix_t_cols_get, _libccv.ccv_compressed_sparse_matrix_t_cols_set)
    nnz = property(_libccv.ccv_compressed_sparse_matrix_t_nnz_get, _libccv.ccv_compressed_sparse_matrix_t_nnz_set)
    tag = property(_libccv.ccv_compressed_sparse_matrix_t_tag_get)
    index = property(_libccv.ccv_compressed_sparse_matrix_t_index_get, _libccv.ccv_compressed_sparse_matrix_t_index_set)
    offset = property(_libccv.ccv_compressed_sparse_matrix_t_offset_get, _libccv.ccv_compressed_sparse_matrix_t_offset_set)
    data = property(_libccv.ccv_compressed_sparse_matrix_t_data_get, _libccv.ccv_compressed_sparse_matrix_t_data_set)

    def __init__(self):
        _libccv.ccv_compressed_sparse_matrix_t_swiginit(self, _libccv.new_ccv_compressed_sparse_matrix_t())
    __swig_destroy__ = _libccv.delete_ccv_compressed_sparse_matrix_t

# Register ccv_compressed_sparse_matrix_t in _libccv:
_libccv.ccv_compressed_sparse_matrix_t_swigregister(ccv_compressed_sparse_matrix_t)

class ccv_compressed_sparse_matrix_t_tag(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    chr = property(_libccv.ccv_compressed_sparse_matrix_t_tag_chr_get, _libccv.ccv_compressed_sparse_matrix_t_tag_chr_set)
    i = property(_libccv.ccv_compressed_sparse_matrix_t_tag_i_get, _libccv.ccv_compressed_sparse_matrix_t_tag_i_set)
    fl = property(_libccv.ccv_compressed_sparse_matrix_t_tag_fl_get, _libccv.ccv_compressed_sparse_matrix_t_tag_fl_set)
    l = property(_libccv.ccv_compressed_sparse_matrix_t_tag_l_get, _libccv.ccv_compressed_sparse_matrix_t_tag_l_set)
    db = property(_libccv.ccv_compressed_sparse_matrix_t_tag_db_get, _libccv.ccv_compressed_sparse_matrix_t_tag_db_set)

    def __init__(self):
        _libccv.ccv_compressed_sparse_matrix_t_tag_swiginit(self, _libccv.new_ccv_compressed_sparse_matrix_t_tag())
    __swig_destroy__ = _libccv.delete_ccv_compressed_sparse_matrix_t_tag

# Register ccv_compressed_sparse_matrix_t_tag in _libccv:
_libccv.ccv_compressed_sparse_matrix_t_tag_swigregister(ccv_compressed_sparse_matrix_t_tag)


def ccv_dense_matrix_renew(x, rows, cols, types, prefer_type, sig):
    return _libccv.ccv_dense_matrix_renew(x, rows, cols, types, prefer_type, sig)

def ccv_dense_matrix_new(rows, cols, type, data, sig):
    return _libccv.ccv_dense_matrix_new(rows, cols, type, data, sig)

def ccv_dense_matrix(rows, cols, type, data, sig):
    return _libccv.ccv_dense_matrix(rows, cols, type, data, sig)

def ccv_make_matrix_mutable(mat):
    return _libccv.ccv_make_matrix_mutable(mat)

def ccv_make_matrix_immutable(mat):
    return _libccv.ccv_make_matrix_immutable(mat)

def ccv_sparse_matrix_new(rows, cols, type, major, sig):
    return _libccv.ccv_sparse_matrix_new(rows, cols, type, major, sig)

def ccv_matrix_free_immediately(mat):
    return _libccv.ccv_matrix_free_immediately(mat)

def ccv_matrix_free(mat):
    return _libccv.ccv_matrix_free(mat)

def ccv_cache_generate_signature(*args):
    return _libccv.ccv_cache_generate_signature(*args)
CCV_DEFAULT_CACHE_SIZE = _libccv.CCV_DEFAULT_CACHE_SIZE

def ccv_drain_cache():
    return _libccv.ccv_drain_cache()

def ccv_disable_cache():
    return _libccv.ccv_disable_cache()

def ccv_enable_default_cache():
    return _libccv.ccv_enable_default_cache()

def ccv_enable_cache(size):
    return _libccv.ccv_enable_cache(size)
CCV_IO_GRAY = _libccv.CCV_IO_GRAY
CCV_IO_RGB_COLOR = _libccv.CCV_IO_RGB_COLOR
CCV_IO_NO_COPY = _libccv.CCV_IO_NO_COPY
CCV_IO_ANY_STREAM = _libccv.CCV_IO_ANY_STREAM
CCV_IO_BMP_STREAM = _libccv.CCV_IO_BMP_STREAM
CCV_IO_JPEG_STREAM = _libccv.CCV_IO_JPEG_STREAM
CCV_IO_PNG_STREAM = _libccv.CCV_IO_PNG_STREAM
CCV_IO_PLAIN_STREAM = _libccv.CCV_IO_PLAIN_STREAM
CCV_IO_DEFLATE_STREAM = _libccv.CCV_IO_DEFLATE_STREAM
CCV_IO_ANY_FILE = _libccv.CCV_IO_ANY_FILE
CCV_IO_BMP_FILE = _libccv.CCV_IO_BMP_FILE
CCV_IO_JPEG_FILE = _libccv.CCV_IO_JPEG_FILE
CCV_IO_PNG_FILE = _libccv.CCV_IO_PNG_FILE
CCV_IO_BINARY_FILE = _libccv.CCV_IO_BINARY_FILE
CCV_IO_ANY_RAW = _libccv.CCV_IO_ANY_RAW
CCV_IO_RGB_RAW = _libccv.CCV_IO_RGB_RAW
CCV_IO_RGBA_RAW = _libccv.CCV_IO_RGBA_RAW
CCV_IO_ARGB_RAW = _libccv.CCV_IO_ARGB_RAW
CCV_IO_BGR_RAW = _libccv.CCV_IO_BGR_RAW
CCV_IO_BGRA_RAW = _libccv.CCV_IO_BGRA_RAW
CCV_IO_ABGR_RAW = _libccv.CCV_IO_ABGR_RAW
CCV_IO_GRAY_RAW = _libccv.CCV_IO_GRAY_RAW
CCV_IO_FINAL = _libccv.CCV_IO_FINAL
CCV_IO_CONTINUE = _libccv.CCV_IO_CONTINUE
CCV_IO_ERROR = _libccv.CCV_IO_ERROR
CCV_IO_ATTEMPTED = _libccv.CCV_IO_ATTEMPTED
CCV_IO_UNKNOWN = _libccv.CCV_IO_UNKNOWN

def ccv_read_impl(_in, type, rows, cols, scanline):
    return _libccv.ccv_read_impl(_in, type, rows, cols, scanline)

def ccv_write(mat, out, len, type, conf):
    return _libccv.ccv_write(mat, out, len, type, conf)

def ccv_trace(mat):
    return _libccv.ccv_trace(mat)
CCV_L1_NORM = _libccv.CCV_L1_NORM
CCV_L2_NORM = _libccv.CCV_L2_NORM
CCV_GSEDT = _libccv.CCV_GSEDT
CCV_NEGATIVE = _libccv.CCV_NEGATIVE
CCV_POSITIVE = _libccv.CCV_POSITIVE
CCV_NO_PADDING = _libccv.CCV_NO_PADDING
CCV_PADDING_ZERO = _libccv.CCV_PADDING_ZERO
CCV_PADDING_EXTEND = _libccv.CCV_PADDING_EXTEND
CCV_PADDING_MIRROR = _libccv.CCV_PADDING_MIRROR
CCV_SIGNED = _libccv.CCV_SIGNED
CCV_UNSIGNED = _libccv.CCV_UNSIGNED

def ccv_norm(mat, type):
    return _libccv.ccv_norm(mat, type)

def ccv_normalize(a, b, btype, flag):
    return _libccv.ccv_normalize(a, b, btype, flag)

def ccv_sat(a, type, padding_pattern):
    return _libccv.ccv_sat(a, type, padding_pattern)

def ccv_sum(mat, flag):
    return _libccv.ccv_sum(mat, flag)

def ccv_variance(mat):
    return _libccv.ccv_variance(mat)

def ccv_multiply(a, b, c, type):
    return _libccv.ccv_multiply(a, b, c, type)

def ccv_add(a, b, c, type):
    return _libccv.ccv_add(a, b, c, type)

def ccv_subtract(a, b, c, type):
    return _libccv.ccv_subtract(a, b, c, type)
CCV_A_TRANSPOSE = _libccv.CCV_A_TRANSPOSE
CCV_B_TRANSPOSE = _libccv.CCV_B_TRANSPOSE
CCV_C_TRANSPOSE = _libccv.CCV_C_TRANSPOSE

def ccv_gemm(a, b, alpha, c, beta, transpose, d, type):
    return _libccv.ccv_gemm(a, b, alpha, c, beta, transpose, d, type)
class ccv_margin_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    left = property(_libccv.ccv_margin_t_left_get, _libccv.ccv_margin_t_left_set)
    top = property(_libccv.ccv_margin_t_top_get, _libccv.ccv_margin_t_top_set)
    right = property(_libccv.ccv_margin_t_right_get, _libccv.ccv_margin_t_right_set)
    bottom = property(_libccv.ccv_margin_t_bottom_get, _libccv.ccv_margin_t_bottom_set)

    def __init__(self):
        _libccv.ccv_margin_t_swiginit(self, _libccv.new_ccv_margin_t())
    __swig_destroy__ = _libccv.delete_ccv_margin_t

# Register ccv_margin_t in _libccv:
_libccv.ccv_margin_t_swigregister(ccv_margin_t)


def ccv_margin(left, top, right, bottom):
    return _libccv.ccv_margin(left, top, right, bottom)

def ccv_get_dense_matrix(mat):
    return _libccv.ccv_get_dense_matrix(mat)

def ccv_get_sparse_matrix(mat):
    return _libccv.ccv_get_sparse_matrix(mat)

def ccv_get_sparse_matrix_vector(mat, index):
    return _libccv.ccv_get_sparse_matrix_vector(mat, index)

def ccv_get_sparse_matrix_cell(mat, row, col):
    return _libccv.ccv_get_sparse_matrix_cell(mat, row, col)

def ccv_set_sparse_matrix_cell(mat, row, col, data):
    return _libccv.ccv_set_sparse_matrix_cell(mat, row, col, data)

def ccv_compress_sparse_matrix(mat, csm):
    return _libccv.ccv_compress_sparse_matrix(mat, csm)

def ccv_decompress_sparse_matrix(csm, smt):
    return _libccv.ccv_decompress_sparse_matrix(csm, smt)

def ccv_move(a, b, btype, y, x):
    return _libccv.ccv_move(a, b, btype, y, x)

def ccv_matrix_eq(a, b):
    return _libccv.ccv_matrix_eq(a, b)

def ccv_slice(a, b, btype, y, x, rows, cols):
    return _libccv.ccv_slice(a, b, btype, y, x, rows, cols)

def ccv_border(a, b, type, margin):
    return _libccv.ccv_border(a, b, type, margin)

def ccv_visualize(a, b, type):
    return _libccv.ccv_visualize(a, b, type)

def ccv_flatten(a, b, type, flag):
    return _libccv.ccv_flatten(a, b, type, flag)

def ccv_zero(mat):
    return _libccv.ccv_zero(mat)

def ccv_shift(a, b, type, lr, rr):
    return _libccv.ccv_shift(a, b, type, lr, rr)

def ccv_any_nan(a):
    return _libccv.ccv_any_nan(a)

def ccv_float_to_half_precision(f, h, len):
    return _libccv.ccv_float_to_half_precision(f, h, len)

def ccv_half_precision_to_float(h, f, len):
    return _libccv.ccv_half_precision_to_float(h, f, len)
class ccv_size_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    width = property(_libccv.ccv_size_t_width_get, _libccv.ccv_size_t_width_set)
    height = property(_libccv.ccv_size_t_height_get, _libccv.ccv_size_t_height_set)

    def __init__(self):
        _libccv.ccv_size_t_swiginit(self, _libccv.new_ccv_size_t())
    __swig_destroy__ = _libccv.delete_ccv_size_t

# Register ccv_size_t in _libccv:
_libccv.ccv_size_t_swigregister(ccv_size_t)


def ccv_size(width, height):
    return _libccv.ccv_size(width, height)

def ccv_size_is_zero(size):
    return _libccv.ccv_size_is_zero(size)
class ccv_rect_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_libccv.ccv_rect_t_x_get, _libccv.ccv_rect_t_x_set)
    y = property(_libccv.ccv_rect_t_y_get, _libccv.ccv_rect_t_y_set)
    width = property(_libccv.ccv_rect_t_width_get, _libccv.ccv_rect_t_width_set)
    height = property(_libccv.ccv_rect_t_height_get, _libccv.ccv_rect_t_height_set)

    def __init__(self):
        _libccv.ccv_rect_t_swiginit(self, _libccv.new_ccv_rect_t())
    __swig_destroy__ = _libccv.delete_ccv_rect_t

# Register ccv_rect_t in _libccv:
_libccv.ccv_rect_t_swigregister(ccv_rect_t)


def ccv_rect(x, y, width, height):
    return _libccv.ccv_rect(x, y, width, height)

def ccv_rect_is_zero(rect):
    return _libccv.ccv_rect_is_zero(rect)
class ccv_array_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type = property(_libccv.ccv_array_t_type_get, _libccv.ccv_array_t_type_set)
    sig = property(_libccv.ccv_array_t_sig_get, _libccv.ccv_array_t_sig_set)
    refcount = property(_libccv.ccv_array_t_refcount_get, _libccv.ccv_array_t_refcount_set)
    rnum = property(_libccv.ccv_array_t_rnum_get, _libccv.ccv_array_t_rnum_set)
    size = property(_libccv.ccv_array_t_size_get, _libccv.ccv_array_t_size_set)
    rsize = property(_libccv.ccv_array_t_rsize_get, _libccv.ccv_array_t_rsize_set)
    data = property(_libccv.ccv_array_t_data_get, _libccv.ccv_array_t_data_set)

    def __init__(self):
        _libccv.ccv_array_t_swiginit(self, _libccv.new_ccv_array_t())
    __swig_destroy__ = _libccv.delete_ccv_array_t

# Register ccv_array_t in _libccv:
_libccv.ccv_array_t_swigregister(ccv_array_t)


def ccv_array_new(rsize, rnum, sig):
    return _libccv.ccv_array_new(rsize, rnum, sig)

def ccv_array_push(array, r):
    return _libccv.ccv_array_push(array, r)

def ccv_array_group(array, index, gfunc, data):
    return _libccv.ccv_array_group(array, index, gfunc, data)

def ccv_make_array_immutable(array):
    return _libccv.ccv_make_array_immutable(array)

def ccv_make_array_mutable(array):
    return _libccv.ccv_make_array_mutable(array)

def ccv_array_zero(array):
    return _libccv.ccv_array_zero(array)

def ccv_array_clear(array):
    return _libccv.ccv_array_clear(array)

def ccv_array_free_immediately(array):
    return _libccv.ccv_array_free_immediately(array)

def ccv_array_free(array):
    return _libccv.ccv_array_free(array)
class ccv_point_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_libccv.ccv_point_t_x_get, _libccv.ccv_point_t_x_set)
    y = property(_libccv.ccv_point_t_y_get, _libccv.ccv_point_t_y_set)

    def __init__(self):
        _libccv.ccv_point_t_swiginit(self, _libccv.new_ccv_point_t())
    __swig_destroy__ = _libccv.delete_ccv_point_t

# Register ccv_point_t in _libccv:
_libccv.ccv_point_t_swigregister(ccv_point_t)


def ccv_point(x, y):
    return _libccv.ccv_point(x, y)
class ccv_decimal_point_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_libccv.ccv_decimal_point_t_x_get, _libccv.ccv_decimal_point_t_x_set)
    y = property(_libccv.ccv_decimal_point_t_y_get, _libccv.ccv_decimal_point_t_y_set)

    def __init__(self):
        _libccv.ccv_decimal_point_t_swiginit(self, _libccv.new_ccv_decimal_point_t())
    __swig_destroy__ = _libccv.delete_ccv_decimal_point_t

# Register ccv_decimal_point_t in _libccv:
_libccv.ccv_decimal_point_t_swigregister(ccv_decimal_point_t)


def ccv_decimal_point(x, y):
    return _libccv.ccv_decimal_point(x, y)
class ccv_decimal_pose_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_libccv.ccv_decimal_pose_t_x_get, _libccv.ccv_decimal_pose_t_x_set)
    y = property(_libccv.ccv_decimal_pose_t_y_get, _libccv.ccv_decimal_pose_t_y_set)
    a = property(_libccv.ccv_decimal_pose_t_a_get, _libccv.ccv_decimal_pose_t_a_set)
    b = property(_libccv.ccv_decimal_pose_t_b_get, _libccv.ccv_decimal_pose_t_b_set)
    roll = property(_libccv.ccv_decimal_pose_t_roll_get, _libccv.ccv_decimal_pose_t_roll_set)
    pitch = property(_libccv.ccv_decimal_pose_t_pitch_get, _libccv.ccv_decimal_pose_t_pitch_set)
    yaw = property(_libccv.ccv_decimal_pose_t_yaw_get, _libccv.ccv_decimal_pose_t_yaw_set)

    def __init__(self):
        _libccv.ccv_decimal_pose_t_swiginit(self, _libccv.new_ccv_decimal_pose_t())
    __swig_destroy__ = _libccv.delete_ccv_decimal_pose_t

# Register ccv_decimal_pose_t in _libccv:
_libccv.ccv_decimal_pose_t_swigregister(ccv_decimal_pose_t)


def ccv_decimal_pose(x, y, a, b, roll, pitch, yaw):
    return _libccv.ccv_decimal_pose(x, y, a, b, roll, pitch, yaw)
class ccv_contour_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    rect = property(_libccv.ccv_contour_t_rect_get, _libccv.ccv_contour_t_rect_set)
    size = property(_libccv.ccv_contour_t_size_get, _libccv.ccv_contour_t_size_set)
    set = property(_libccv.ccv_contour_t_set_get, _libccv.ccv_contour_t_set_set)
    m10 = property(_libccv.ccv_contour_t_m10_get, _libccv.ccv_contour_t_m10_set)
    m01 = property(_libccv.ccv_contour_t_m01_get, _libccv.ccv_contour_t_m01_set)
    m11 = property(_libccv.ccv_contour_t_m11_get, _libccv.ccv_contour_t_m11_set)
    m20 = property(_libccv.ccv_contour_t_m20_get, _libccv.ccv_contour_t_m20_set)
    m02 = property(_libccv.ccv_contour_t_m02_get, _libccv.ccv_contour_t_m02_set)

    def __init__(self):
        _libccv.ccv_contour_t_swiginit(self, _libccv.new_ccv_contour_t())
    __swig_destroy__ = _libccv.delete_ccv_contour_t

# Register ccv_contour_t in _libccv:
_libccv.ccv_contour_t_swigregister(ccv_contour_t)


def ccv_contour_new(set):
    return _libccv.ccv_contour_new(set)

def ccv_contour_push(contour, point):
    return _libccv.ccv_contour_push(contour, point)

def ccv_contour_free(contour):
    return _libccv.ccv_contour_free(contour)

def ccv_invert(a, b, type):
    return _libccv.ccv_invert(a, b, type)

def ccv_solve(a, b, d, type):
    return _libccv.ccv_solve(a, b, d, type)

def ccv_eigen(a, type, epsilon):
    return _libccv.ccv_eigen(a, type, epsilon)
class ccv_minimize_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    interp = property(_libccv.ccv_minimize_param_t_interp_get, _libccv.ccv_minimize_param_t_interp_set)
    extrap = property(_libccv.ccv_minimize_param_t_extrap_get, _libccv.ccv_minimize_param_t_extrap_set)
    max_iter = property(_libccv.ccv_minimize_param_t_max_iter_get, _libccv.ccv_minimize_param_t_max_iter_set)
    ratio = property(_libccv.ccv_minimize_param_t_ratio_get, _libccv.ccv_minimize_param_t_ratio_set)
    rho = property(_libccv.ccv_minimize_param_t_rho_get, _libccv.ccv_minimize_param_t_rho_set)
    sig = property(_libccv.ccv_minimize_param_t_sig_get, _libccv.ccv_minimize_param_t_sig_set)

    def __init__(self):
        _libccv.ccv_minimize_param_t_swiginit(self, _libccv.new_ccv_minimize_param_t())
    __swig_destroy__ = _libccv.delete_ccv_minimize_param_t

# Register ccv_minimize_param_t in _libccv:
_libccv.ccv_minimize_param_t_swigregister(ccv_minimize_param_t)


def ccv_minimize(x, length, red, func, params, data):
    return _libccv.ccv_minimize(x, length, red, func, params, data)

def ccv_filter(a, b, type, padding_pattern):
    return _libccv.ccv_filter(a, b, type, padding_pattern)

def ccv_filter_kernel(x, func, data):
    return _libccv.ccv_filter_kernel(x, func, data)

def ccv_distance_transform(a, type, x_type, y_type, dx, dy, dxx, dyy, flag):
    return _libccv.ccv_distance_transform(a, type, x_type, y_type, dx, dy, dxx, dyy, flag)

def ccv_sparse_coding(x, k, A, typeA, y, typey):
    return _libccv.ccv_sparse_coding(x, k, A, typeA, y, typey)

def ccv_sobel(a, type, dx, dy):
    return _libccv.ccv_sobel(a, type, dx, dy)

def ccv_gradient(a, ttype, mtype, dx, dy):
    return _libccv.ccv_gradient(a, ttype, mtype, dx, dy)
CCV_FLIP_X = _libccv.CCV_FLIP_X
CCV_FLIP_Y = _libccv.CCV_FLIP_Y

def ccv_flip(a, btype, type):
    return _libccv.ccv_flip(a, btype, type)

def ccv_blur(a, type, sigma):
    return _libccv.ccv_blur(a, type, sigma)
CCV_RGB_TO_YUV = _libccv.CCV_RGB_TO_YUV

def ccv_color_transform(a, type, flag):
    return _libccv.ccv_color_transform(a, type, flag)
CCV_INTER_AREA = _libccv.CCV_INTER_AREA
CCV_INTER_LINEAR = _libccv.CCV_INTER_LINEAR
CCV_INTER_CUBIC = _libccv.CCV_INTER_CUBIC
CCV_INTER_LANCZOS = _libccv.CCV_INTER_LANCZOS

def ccv_resample(a, btype, rows, cols, type):
    return _libccv.ccv_resample(a, btype, rows, cols, type)

def ccv_sample_down(a, type, src_x, src_y):
    return _libccv.ccv_sample_down(a, type, src_x, src_y)

def ccv_sample_up(a, type, src_x, src_y):
    return _libccv.ccv_sample_up(a, type, src_x, src_y)

def ccv_decimal_slice(a, type, y, x, rows, cols):
    return _libccv.ccv_decimal_slice(a, type, y, x, rows, cols)

def ccv_perspective_transform_apply(point, size, m00, m01, m02, m10, m11, m12, m20, m21, m22):
    return _libccv.ccv_perspective_transform_apply(point, size, m00, m01, m02, m10, m11, m12, m20, m21, m22)

def ccv_perspective_transform(a, type, m00, m01, m02, m10, m11, m12, m20, m21, m22):
    return _libccv.ccv_perspective_transform(a, type, m00, m01, m02, m10, m11, m12, m20, m21, m22)

def ccv_hog(a, b_type, sbin, size):
    return _libccv.ccv_hog(a, b_type, sbin, size)

def ccv_canny(a, type, size, low_thresh, high_thresh):
    return _libccv.ccv_canny(a, type, size, low_thresh, high_thresh)

def ccv_close_outline(a, type):
    return _libccv.ccv_close_outline(a, type)

def ccv_otsu(a, outvar, range):
    return _libccv.ccv_otsu(a, outvar, range)
class ccv_decimal_point_with_status_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    point = property(_libccv.ccv_decimal_point_with_status_t_point_get, _libccv.ccv_decimal_point_with_status_t_point_set)
    status = property(_libccv.ccv_decimal_point_with_status_t_status_get, _libccv.ccv_decimal_point_with_status_t_status_set)

    def __init__(self):
        _libccv.ccv_decimal_point_with_status_t_swiginit(self, _libccv.new_ccv_decimal_point_with_status_t())
    __swig_destroy__ = _libccv.delete_ccv_decimal_point_with_status_t

# Register ccv_decimal_point_with_status_t in _libccv:
_libccv.ccv_decimal_point_with_status_t_swigregister(ccv_decimal_point_with_status_t)


def ccv_optical_flow_lucas_kanade(a, b, point_a, point_b, win_size, level, min_eigen):
    return _libccv.ccv_optical_flow_lucas_kanade(a, b, point_a, point_b, win_size, level, min_eigen)
class ccv_daisy_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    radius = property(_libccv.ccv_daisy_param_t_radius_get, _libccv.ccv_daisy_param_t_radius_set)
    rad_q_no = property(_libccv.ccv_daisy_param_t_rad_q_no_get, _libccv.ccv_daisy_param_t_rad_q_no_set)
    th_q_no = property(_libccv.ccv_daisy_param_t_th_q_no_get, _libccv.ccv_daisy_param_t_th_q_no_set)
    hist_th_q_no = property(_libccv.ccv_daisy_param_t_hist_th_q_no_get, _libccv.ccv_daisy_param_t_hist_th_q_no_set)
    normalize_threshold = property(_libccv.ccv_daisy_param_t_normalize_threshold_get, _libccv.ccv_daisy_param_t_normalize_threshold_set)
    normalize_method = property(_libccv.ccv_daisy_param_t_normalize_method_get, _libccv.ccv_daisy_param_t_normalize_method_set)

    def __init__(self):
        _libccv.ccv_daisy_param_t_swiginit(self, _libccv.new_ccv_daisy_param_t())
    __swig_destroy__ = _libccv.delete_ccv_daisy_param_t

# Register ccv_daisy_param_t in _libccv:
_libccv.ccv_daisy_param_t_swigregister(ccv_daisy_param_t)

CCV_DAISY_NORMAL_PARTIAL = _libccv.CCV_DAISY_NORMAL_PARTIAL
CCV_DAISY_NORMAL_FULL = _libccv.CCV_DAISY_NORMAL_FULL
CCV_DAISY_NORMAL_SIFT = _libccv.CCV_DAISY_NORMAL_SIFT

def ccv_daisy(a, type, params):
    return _libccv.ccv_daisy(a, type, params)
class ccv_keypoint_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_libccv.ccv_keypoint_t_x_get, _libccv.ccv_keypoint_t_x_set)
    y = property(_libccv.ccv_keypoint_t_y_get, _libccv.ccv_keypoint_t_y_set)
    octave = property(_libccv.ccv_keypoint_t_octave_get, _libccv.ccv_keypoint_t_octave_set)
    level = property(_libccv.ccv_keypoint_t_level_get, _libccv.ccv_keypoint_t_level_set)
    affine = property(_libccv.ccv_keypoint_t_affine_get)
    regular = property(_libccv.ccv_keypoint_t_regular_get)

    def __init__(self):
        _libccv.ccv_keypoint_t_swiginit(self, _libccv.new_ccv_keypoint_t())
    __swig_destroy__ = _libccv.delete_ccv_keypoint_t

# Register ccv_keypoint_t in _libccv:
_libccv.ccv_keypoint_t_swigregister(ccv_keypoint_t)

class ccv_sift_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    up2x = property(_libccv.ccv_sift_param_t_up2x_get, _libccv.ccv_sift_param_t_up2x_set)
    noctaves = property(_libccv.ccv_sift_param_t_noctaves_get, _libccv.ccv_sift_param_t_noctaves_set)
    nlevels = property(_libccv.ccv_sift_param_t_nlevels_get, _libccv.ccv_sift_param_t_nlevels_set)
    edge_threshold = property(_libccv.ccv_sift_param_t_edge_threshold_get, _libccv.ccv_sift_param_t_edge_threshold_set)
    peak_threshold = property(_libccv.ccv_sift_param_t_peak_threshold_get, _libccv.ccv_sift_param_t_peak_threshold_set)
    norm_threshold = property(_libccv.ccv_sift_param_t_norm_threshold_get, _libccv.ccv_sift_param_t_norm_threshold_set)

    def __init__(self):
        _libccv.ccv_sift_param_t_swiginit(self, _libccv.new_ccv_sift_param_t())
    __swig_destroy__ = _libccv.delete_ccv_sift_param_t

# Register ccv_sift_param_t in _libccv:
_libccv.ccv_sift_param_t_swigregister(ccv_sift_param_t)


def ccv_sift(a, keypoints, type, params):
    return _libccv.ccv_sift(a, keypoints, type, params)
class ccv_mser_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    delta = property(_libccv.ccv_mser_param_t_delta_get, _libccv.ccv_mser_param_t_delta_set)
    min_area = property(_libccv.ccv_mser_param_t_min_area_get, _libccv.ccv_mser_param_t_min_area_set)
    direction = property(_libccv.ccv_mser_param_t_direction_get, _libccv.ccv_mser_param_t_direction_set)
    max_area = property(_libccv.ccv_mser_param_t_max_area_get, _libccv.ccv_mser_param_t_max_area_set)
    max_variance = property(_libccv.ccv_mser_param_t_max_variance_get, _libccv.ccv_mser_param_t_max_variance_set)
    min_diversity = property(_libccv.ccv_mser_param_t_min_diversity_get, _libccv.ccv_mser_param_t_min_diversity_set)
    range = property(_libccv.ccv_mser_param_t_range_get, _libccv.ccv_mser_param_t_range_set)
    area_threshold = property(_libccv.ccv_mser_param_t_area_threshold_get, _libccv.ccv_mser_param_t_area_threshold_set)
    min_margin = property(_libccv.ccv_mser_param_t_min_margin_get, _libccv.ccv_mser_param_t_min_margin_set)
    max_evolution = property(_libccv.ccv_mser_param_t_max_evolution_get, _libccv.ccv_mser_param_t_max_evolution_set)
    edge_blur_sigma = property(_libccv.ccv_mser_param_t_edge_blur_sigma_get, _libccv.ccv_mser_param_t_edge_blur_sigma_set)

    def __init__(self):
        _libccv.ccv_mser_param_t_swiginit(self, _libccv.new_ccv_mser_param_t())
    __swig_destroy__ = _libccv.delete_ccv_mser_param_t

# Register ccv_mser_param_t in _libccv:
_libccv.ccv_mser_param_t_swigregister(ccv_mser_param_t)
ccv_sift_default_params = cvar.ccv_sift_default_params

class ccv_mser_keypoint_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    rect = property(_libccv.ccv_mser_keypoint_t_rect_get, _libccv.ccv_mser_keypoint_t_rect_set)
    size = property(_libccv.ccv_mser_keypoint_t_size_get, _libccv.ccv_mser_keypoint_t_size_set)
    m10 = property(_libccv.ccv_mser_keypoint_t_m10_get, _libccv.ccv_mser_keypoint_t_m10_set)
    m01 = property(_libccv.ccv_mser_keypoint_t_m01_get, _libccv.ccv_mser_keypoint_t_m01_set)
    m11 = property(_libccv.ccv_mser_keypoint_t_m11_get, _libccv.ccv_mser_keypoint_t_m11_set)
    m20 = property(_libccv.ccv_mser_keypoint_t_m20_get, _libccv.ccv_mser_keypoint_t_m20_set)
    m02 = property(_libccv.ccv_mser_keypoint_t_m02_get, _libccv.ccv_mser_keypoint_t_m02_set)
    keypoint = property(_libccv.ccv_mser_keypoint_t_keypoint_get, _libccv.ccv_mser_keypoint_t_keypoint_set)

    def __init__(self):
        _libccv.ccv_mser_keypoint_t_swiginit(self, _libccv.new_ccv_mser_keypoint_t())
    __swig_destroy__ = _libccv.delete_ccv_mser_keypoint_t

# Register ccv_mser_keypoint_t in _libccv:
_libccv.ccv_mser_keypoint_t_swigregister(ccv_mser_keypoint_t)

CCV_BRIGHT_TO_DARK = _libccv.CCV_BRIGHT_TO_DARK
CCV_DARK_TO_BRIGHT = _libccv.CCV_DARK_TO_BRIGHT

def ccv_mser(a, h, type, params):
    return _libccv.ccv_mser(a, h, type, params)
class ccv_swt_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    interval = property(_libccv.ccv_swt_param_t_interval_get, _libccv.ccv_swt_param_t_interval_set)
    min_neighbors = property(_libccv.ccv_swt_param_t_min_neighbors_get, _libccv.ccv_swt_param_t_min_neighbors_set)
    scale_invariant = property(_libccv.ccv_swt_param_t_scale_invariant_get, _libccv.ccv_swt_param_t_scale_invariant_set)
    direction = property(_libccv.ccv_swt_param_t_direction_get, _libccv.ccv_swt_param_t_direction_set)
    same_word_thresh = property(_libccv.ccv_swt_param_t_same_word_thresh_get, _libccv.ccv_swt_param_t_same_word_thresh_set)
    size = property(_libccv.ccv_swt_param_t_size_get, _libccv.ccv_swt_param_t_size_set)
    low_thresh = property(_libccv.ccv_swt_param_t_low_thresh_get, _libccv.ccv_swt_param_t_low_thresh_set)
    high_thresh = property(_libccv.ccv_swt_param_t_high_thresh_get, _libccv.ccv_swt_param_t_high_thresh_set)
    max_height = property(_libccv.ccv_swt_param_t_max_height_get, _libccv.ccv_swt_param_t_max_height_set)
    min_height = property(_libccv.ccv_swt_param_t_min_height_get, _libccv.ccv_swt_param_t_min_height_set)
    min_area = property(_libccv.ccv_swt_param_t_min_area_get, _libccv.ccv_swt_param_t_min_area_set)
    letter_occlude_thresh = property(_libccv.ccv_swt_param_t_letter_occlude_thresh_get, _libccv.ccv_swt_param_t_letter_occlude_thresh_set)
    aspect_ratio = property(_libccv.ccv_swt_param_t_aspect_ratio_get, _libccv.ccv_swt_param_t_aspect_ratio_set)
    std_ratio = property(_libccv.ccv_swt_param_t_std_ratio_get, _libccv.ccv_swt_param_t_std_ratio_set)
    thickness_ratio = property(_libccv.ccv_swt_param_t_thickness_ratio_get, _libccv.ccv_swt_param_t_thickness_ratio_set)
    height_ratio = property(_libccv.ccv_swt_param_t_height_ratio_get, _libccv.ccv_swt_param_t_height_ratio_set)
    intensity_thresh = property(_libccv.ccv_swt_param_t_intensity_thresh_get, _libccv.ccv_swt_param_t_intensity_thresh_set)
    distance_ratio = property(_libccv.ccv_swt_param_t_distance_ratio_get, _libccv.ccv_swt_param_t_distance_ratio_set)
    intersect_ratio = property(_libccv.ccv_swt_param_t_intersect_ratio_get, _libccv.ccv_swt_param_t_intersect_ratio_set)
    elongate_ratio = property(_libccv.ccv_swt_param_t_elongate_ratio_get, _libccv.ccv_swt_param_t_elongate_ratio_set)
    letter_thresh = property(_libccv.ccv_swt_param_t_letter_thresh_get, _libccv.ccv_swt_param_t_letter_thresh_set)
    word_and_letters = property(_libccv.ccv_swt_param_t_word_and_letters_get, _libccv.ccv_swt_param_t_word_and_letters_set)
    kill_rectangle_shapes_ratio = property(_libccv.ccv_swt_param_t_kill_rectangle_shapes_ratio_get, _libccv.ccv_swt_param_t_kill_rectangle_shapes_ratio_set)
    breakdown = property(_libccv.ccv_swt_param_t_breakdown_get, _libccv.ccv_swt_param_t_breakdown_set)
    breakdown_ratio = property(_libccv.ccv_swt_param_t_breakdown_ratio_get, _libccv.ccv_swt_param_t_breakdown_ratio_set)

    def __init__(self):
        _libccv.ccv_swt_param_t_swiginit(self, _libccv.new_ccv_swt_param_t())
    __swig_destroy__ = _libccv.delete_ccv_swt_param_t

# Register ccv_swt_param_t in _libccv:
_libccv.ccv_swt_param_t_swigregister(ccv_swt_param_t)


def ccv_swt(a, type, params):
    return _libccv.ccv_swt(a, type, params)

def ccv_swt_detect_words(a, params):
    return _libccv.ccv_swt_detect_words(a, params)
class ccv_file_info_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    filename = property(_libccv.ccv_file_info_t_filename_get, _libccv.ccv_file_info_t_filename_set)
    box = property(_libccv.ccv_file_info_t_box_get, _libccv.ccv_file_info_t_box_set)
    pose = property(_libccv.ccv_file_info_t_pose_get, _libccv.ccv_file_info_t_pose_set)

    def __init__(self):
        _libccv.ccv_file_info_t_swiginit(self, _libccv.new_ccv_file_info_t())
    __swig_destroy__ = _libccv.delete_ccv_file_info_t

# Register ccv_file_info_t in _libccv:
_libccv.ccv_file_info_t_swigregister(ccv_file_info_t)
ccv_swt_default_params = cvar.ccv_swt_default_params

CCV_DPM_PART_MAX = _libccv.CCV_DPM_PART_MAX
class ccv_classification_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    id = property(_libccv.ccv_classification_t_id_get, _libccv.ccv_classification_t_id_set)
    confidence = property(_libccv.ccv_classification_t_confidence_get, _libccv.ccv_classification_t_confidence_set)

    def __init__(self):
        _libccv.ccv_classification_t_swiginit(self, _libccv.new_ccv_classification_t())
    __swig_destroy__ = _libccv.delete_ccv_classification_t

# Register ccv_classification_t in _libccv:
_libccv.ccv_classification_t_swigregister(ccv_classification_t)

class ccv_comp_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    rect = property(_libccv.ccv_comp_t_rect_get, _libccv.ccv_comp_t_rect_set)
    neighbors = property(_libccv.ccv_comp_t_neighbors_get, _libccv.ccv_comp_t_neighbors_set)
    classification = property(_libccv.ccv_comp_t_classification_get, _libccv.ccv_comp_t_classification_set)

    def __init__(self):
        _libccv.ccv_comp_t_swiginit(self, _libccv.new_ccv_comp_t())
    __swig_destroy__ = _libccv.delete_ccv_comp_t

# Register ccv_comp_t in _libccv:
_libccv.ccv_comp_t_swigregister(ccv_comp_t)

class ccv_root_comp_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    rect = property(_libccv.ccv_root_comp_t_rect_get, _libccv.ccv_root_comp_t_rect_set)
    neighbors = property(_libccv.ccv_root_comp_t_neighbors_get, _libccv.ccv_root_comp_t_neighbors_set)
    classification = property(_libccv.ccv_root_comp_t_classification_get, _libccv.ccv_root_comp_t_classification_set)
    pnum = property(_libccv.ccv_root_comp_t_pnum_get, _libccv.ccv_root_comp_t_pnum_set)
    part = property(_libccv.ccv_root_comp_t_part_get, _libccv.ccv_root_comp_t_part_set)

    def __init__(self):
        _libccv.ccv_root_comp_t_swiginit(self, _libccv.new_ccv_root_comp_t())
    __swig_destroy__ = _libccv.delete_ccv_root_comp_t

# Register ccv_root_comp_t in _libccv:
_libccv.ccv_root_comp_t_swigregister(ccv_root_comp_t)

class ccv_dpm_part_classifier_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    w = property(_libccv.ccv_dpm_part_classifier_t_w_get, _libccv.ccv_dpm_part_classifier_t_w_set)
    dx = property(_libccv.ccv_dpm_part_classifier_t_dx_get, _libccv.ccv_dpm_part_classifier_t_dx_set)
    dy = property(_libccv.ccv_dpm_part_classifier_t_dy_get, _libccv.ccv_dpm_part_classifier_t_dy_set)
    dxx = property(_libccv.ccv_dpm_part_classifier_t_dxx_get, _libccv.ccv_dpm_part_classifier_t_dxx_set)
    dyy = property(_libccv.ccv_dpm_part_classifier_t_dyy_get, _libccv.ccv_dpm_part_classifier_t_dyy_set)
    x = property(_libccv.ccv_dpm_part_classifier_t_x_get, _libccv.ccv_dpm_part_classifier_t_x_set)
    y = property(_libccv.ccv_dpm_part_classifier_t_y_get, _libccv.ccv_dpm_part_classifier_t_y_set)
    z = property(_libccv.ccv_dpm_part_classifier_t_z_get, _libccv.ccv_dpm_part_classifier_t_z_set)
    counterpart = property(_libccv.ccv_dpm_part_classifier_t_counterpart_get, _libccv.ccv_dpm_part_classifier_t_counterpart_set)
    alpha = property(_libccv.ccv_dpm_part_classifier_t_alpha_get, _libccv.ccv_dpm_part_classifier_t_alpha_set)

    def __init__(self):
        _libccv.ccv_dpm_part_classifier_t_swiginit(self, _libccv.new_ccv_dpm_part_classifier_t())
    __swig_destroy__ = _libccv.delete_ccv_dpm_part_classifier_t

# Register ccv_dpm_part_classifier_t in _libccv:
_libccv.ccv_dpm_part_classifier_t_swigregister(ccv_dpm_part_classifier_t)

class ccv_dpm_root_classifier_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    count = property(_libccv.ccv_dpm_root_classifier_t_count_get, _libccv.ccv_dpm_root_classifier_t_count_set)
    root = property(_libccv.ccv_dpm_root_classifier_t_root_get, _libccv.ccv_dpm_root_classifier_t_root_set)
    part = property(_libccv.ccv_dpm_root_classifier_t_part_get, _libccv.ccv_dpm_root_classifier_t_part_set)
    alpha = property(_libccv.ccv_dpm_root_classifier_t_alpha_get, _libccv.ccv_dpm_root_classifier_t_alpha_set)
    beta = property(_libccv.ccv_dpm_root_classifier_t_beta_get, _libccv.ccv_dpm_root_classifier_t_beta_set)

    def __init__(self):
        _libccv.ccv_dpm_root_classifier_t_swiginit(self, _libccv.new_ccv_dpm_root_classifier_t())
    __swig_destroy__ = _libccv.delete_ccv_dpm_root_classifier_t

# Register ccv_dpm_root_classifier_t in _libccv:
_libccv.ccv_dpm_root_classifier_t_swigregister(ccv_dpm_root_classifier_t)

class ccv_dpm_mixture_model_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    count = property(_libccv.ccv_dpm_mixture_model_t_count_get, _libccv.ccv_dpm_mixture_model_t_count_set)
    root = property(_libccv.ccv_dpm_mixture_model_t_root_get, _libccv.ccv_dpm_mixture_model_t_root_set)

    def __init__(self):
        _libccv.ccv_dpm_mixture_model_t_swiginit(self, _libccv.new_ccv_dpm_mixture_model_t())
    __swig_destroy__ = _libccv.delete_ccv_dpm_mixture_model_t

# Register ccv_dpm_mixture_model_t in _libccv:
_libccv.ccv_dpm_mixture_model_t_swigregister(ccv_dpm_mixture_model_t)

class ccv_dpm_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    interval = property(_libccv.ccv_dpm_param_t_interval_get, _libccv.ccv_dpm_param_t_interval_set)
    min_neighbors = property(_libccv.ccv_dpm_param_t_min_neighbors_get, _libccv.ccv_dpm_param_t_min_neighbors_set)
    flags = property(_libccv.ccv_dpm_param_t_flags_get, _libccv.ccv_dpm_param_t_flags_set)
    threshold = property(_libccv.ccv_dpm_param_t_threshold_get, _libccv.ccv_dpm_param_t_threshold_set)

    def __init__(self):
        _libccv.ccv_dpm_param_t_swiginit(self, _libccv.new_ccv_dpm_param_t())
    __swig_destroy__ = _libccv.delete_ccv_dpm_param_t

# Register ccv_dpm_param_t in _libccv:
_libccv.ccv_dpm_param_t_swigregister(ccv_dpm_param_t)

class ccv_dpm_new_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    components = property(_libccv.ccv_dpm_new_param_t_components_get, _libccv.ccv_dpm_new_param_t_components_set)
    parts = property(_libccv.ccv_dpm_new_param_t_parts_get, _libccv.ccv_dpm_new_param_t_parts_set)
    grayscale = property(_libccv.ccv_dpm_new_param_t_grayscale_get, _libccv.ccv_dpm_new_param_t_grayscale_set)
    symmetric = property(_libccv.ccv_dpm_new_param_t_symmetric_get, _libccv.ccv_dpm_new_param_t_symmetric_set)
    min_area = property(_libccv.ccv_dpm_new_param_t_min_area_get, _libccv.ccv_dpm_new_param_t_min_area_set)
    max_area = property(_libccv.ccv_dpm_new_param_t_max_area_get, _libccv.ccv_dpm_new_param_t_max_area_set)
    iterations = property(_libccv.ccv_dpm_new_param_t_iterations_get, _libccv.ccv_dpm_new_param_t_iterations_set)
    data_minings = property(_libccv.ccv_dpm_new_param_t_data_minings_get, _libccv.ccv_dpm_new_param_t_data_minings_set)
    root_relabels = property(_libccv.ccv_dpm_new_param_t_root_relabels_get, _libccv.ccv_dpm_new_param_t_root_relabels_set)
    relabels = property(_libccv.ccv_dpm_new_param_t_relabels_get, _libccv.ccv_dpm_new_param_t_relabels_set)
    discard_estimating_constant = property(_libccv.ccv_dpm_new_param_t_discard_estimating_constant_get, _libccv.ccv_dpm_new_param_t_discard_estimating_constant_set)
    negative_cache_size = property(_libccv.ccv_dpm_new_param_t_negative_cache_size_get, _libccv.ccv_dpm_new_param_t_negative_cache_size_set)
    include_overlap = property(_libccv.ccv_dpm_new_param_t_include_overlap_get, _libccv.ccv_dpm_new_param_t_include_overlap_set)
    alpha = property(_libccv.ccv_dpm_new_param_t_alpha_get, _libccv.ccv_dpm_new_param_t_alpha_set)
    alpha_ratio = property(_libccv.ccv_dpm_new_param_t_alpha_ratio_get, _libccv.ccv_dpm_new_param_t_alpha_ratio_set)
    balance = property(_libccv.ccv_dpm_new_param_t_balance_get, _libccv.ccv_dpm_new_param_t_balance_set)
    C = property(_libccv.ccv_dpm_new_param_t_C_get, _libccv.ccv_dpm_new_param_t_C_set)
    percentile_breakdown = property(_libccv.ccv_dpm_new_param_t_percentile_breakdown_get, _libccv.ccv_dpm_new_param_t_percentile_breakdown_set)
    detector = property(_libccv.ccv_dpm_new_param_t_detector_get, _libccv.ccv_dpm_new_param_t_detector_set)

    def __init__(self):
        _libccv.ccv_dpm_new_param_t_swiginit(self, _libccv.new_ccv_dpm_new_param_t())
    __swig_destroy__ = _libccv.delete_ccv_dpm_new_param_t

# Register ccv_dpm_new_param_t in _libccv:
_libccv.ccv_dpm_new_param_t_swigregister(ccv_dpm_new_param_t)

CCV_DPM_NO_NESTED = _libccv.CCV_DPM_NO_NESTED

def ccv_dpm_mixture_model_new(posfiles, bboxes, posnum, bgfiles, bgnum, negnum, dir, params):
    return _libccv.ccv_dpm_mixture_model_new(posfiles, bboxes, posnum, bgfiles, bgnum, negnum, dir, params)

def ccv_dpm_detect_objects(a, model, count, params):
    return _libccv.ccv_dpm_detect_objects(a, model, count, params)

def ccv_dpm_read_mixture_model(directory):
    return _libccv.ccv_dpm_read_mixture_model(directory)

def ccv_dpm_mixture_model_free(model):
    return _libccv.ccv_dpm_mixture_model_free(model)
CCV_BBF_POINT_MAX = _libccv.CCV_BBF_POINT_MAX
CCV_BBF_POINT_MIN = _libccv.CCV_BBF_POINT_MIN
class ccv_bbf_feature_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    size = property(_libccv.ccv_bbf_feature_t_size_get, _libccv.ccv_bbf_feature_t_size_set)
    px = property(_libccv.ccv_bbf_feature_t_px_get, _libccv.ccv_bbf_feature_t_px_set)
    py = property(_libccv.ccv_bbf_feature_t_py_get, _libccv.ccv_bbf_feature_t_py_set)
    pz = property(_libccv.ccv_bbf_feature_t_pz_get, _libccv.ccv_bbf_feature_t_pz_set)
    nx = property(_libccv.ccv_bbf_feature_t_nx_get, _libccv.ccv_bbf_feature_t_nx_set)
    ny = property(_libccv.ccv_bbf_feature_t_ny_get, _libccv.ccv_bbf_feature_t_ny_set)
    nz = property(_libccv.ccv_bbf_feature_t_nz_get, _libccv.ccv_bbf_feature_t_nz_set)

    def __init__(self):
        _libccv.ccv_bbf_feature_t_swiginit(self, _libccv.new_ccv_bbf_feature_t())
    __swig_destroy__ = _libccv.delete_ccv_bbf_feature_t

# Register ccv_bbf_feature_t in _libccv:
_libccv.ccv_bbf_feature_t_swigregister(ccv_bbf_feature_t)
ccv_dpm_default_params = cvar.ccv_dpm_default_params

class ccv_bbf_stage_classifier_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    count = property(_libccv.ccv_bbf_stage_classifier_t_count_get, _libccv.ccv_bbf_stage_classifier_t_count_set)
    threshold = property(_libccv.ccv_bbf_stage_classifier_t_threshold_get, _libccv.ccv_bbf_stage_classifier_t_threshold_set)
    feature = property(_libccv.ccv_bbf_stage_classifier_t_feature_get, _libccv.ccv_bbf_stage_classifier_t_feature_set)
    alpha = property(_libccv.ccv_bbf_stage_classifier_t_alpha_get, _libccv.ccv_bbf_stage_classifier_t_alpha_set)

    def __init__(self):
        _libccv.ccv_bbf_stage_classifier_t_swiginit(self, _libccv.new_ccv_bbf_stage_classifier_t())
    __swig_destroy__ = _libccv.delete_ccv_bbf_stage_classifier_t

# Register ccv_bbf_stage_classifier_t in _libccv:
_libccv.ccv_bbf_stage_classifier_t_swigregister(ccv_bbf_stage_classifier_t)

class ccv_bbf_classifier_cascade_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    count = property(_libccv.ccv_bbf_classifier_cascade_t_count_get, _libccv.ccv_bbf_classifier_cascade_t_count_set)
    size = property(_libccv.ccv_bbf_classifier_cascade_t_size_get, _libccv.ccv_bbf_classifier_cascade_t_size_set)
    stage_classifier = property(_libccv.ccv_bbf_classifier_cascade_t_stage_classifier_get, _libccv.ccv_bbf_classifier_cascade_t_stage_classifier_set)

    def __init__(self):
        _libccv.ccv_bbf_classifier_cascade_t_swiginit(self, _libccv.new_ccv_bbf_classifier_cascade_t())
    __swig_destroy__ = _libccv.delete_ccv_bbf_classifier_cascade_t

# Register ccv_bbf_classifier_cascade_t in _libccv:
_libccv.ccv_bbf_classifier_cascade_t_swigregister(ccv_bbf_classifier_cascade_t)

CCV_BBF_GENETIC_OPT = _libccv.CCV_BBF_GENETIC_OPT
CCV_BBF_FLOAT_OPT = _libccv.CCV_BBF_FLOAT_OPT
class ccv_bbf_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    interval = property(_libccv.ccv_bbf_param_t_interval_get, _libccv.ccv_bbf_param_t_interval_set)
    min_neighbors = property(_libccv.ccv_bbf_param_t_min_neighbors_get, _libccv.ccv_bbf_param_t_min_neighbors_set)
    flags = property(_libccv.ccv_bbf_param_t_flags_get, _libccv.ccv_bbf_param_t_flags_set)
    accurate = property(_libccv.ccv_bbf_param_t_accurate_get, _libccv.ccv_bbf_param_t_accurate_set)
    size = property(_libccv.ccv_bbf_param_t_size_get, _libccv.ccv_bbf_param_t_size_set)

    def __init__(self):
        _libccv.ccv_bbf_param_t_swiginit(self, _libccv.new_ccv_bbf_param_t())
    __swig_destroy__ = _libccv.delete_ccv_bbf_param_t

# Register ccv_bbf_param_t in _libccv:
_libccv.ccv_bbf_param_t_swigregister(ccv_bbf_param_t)

class ccv_bbf_new_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    pos_crit = property(_libccv.ccv_bbf_new_param_t_pos_crit_get, _libccv.ccv_bbf_new_param_t_pos_crit_set)
    neg_crit = property(_libccv.ccv_bbf_new_param_t_neg_crit_get, _libccv.ccv_bbf_new_param_t_neg_crit_set)
    balance_k = property(_libccv.ccv_bbf_new_param_t_balance_k_get, _libccv.ccv_bbf_new_param_t_balance_k_set)
    layer = property(_libccv.ccv_bbf_new_param_t_layer_get, _libccv.ccv_bbf_new_param_t_layer_set)
    feature_number = property(_libccv.ccv_bbf_new_param_t_feature_number_get, _libccv.ccv_bbf_new_param_t_feature_number_set)
    optimizer = property(_libccv.ccv_bbf_new_param_t_optimizer_get, _libccv.ccv_bbf_new_param_t_optimizer_set)
    detector = property(_libccv.ccv_bbf_new_param_t_detector_get, _libccv.ccv_bbf_new_param_t_detector_set)

    def __init__(self):
        _libccv.ccv_bbf_new_param_t_swiginit(self, _libccv.new_ccv_bbf_new_param_t())
    __swig_destroy__ = _libccv.delete_ccv_bbf_new_param_t

# Register ccv_bbf_new_param_t in _libccv:
_libccv.ccv_bbf_new_param_t_swigregister(ccv_bbf_new_param_t)

CCV_BBF_NO_NESTED = _libccv.CCV_BBF_NO_NESTED

def ccv_bbf_classifier_cascade_new(posnum, bgfiles, bgnum, negnum, size, dir, params):
    return _libccv.ccv_bbf_classifier_cascade_new(posnum, bgfiles, bgnum, negnum, size, dir, params)

def ccv_bbf_detect_objects(a, cascade, count, params):
    return _libccv.ccv_bbf_detect_objects(a, cascade, count, params)

def ccv_bbf_read_classifier_cascade(directory):
    return _libccv.ccv_bbf_read_classifier_cascade(directory)

def ccv_bbf_classifier_cascade_free(cascade):
    return _libccv.ccv_bbf_classifier_cascade_free(cascade)

def ccv_bbf_classifier_cascade_read_binary(s):
    return _libccv.ccv_bbf_classifier_cascade_read_binary(s)

def ccv_bbf_classifier_cascade_write_binary(cascade, s, slen):
    return _libccv.ccv_bbf_classifier_cascade_write_binary(cascade, s, slen)
class ccv_ferns_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    structs = property(_libccv.ccv_ferns_t_structs_get, _libccv.ccv_ferns_t_structs_set)
    features = property(_libccv.ccv_ferns_t_features_get, _libccv.ccv_ferns_t_features_set)
    scales = property(_libccv.ccv_ferns_t_scales_get, _libccv.ccv_ferns_t_scales_set)
    posteriors = property(_libccv.ccv_ferns_t_posteriors_get, _libccv.ccv_ferns_t_posteriors_set)
    threshold = property(_libccv.ccv_ferns_t_threshold_get, _libccv.ccv_ferns_t_threshold_set)
    cnum = property(_libccv.ccv_ferns_t_cnum_get, _libccv.ccv_ferns_t_cnum_set)
    rnum = property(_libccv.ccv_ferns_t_rnum_get, _libccv.ccv_ferns_t_rnum_set)
    posterior = property(_libccv.ccv_ferns_t_posterior_get, _libccv.ccv_ferns_t_posterior_set)
    fern = property(_libccv.ccv_ferns_t_fern_get, _libccv.ccv_ferns_t_fern_set)

    def __init__(self):
        _libccv.ccv_ferns_t_swiginit(self, _libccv.new_ccv_ferns_t())
    __swig_destroy__ = _libccv.delete_ccv_ferns_t

# Register ccv_ferns_t in _libccv:
_libccv.ccv_ferns_t_swigregister(ccv_ferns_t)
ccv_bbf_default_params = cvar.ccv_bbf_default_params


def ccv_ferns_new(structs, features, scales, sizes):
    return _libccv.ccv_ferns_new(structs, features, scales, sizes)

def ccv_ferns_feature(ferns, a, scale, fern):
    return _libccv.ccv_ferns_feature(ferns, a, scale, fern)

def ccv_ferns_correct(ferns, fern, c, repeat):
    return _libccv.ccv_ferns_correct(ferns, fern, c, repeat)

def ccv_ferns_predict(ferns, fern):
    return _libccv.ccv_ferns_predict(ferns, fern)

def ccv_ferns_free(ferns):
    return _libccv.ccv_ferns_free(ferns)
class ccv_tld_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    win_size = property(_libccv.ccv_tld_param_t_win_size_get, _libccv.ccv_tld_param_t_win_size_set)
    level = property(_libccv.ccv_tld_param_t_level_get, _libccv.ccv_tld_param_t_level_set)
    min_eigen = property(_libccv.ccv_tld_param_t_min_eigen_get, _libccv.ccv_tld_param_t_min_eigen_set)
    min_forward_backward_error = property(_libccv.ccv_tld_param_t_min_forward_backward_error_get, _libccv.ccv_tld_param_t_min_forward_backward_error_set)
    interval = property(_libccv.ccv_tld_param_t_interval_get, _libccv.ccv_tld_param_t_interval_set)
    shift = property(_libccv.ccv_tld_param_t_shift_get, _libccv.ccv_tld_param_t_shift_set)
    min_win = property(_libccv.ccv_tld_param_t_min_win_get, _libccv.ccv_tld_param_t_min_win_set)
    include_overlap = property(_libccv.ccv_tld_param_t_include_overlap_get, _libccv.ccv_tld_param_t_include_overlap_set)
    exclude_overlap = property(_libccv.ccv_tld_param_t_exclude_overlap_get, _libccv.ccv_tld_param_t_exclude_overlap_set)
    structs = property(_libccv.ccv_tld_param_t_structs_get, _libccv.ccv_tld_param_t_structs_set)
    features = property(_libccv.ccv_tld_param_t_features_get, _libccv.ccv_tld_param_t_features_set)
    validate_set = property(_libccv.ccv_tld_param_t_validate_set_get, _libccv.ccv_tld_param_t_validate_set_set)
    nnc_same = property(_libccv.ccv_tld_param_t_nnc_same_get, _libccv.ccv_tld_param_t_nnc_same_set)
    nnc_thres = property(_libccv.ccv_tld_param_t_nnc_thres_get, _libccv.ccv_tld_param_t_nnc_thres_set)
    nnc_verify = property(_libccv.ccv_tld_param_t_nnc_verify_get, _libccv.ccv_tld_param_t_nnc_verify_set)
    nnc_beyond = property(_libccv.ccv_tld_param_t_nnc_beyond_get, _libccv.ccv_tld_param_t_nnc_beyond_set)
    nnc_collect = property(_libccv.ccv_tld_param_t_nnc_collect_get, _libccv.ccv_tld_param_t_nnc_collect_set)
    bad_patches = property(_libccv.ccv_tld_param_t_bad_patches_get, _libccv.ccv_tld_param_t_bad_patches_set)
    new_deform = property(_libccv.ccv_tld_param_t_new_deform_get, _libccv.ccv_tld_param_t_new_deform_set)
    track_deform = property(_libccv.ccv_tld_param_t_track_deform_get, _libccv.ccv_tld_param_t_track_deform_set)
    new_deform_angle = property(_libccv.ccv_tld_param_t_new_deform_angle_get, _libccv.ccv_tld_param_t_new_deform_angle_set)
    track_deform_angle = property(_libccv.ccv_tld_param_t_track_deform_angle_get, _libccv.ccv_tld_param_t_track_deform_angle_set)
    new_deform_scale = property(_libccv.ccv_tld_param_t_new_deform_scale_get, _libccv.ccv_tld_param_t_new_deform_scale_set)
    track_deform_scale = property(_libccv.ccv_tld_param_t_track_deform_scale_get, _libccv.ccv_tld_param_t_track_deform_scale_set)
    new_deform_shift = property(_libccv.ccv_tld_param_t_new_deform_shift_get, _libccv.ccv_tld_param_t_new_deform_shift_set)
    track_deform_shift = property(_libccv.ccv_tld_param_t_track_deform_shift_get, _libccv.ccv_tld_param_t_track_deform_shift_set)
    top_n = property(_libccv.ccv_tld_param_t_top_n_get, _libccv.ccv_tld_param_t_top_n_set)
    rotation = property(_libccv.ccv_tld_param_t_rotation_get, _libccv.ccv_tld_param_t_rotation_set)

    def __init__(self):
        _libccv.ccv_tld_param_t_swiginit(self, _libccv.new_ccv_tld_param_t())
    __swig_destroy__ = _libccv.delete_ccv_tld_param_t

# Register ccv_tld_param_t in _libccv:
_libccv.ccv_tld_param_t_swigregister(ccv_tld_param_t)

class ccv_tld_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    params = property(_libccv.ccv_tld_t_params_get, _libccv.ccv_tld_t_params_set)
    box = property(_libccv.ccv_tld_t_box_get, _libccv.ccv_tld_t_box_set)
    ferns = property(_libccv.ccv_tld_t_ferns_get, _libccv.ccv_tld_t_ferns_set)
    sv = property(_libccv.ccv_tld_t_sv_get, _libccv.ccv_tld_t_sv_set)
    patch = property(_libccv.ccv_tld_t_patch_get, _libccv.ccv_tld_t_patch_set)
    found = property(_libccv.ccv_tld_t_found_get, _libccv.ccv_tld_t_found_set)
    verified = property(_libccv.ccv_tld_t_verified_get, _libccv.ccv_tld_t_verified_set)
    top = property(_libccv.ccv_tld_t_top_get, _libccv.ccv_tld_t_top_set)
    ferns_thres = property(_libccv.ccv_tld_t_ferns_thres_get, _libccv.ccv_tld_t_ferns_thres_set)
    nnc_thres = property(_libccv.ccv_tld_t_nnc_thres_get, _libccv.ccv_tld_t_nnc_thres_set)
    nnc_verify_thres = property(_libccv.ccv_tld_t_nnc_verify_thres_get, _libccv.ccv_tld_t_nnc_verify_thres_set)
    var_thres = property(_libccv.ccv_tld_t_var_thres_get, _libccv.ccv_tld_t_var_thres_set)
    frame_signature = property(_libccv.ccv_tld_t_frame_signature_get, _libccv.ccv_tld_t_frame_signature_set)
    count = property(_libccv.ccv_tld_t_count_get, _libccv.ccv_tld_t_count_set)
    sfmt = property(_libccv.ccv_tld_t_sfmt_get, _libccv.ccv_tld_t_sfmt_set)
    dsfmt = property(_libccv.ccv_tld_t_dsfmt_get, _libccv.ccv_tld_t_dsfmt_set)
    fern_buffer = property(_libccv.ccv_tld_t_fern_buffer_get, _libccv.ccv_tld_t_fern_buffer_set)

    def __init__(self):
        _libccv.ccv_tld_t_swiginit(self, _libccv.new_ccv_tld_t())
    __swig_destroy__ = _libccv.delete_ccv_tld_t

# Register ccv_tld_t in _libccv:
_libccv.ccv_tld_t_swigregister(ccv_tld_t)
ccv_tld_default_params = cvar.ccv_tld_default_params

class ccv_tld_info_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    perform_track = property(_libccv.ccv_tld_info_t_perform_track_get, _libccv.ccv_tld_info_t_perform_track_set)
    perform_learn = property(_libccv.ccv_tld_info_t_perform_learn_get, _libccv.ccv_tld_info_t_perform_learn_set)
    track_success = property(_libccv.ccv_tld_info_t_track_success_get, _libccv.ccv_tld_info_t_track_success_set)
    ferns_detects = property(_libccv.ccv_tld_info_t_ferns_detects_get, _libccv.ccv_tld_info_t_ferns_detects_set)
    nnc_detects = property(_libccv.ccv_tld_info_t_nnc_detects_get, _libccv.ccv_tld_info_t_nnc_detects_set)
    clustered_detects = property(_libccv.ccv_tld_info_t_clustered_detects_get, _libccv.ccv_tld_info_t_clustered_detects_set)
    confident_matches = property(_libccv.ccv_tld_info_t_confident_matches_get, _libccv.ccv_tld_info_t_confident_matches_set)
    close_matches = property(_libccv.ccv_tld_info_t_close_matches_get, _libccv.ccv_tld_info_t_close_matches_set)

    def __init__(self):
        _libccv.ccv_tld_info_t_swiginit(self, _libccv.new_ccv_tld_info_t())
    __swig_destroy__ = _libccv.delete_ccv_tld_info_t

# Register ccv_tld_info_t in _libccv:
_libccv.ccv_tld_info_t_swigregister(ccv_tld_info_t)


def ccv_tld_new(a, box, params):
    return _libccv.ccv_tld_new(a, box, params)

def ccv_tld_track_object(tld, a, b, info):
    return _libccv.ccv_tld_track_object(tld, a, b, info)

def ccv_tld_free(tld):
    return _libccv.ccv_tld_free(tld)
CCV_ICF_SAT_MAX = _libccv.CCV_ICF_SAT_MAX
class ccv_icf_feature_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    count = property(_libccv.ccv_icf_feature_t_count_get, _libccv.ccv_icf_feature_t_count_set)
    channel = property(_libccv.ccv_icf_feature_t_channel_get, _libccv.ccv_icf_feature_t_channel_set)
    sat = property(_libccv.ccv_icf_feature_t_sat_get, _libccv.ccv_icf_feature_t_sat_set)
    alpha = property(_libccv.ccv_icf_feature_t_alpha_get, _libccv.ccv_icf_feature_t_alpha_set)
    beta = property(_libccv.ccv_icf_feature_t_beta_get, _libccv.ccv_icf_feature_t_beta_set)

    def __init__(self):
        _libccv.ccv_icf_feature_t_swiginit(self, _libccv.new_ccv_icf_feature_t())
    __swig_destroy__ = _libccv.delete_ccv_icf_feature_t

# Register ccv_icf_feature_t in _libccv:
_libccv.ccv_icf_feature_t_swigregister(ccv_icf_feature_t)

class ccv_icf_decision_tree_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    _pass = property(_libccv.ccv_icf_decision_tree_t__pass_get, _libccv.ccv_icf_decision_tree_t__pass_set)
    features = property(_libccv.ccv_icf_decision_tree_t_features_get, _libccv.ccv_icf_decision_tree_t_features_set)
    weigh = property(_libccv.ccv_icf_decision_tree_t_weigh_get, _libccv.ccv_icf_decision_tree_t_weigh_set)
    threshold = property(_libccv.ccv_icf_decision_tree_t_threshold_get, _libccv.ccv_icf_decision_tree_t_threshold_set)

    def __init__(self):
        _libccv.ccv_icf_decision_tree_t_swiginit(self, _libccv.new_ccv_icf_decision_tree_t())
    __swig_destroy__ = _libccv.delete_ccv_icf_decision_tree_t

# Register ccv_icf_decision_tree_t in _libccv:
_libccv.ccv_icf_decision_tree_t_swigregister(ccv_icf_decision_tree_t)

CCV_ICF_CLASSIFIER_TYPE_A = _libccv.CCV_ICF_CLASSIFIER_TYPE_A
CCV_ICF_CLASSIFIER_TYPE_B = _libccv.CCV_ICF_CLASSIFIER_TYPE_B
class ccv_icf_classifier_cascade_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type = property(_libccv.ccv_icf_classifier_cascade_t_type_get, _libccv.ccv_icf_classifier_cascade_t_type_set)
    count = property(_libccv.ccv_icf_classifier_cascade_t_count_get, _libccv.ccv_icf_classifier_cascade_t_count_set)
    grayscale = property(_libccv.ccv_icf_classifier_cascade_t_grayscale_get, _libccv.ccv_icf_classifier_cascade_t_grayscale_set)
    margin = property(_libccv.ccv_icf_classifier_cascade_t_margin_get, _libccv.ccv_icf_classifier_cascade_t_margin_set)
    size = property(_libccv.ccv_icf_classifier_cascade_t_size_get, _libccv.ccv_icf_classifier_cascade_t_size_set)
    weak_classifiers = property(_libccv.ccv_icf_classifier_cascade_t_weak_classifiers_get, _libccv.ccv_icf_classifier_cascade_t_weak_classifiers_set)

    def __init__(self):
        _libccv.ccv_icf_classifier_cascade_t_swiginit(self, _libccv.new_ccv_icf_classifier_cascade_t())
    __swig_destroy__ = _libccv.delete_ccv_icf_classifier_cascade_t

# Register ccv_icf_classifier_cascade_t in _libccv:
_libccv.ccv_icf_classifier_cascade_t_swigregister(ccv_icf_classifier_cascade_t)

class ccv_icf_multiscale_classifier_cascade_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type = property(_libccv.ccv_icf_multiscale_classifier_cascade_t_type_get, _libccv.ccv_icf_multiscale_classifier_cascade_t_type_set)
    count = property(_libccv.ccv_icf_multiscale_classifier_cascade_t_count_get, _libccv.ccv_icf_multiscale_classifier_cascade_t_count_set)
    octave = property(_libccv.ccv_icf_multiscale_classifier_cascade_t_octave_get, _libccv.ccv_icf_multiscale_classifier_cascade_t_octave_set)
    grayscale = property(_libccv.ccv_icf_multiscale_classifier_cascade_t_grayscale_get, _libccv.ccv_icf_multiscale_classifier_cascade_t_grayscale_set)
    cascade = property(_libccv.ccv_icf_multiscale_classifier_cascade_t_cascade_get, _libccv.ccv_icf_multiscale_classifier_cascade_t_cascade_set)

    def __init__(self):
        _libccv.ccv_icf_multiscale_classifier_cascade_t_swiginit(self, _libccv.new_ccv_icf_multiscale_classifier_cascade_t())
    __swig_destroy__ = _libccv.delete_ccv_icf_multiscale_classifier_cascade_t

# Register ccv_icf_multiscale_classifier_cascade_t in _libccv:
_libccv.ccv_icf_multiscale_classifier_cascade_t_swigregister(ccv_icf_multiscale_classifier_cascade_t)

class ccv_icf_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    min_neighbors = property(_libccv.ccv_icf_param_t_min_neighbors_get, _libccv.ccv_icf_param_t_min_neighbors_set)
    flags = property(_libccv.ccv_icf_param_t_flags_get, _libccv.ccv_icf_param_t_flags_set)
    step_through = property(_libccv.ccv_icf_param_t_step_through_get, _libccv.ccv_icf_param_t_step_through_set)
    interval = property(_libccv.ccv_icf_param_t_interval_get, _libccv.ccv_icf_param_t_interval_set)
    threshold = property(_libccv.ccv_icf_param_t_threshold_get, _libccv.ccv_icf_param_t_threshold_set)

    def __init__(self):
        _libccv.ccv_icf_param_t_swiginit(self, _libccv.new_ccv_icf_param_t())
    __swig_destroy__ = _libccv.delete_ccv_icf_param_t

# Register ccv_icf_param_t in _libccv:
_libccv.ccv_icf_param_t_swigregister(ccv_icf_param_t)

class ccv_icf_new_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    detector = property(_libccv.ccv_icf_new_param_t_detector_get, _libccv.ccv_icf_new_param_t_detector_set)
    grayscale = property(_libccv.ccv_icf_new_param_t_grayscale_get, _libccv.ccv_icf_new_param_t_grayscale_set)
    min_dimension = property(_libccv.ccv_icf_new_param_t_min_dimension_get, _libccv.ccv_icf_new_param_t_min_dimension_set)
    margin = property(_libccv.ccv_icf_new_param_t_margin_get, _libccv.ccv_icf_new_param_t_margin_set)
    size = property(_libccv.ccv_icf_new_param_t_size_get, _libccv.ccv_icf_new_param_t_size_set)
    feature_size = property(_libccv.ccv_icf_new_param_t_feature_size_get, _libccv.ccv_icf_new_param_t_feature_size_set)
    weak_classifier = property(_libccv.ccv_icf_new_param_t_weak_classifier_get, _libccv.ccv_icf_new_param_t_weak_classifier_set)
    bootstrap = property(_libccv.ccv_icf_new_param_t_bootstrap_get, _libccv.ccv_icf_new_param_t_bootstrap_set)
    deform_angle = property(_libccv.ccv_icf_new_param_t_deform_angle_get, _libccv.ccv_icf_new_param_t_deform_angle_set)
    deform_scale = property(_libccv.ccv_icf_new_param_t_deform_scale_get, _libccv.ccv_icf_new_param_t_deform_scale_set)
    deform_shift = property(_libccv.ccv_icf_new_param_t_deform_shift_get, _libccv.ccv_icf_new_param_t_deform_shift_set)
    acceptance = property(_libccv.ccv_icf_new_param_t_acceptance_get, _libccv.ccv_icf_new_param_t_acceptance_set)

    def __init__(self):
        _libccv.ccv_icf_new_param_t_swiginit(self, _libccv.new_ccv_icf_new_param_t())
    __swig_destroy__ = _libccv.delete_ccv_icf_new_param_t

# Register ccv_icf_new_param_t in _libccv:
_libccv.ccv_icf_new_param_t_swigregister(ccv_icf_new_param_t)
ccv_icf_default_params = cvar.ccv_icf_default_params


def ccv_icf(a, type):
    return _libccv.ccv_icf(a, type)

def ccv_icf_classifier_cascade_new(posfiles, posnum, bgfiles, negnum, testfiles, dir, params):
    return _libccv.ccv_icf_classifier_cascade_new(posfiles, posnum, bgfiles, negnum, testfiles, dir, params)

def ccv_icf_classifier_cascade_soft(cascade, posfiles, acceptance):
    return _libccv.ccv_icf_classifier_cascade_soft(cascade, posfiles, acceptance)

def ccv_icf_read_classifier_cascade(filename):
    return _libccv.ccv_icf_read_classifier_cascade(filename)

def ccv_icf_write_classifier_cascade(classifier, filename):
    return _libccv.ccv_icf_write_classifier_cascade(classifier, filename)

def ccv_icf_classifier_cascade_free(classifier):
    return _libccv.ccv_icf_classifier_cascade_free(classifier)

def ccv_icf_read_multiscale_classifier_cascade(directory):
    return _libccv.ccv_icf_read_multiscale_classifier_cascade(directory)

def ccv_icf_write_multiscale_classifier_cascade(classifier, directory):
    return _libccv.ccv_icf_write_multiscale_classifier_cascade(classifier, directory)

def ccv_icf_multiscale_classifier_cascade_free(classifier):
    return _libccv.ccv_icf_multiscale_classifier_cascade_free(classifier)

def ccv_icf_detect_objects(a, cascade, count, params):
    return _libccv.ccv_icf_detect_objects(a, cascade, count, params)
CCV_CONVNET_CONVOLUTIONAL = _libccv.CCV_CONVNET_CONVOLUTIONAL
CCV_CONVNET_FULL_CONNECT = _libccv.CCV_CONVNET_FULL_CONNECT
CCV_CONVNET_MAX_POOL = _libccv.CCV_CONVNET_MAX_POOL
CCV_CONVNET_AVERAGE_POOL = _libccv.CCV_CONVNET_AVERAGE_POOL
CCV_CONVNET_LOCAL_RESPONSE_NORM = _libccv.CCV_CONVNET_LOCAL_RESPONSE_NORM
class ccv_convnet_type_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    convolutional = property(_libccv.ccv_convnet_type_t_convolutional_get)
    pool = property(_libccv.ccv_convnet_type_t_pool_get)
    rnorm = property(_libccv.ccv_convnet_type_t_rnorm_get)
    full_connect = property(_libccv.ccv_convnet_type_t_full_connect_get)

    def __init__(self):
        _libccv.ccv_convnet_type_t_swiginit(self, _libccv.new_ccv_convnet_type_t())
    __swig_destroy__ = _libccv.delete_ccv_convnet_type_t

# Register ccv_convnet_type_t in _libccv:
_libccv.ccv_convnet_type_t_swigregister(ccv_convnet_type_t)

class ccv_convnet_type_t_full_connect(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    count = property(_libccv.ccv_convnet_type_t_full_connect_count_get, _libccv.ccv_convnet_type_t_full_connect_count_set)

    def __init__(self):
        _libccv.ccv_convnet_type_t_full_connect_swiginit(self, _libccv.new_ccv_convnet_type_t_full_connect())
    __swig_destroy__ = _libccv.delete_ccv_convnet_type_t_full_connect

# Register ccv_convnet_type_t_full_connect in _libccv:
_libccv.ccv_convnet_type_t_full_connect_swigregister(ccv_convnet_type_t_full_connect)

class ccv_convnet_type_t_rnorm(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    size = property(_libccv.ccv_convnet_type_t_rnorm_size_get, _libccv.ccv_convnet_type_t_rnorm_size_set)
    kappa = property(_libccv.ccv_convnet_type_t_rnorm_kappa_get, _libccv.ccv_convnet_type_t_rnorm_kappa_set)
    alpha = property(_libccv.ccv_convnet_type_t_rnorm_alpha_get, _libccv.ccv_convnet_type_t_rnorm_alpha_set)
    beta = property(_libccv.ccv_convnet_type_t_rnorm_beta_get, _libccv.ccv_convnet_type_t_rnorm_beta_set)

    def __init__(self):
        _libccv.ccv_convnet_type_t_rnorm_swiginit(self, _libccv.new_ccv_convnet_type_t_rnorm())
    __swig_destroy__ = _libccv.delete_ccv_convnet_type_t_rnorm

# Register ccv_convnet_type_t_rnorm in _libccv:
_libccv.ccv_convnet_type_t_rnorm_swigregister(ccv_convnet_type_t_rnorm)

class ccv_convnet_type_t_pool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    strides = property(_libccv.ccv_convnet_type_t_pool_strides_get, _libccv.ccv_convnet_type_t_pool_strides_set)
    size = property(_libccv.ccv_convnet_type_t_pool_size_get, _libccv.ccv_convnet_type_t_pool_size_set)
    border = property(_libccv.ccv_convnet_type_t_pool_border_get, _libccv.ccv_convnet_type_t_pool_border_set)

    def __init__(self):
        _libccv.ccv_convnet_type_t_pool_swiginit(self, _libccv.new_ccv_convnet_type_t_pool())
    __swig_destroy__ = _libccv.delete_ccv_convnet_type_t_pool

# Register ccv_convnet_type_t_pool in _libccv:
_libccv.ccv_convnet_type_t_pool_swigregister(ccv_convnet_type_t_pool)

class ccv_convnet_type_t_convolutional(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    count = property(_libccv.ccv_convnet_type_t_convolutional_count_get, _libccv.ccv_convnet_type_t_convolutional_count_set)
    strides = property(_libccv.ccv_convnet_type_t_convolutional_strides_get, _libccv.ccv_convnet_type_t_convolutional_strides_set)
    border = property(_libccv.ccv_convnet_type_t_convolutional_border_get, _libccv.ccv_convnet_type_t_convolutional_border_set)
    rows = property(_libccv.ccv_convnet_type_t_convolutional_rows_get, _libccv.ccv_convnet_type_t_convolutional_rows_set)
    cols = property(_libccv.ccv_convnet_type_t_convolutional_cols_get, _libccv.ccv_convnet_type_t_convolutional_cols_set)
    channels = property(_libccv.ccv_convnet_type_t_convolutional_channels_get, _libccv.ccv_convnet_type_t_convolutional_channels_set)
    partition = property(_libccv.ccv_convnet_type_t_convolutional_partition_get, _libccv.ccv_convnet_type_t_convolutional_partition_set)

    def __init__(self):
        _libccv.ccv_convnet_type_t_convolutional_swiginit(self, _libccv.new_ccv_convnet_type_t_convolutional())
    __swig_destroy__ = _libccv.delete_ccv_convnet_type_t_convolutional

# Register ccv_convnet_type_t_convolutional in _libccv:
_libccv.ccv_convnet_type_t_convolutional_swigregister(ccv_convnet_type_t_convolutional)

class ccv_convnet_input_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    matrix = property(_libccv.ccv_convnet_input_t_matrix_get)
    node = property(_libccv.ccv_convnet_input_t_node_get)

    def __init__(self):
        _libccv.ccv_convnet_input_t_swiginit(self, _libccv.new_ccv_convnet_input_t())
    __swig_destroy__ = _libccv.delete_ccv_convnet_input_t

# Register ccv_convnet_input_t in _libccv:
_libccv.ccv_convnet_input_t_swigregister(ccv_convnet_input_t)

class ccv_convnet_input_t_node(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    count = property(_libccv.ccv_convnet_input_t_node_count_get, _libccv.ccv_convnet_input_t_node_count_set)

    def __init__(self):
        _libccv.ccv_convnet_input_t_node_swiginit(self, _libccv.new_ccv_convnet_input_t_node())
    __swig_destroy__ = _libccv.delete_ccv_convnet_input_t_node

# Register ccv_convnet_input_t_node in _libccv:
_libccv.ccv_convnet_input_t_node_swigregister(ccv_convnet_input_t_node)

class ccv_convnet_input_t_matrix(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    rows = property(_libccv.ccv_convnet_input_t_matrix_rows_get, _libccv.ccv_convnet_input_t_matrix_rows_set)
    cols = property(_libccv.ccv_convnet_input_t_matrix_cols_get, _libccv.ccv_convnet_input_t_matrix_cols_set)
    channels = property(_libccv.ccv_convnet_input_t_matrix_channels_get, _libccv.ccv_convnet_input_t_matrix_channels_set)
    partition = property(_libccv.ccv_convnet_input_t_matrix_partition_get, _libccv.ccv_convnet_input_t_matrix_partition_set)

    def __init__(self):
        _libccv.ccv_convnet_input_t_matrix_swiginit(self, _libccv.new_ccv_convnet_input_t_matrix())
    __swig_destroy__ = _libccv.delete_ccv_convnet_input_t_matrix

# Register ccv_convnet_input_t_matrix in _libccv:
_libccv.ccv_convnet_input_t_matrix_swigregister(ccv_convnet_input_t_matrix)

class ccv_convnet_layer_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type = property(_libccv.ccv_convnet_layer_param_t_type_get, _libccv.ccv_convnet_layer_param_t_type_set)
    bias = property(_libccv.ccv_convnet_layer_param_t_bias_get, _libccv.ccv_convnet_layer_param_t_bias_set)
    sigma = property(_libccv.ccv_convnet_layer_param_t_sigma_get, _libccv.ccv_convnet_layer_param_t_sigma_set)
    input = property(_libccv.ccv_convnet_layer_param_t_input_get, _libccv.ccv_convnet_layer_param_t_input_set)
    output = property(_libccv.ccv_convnet_layer_param_t_output_get, _libccv.ccv_convnet_layer_param_t_output_set)

    def __init__(self):
        _libccv.ccv_convnet_layer_param_t_swiginit(self, _libccv.new_ccv_convnet_layer_param_t())
    __swig_destroy__ = _libccv.delete_ccv_convnet_layer_param_t

# Register ccv_convnet_layer_param_t in _libccv:
_libccv.ccv_convnet_layer_param_t_swigregister(ccv_convnet_layer_param_t)

class ccv_convnet_layer_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    type = property(_libccv.ccv_convnet_layer_t_type_get, _libccv.ccv_convnet_layer_t_type_set)
    w = property(_libccv.ccv_convnet_layer_t_w_get, _libccv.ccv_convnet_layer_t_w_set)
    bias = property(_libccv.ccv_convnet_layer_t_bias_get, _libccv.ccv_convnet_layer_t_bias_set)
    wnum = property(_libccv.ccv_convnet_layer_t_wnum_get, _libccv.ccv_convnet_layer_t_wnum_set)
    input = property(_libccv.ccv_convnet_layer_t_input_get, _libccv.ccv_convnet_layer_t_input_set)
    net = property(_libccv.ccv_convnet_layer_t_net_get, _libccv.ccv_convnet_layer_t_net_set)
    reserved = property(_libccv.ccv_convnet_layer_t_reserved_get, _libccv.ccv_convnet_layer_t_reserved_set)

    def __init__(self):
        _libccv.ccv_convnet_layer_t_swiginit(self, _libccv.new_ccv_convnet_layer_t())
    __swig_destroy__ = _libccv.delete_ccv_convnet_layer_t

# Register ccv_convnet_layer_t in _libccv:
_libccv.ccv_convnet_layer_t_swigregister(ccv_convnet_layer_t)

class ccv_convnet_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    use_cwc_accel = property(_libccv.ccv_convnet_t_use_cwc_accel_get, _libccv.ccv_convnet_t_use_cwc_accel_set)
    input = property(_libccv.ccv_convnet_t_input_get, _libccv.ccv_convnet_t_input_set)
    rows = property(_libccv.ccv_convnet_t_rows_get, _libccv.ccv_convnet_t_rows_set)
    cols = property(_libccv.ccv_convnet_t_cols_get, _libccv.ccv_convnet_t_cols_set)
    channels = property(_libccv.ccv_convnet_t_channels_get, _libccv.ccv_convnet_t_channels_set)
    count = property(_libccv.ccv_convnet_t_count_get, _libccv.ccv_convnet_t_count_set)
    mean_activity = property(_libccv.ccv_convnet_t_mean_activity_get, _libccv.ccv_convnet_t_mean_activity_set)
    layers = property(_libccv.ccv_convnet_t_layers_get, _libccv.ccv_convnet_t_layers_set)
    denoms = property(_libccv.ccv_convnet_t_denoms_get, _libccv.ccv_convnet_t_denoms_set)
    acts = property(_libccv.ccv_convnet_t_acts_get, _libccv.ccv_convnet_t_acts_set)
    reserved = property(_libccv.ccv_convnet_t_reserved_get, _libccv.ccv_convnet_t_reserved_set)

    def __init__(self):
        _libccv.ccv_convnet_t_swiginit(self, _libccv.new_ccv_convnet_t())
    __swig_destroy__ = _libccv.delete_ccv_convnet_t

# Register ccv_convnet_t in _libccv:
_libccv.ccv_convnet_t_swigregister(ccv_convnet_t)

class ccv_convnet_layer_sgd_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    decay = property(_libccv.ccv_convnet_layer_sgd_param_t_decay_get, _libccv.ccv_convnet_layer_sgd_param_t_decay_set)
    learn_rate = property(_libccv.ccv_convnet_layer_sgd_param_t_learn_rate_get, _libccv.ccv_convnet_layer_sgd_param_t_learn_rate_set)
    momentum = property(_libccv.ccv_convnet_layer_sgd_param_t_momentum_get, _libccv.ccv_convnet_layer_sgd_param_t_momentum_set)

    def __init__(self):
        _libccv.ccv_convnet_layer_sgd_param_t_swiginit(self, _libccv.new_ccv_convnet_layer_sgd_param_t())
    __swig_destroy__ = _libccv.delete_ccv_convnet_layer_sgd_param_t

# Register ccv_convnet_layer_sgd_param_t in _libccv:
_libccv.ccv_convnet_layer_sgd_param_t_swigregister(ccv_convnet_layer_sgd_param_t)

class ccv_convnet_layer_train_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    dor = property(_libccv.ccv_convnet_layer_train_param_t_dor_get, _libccv.ccv_convnet_layer_train_param_t_dor_set)
    w = property(_libccv.ccv_convnet_layer_train_param_t_w_get, _libccv.ccv_convnet_layer_train_param_t_w_set)
    bias = property(_libccv.ccv_convnet_layer_train_param_t_bias_get, _libccv.ccv_convnet_layer_train_param_t_bias_set)

    def __init__(self):
        _libccv.ccv_convnet_layer_train_param_t_swiginit(self, _libccv.new_ccv_convnet_layer_train_param_t())
    __swig_destroy__ = _libccv.delete_ccv_convnet_layer_train_param_t

# Register ccv_convnet_layer_train_param_t in _libccv:
_libccv.ccv_convnet_layer_train_param_t_swigregister(ccv_convnet_layer_train_param_t)

class ccv_convnet_train_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    max_epoch = property(_libccv.ccv_convnet_train_param_t_max_epoch_get, _libccv.ccv_convnet_train_param_t_max_epoch_set)
    mini_batch = property(_libccv.ccv_convnet_train_param_t_mini_batch_get, _libccv.ccv_convnet_train_param_t_mini_batch_set)
    iterations = property(_libccv.ccv_convnet_train_param_t_iterations_get, _libccv.ccv_convnet_train_param_t_iterations_set)
    symmetric = property(_libccv.ccv_convnet_train_param_t_symmetric_get, _libccv.ccv_convnet_train_param_t_symmetric_set)
    color_gain = property(_libccv.ccv_convnet_train_param_t_color_gain_get, _libccv.ccv_convnet_train_param_t_color_gain_set)
    layer_params = property(_libccv.ccv_convnet_train_param_t_layer_params_get, _libccv.ccv_convnet_train_param_t_layer_params_set)

    def __init__(self):
        _libccv.ccv_convnet_train_param_t_swiginit(self, _libccv.new_ccv_convnet_train_param_t())
    __swig_destroy__ = _libccv.delete_ccv_convnet_train_param_t

# Register ccv_convnet_train_param_t in _libccv:
_libccv.ccv_convnet_train_param_t_swigregister(ccv_convnet_train_param_t)

CCV_CATEGORIZED_DENSE_MATRIX = _libccv.CCV_CATEGORIZED_DENSE_MATRIX
CCV_CATEGORIZED_FILE = _libccv.CCV_CATEGORIZED_FILE
class ccv_categorized_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    c = property(_libccv.ccv_categorized_t_c_get, _libccv.ccv_categorized_t_c_set)
    type = property(_libccv.ccv_categorized_t_type_get, _libccv.ccv_categorized_t_type_set)
    matrix = property(_libccv.ccv_categorized_t_matrix_get, _libccv.ccv_categorized_t_matrix_set)
    file = property(_libccv.ccv_categorized_t_file_get, _libccv.ccv_categorized_t_file_set)

    def __init__(self):
        _libccv.ccv_categorized_t_swiginit(self, _libccv.new_ccv_categorized_t())
    __swig_destroy__ = _libccv.delete_ccv_categorized_t

# Register ccv_categorized_t in _libccv:
_libccv.ccv_categorized_t_swigregister(ccv_categorized_t)


def ccv_categorized(c, matrix, file):
    return _libccv.ccv_categorized(c, matrix, file)
class ccv_convnet_write_param_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    half_precision = property(_libccv.ccv_convnet_write_param_t_half_precision_get, _libccv.ccv_convnet_write_param_t_half_precision_set)

    def __init__(self):
        _libccv.ccv_convnet_write_param_t_swiginit(self, _libccv.new_ccv_convnet_write_param_t())
    __swig_destroy__ = _libccv.delete_ccv_convnet_write_param_t

# Register ccv_convnet_write_param_t in _libccv:
_libccv.ccv_convnet_write_param_t_swigregister(ccv_convnet_write_param_t)


def ccv_convnet_new(use_cwc_accel, input, params, count):
    return _libccv.ccv_convnet_new(use_cwc_accel, input, params, count)

def ccv_convnet_verify(convnet, output):
    return _libccv.ccv_convnet_verify(convnet, output)

def ccv_convnet_supervised_train(convnet, categorizeds, tests, filename, params):
    return _libccv.ccv_convnet_supervised_train(convnet, categorizeds, tests, filename, params)

def ccv_convnet_encode(convnet, batch):
    return _libccv.ccv_convnet_encode(convnet, batch)

def ccv_convnet_classify(convnet, symmetric, ranks, tops, batch):
    return _libccv.ccv_convnet_classify(convnet, symmetric, ranks, tops, batch)

def ccv_convnet_read(use_cwc_accel, filename):
    return _libccv.ccv_convnet_read(use_cwc_accel, filename)

def ccv_convnet_write(convnet, filename, params):
    return _libccv.ccv_convnet_write(convnet, filename, params)

def ccv_convnet_compact(convnet):
    return _libccv.ccv_convnet_compact(convnet)

def ccv_convnet_free(convnet):
    return _libccv.ccv_convnet_free(convnet)


