Class SparseMat

__init__( (object)arg1, (Mat)m [, (bool)try1d=False]) -> None :

    C++ signature :
        void __init__(_object*,cv::Mat [,bool=False])

__init__( (object)arg1 [, (MatND)m]) -> None :

    C++ signature :
        void __init__(_object* [,cv::MatND])

__init__( (object)arg1, (SparseMat)m) -> None :

    C++ signature :
        void __init__(_object*,cv::SparseMat)

__init__( (object)arg1, (Mat)_sizes, (object)_type) -> object :

    C++ signature :
        void* __init__(boost::python::api::object,cv::Mat,int)

Overrides: object.__init__

helper for pickle

Overrides: object.__reduce__

(inherited documentation)

addref( (SparseMat)arg1) -> None :

    C++ signature :
        void addref(cv::SparseMat {lvalue})

assign( (SparseMat)arg1, (SparseMat)m) -> SparseMat :
    
    Wrapped function:
        operator=

    C++ signature :
        cv::SparseMat {lvalue} assign(cv::SparseMat {lvalue},cv::SparseMat)

assign( (SparseMat)arg1, (Mat)m) -> SparseMat :
    
    Wrapped function:
        operator=

    C++ signature :
        cv::SparseMat {lvalue} assign(cv::SparseMat {lvalue},cv::Mat)

assign( (SparseMat)arg1, (MatND)m) -> SparseMat :
    
    Wrapped function:
        operator=

    C++ signature :
        cv::SparseMat {lvalue} assign(cv::SparseMat {lvalue},cv::MatND)

assignTo( (SparseMat)arg1, (SparseMat)m [, (object)type=-1]) -> None :

    C++ signature :
        void assignTo(cv::SparseMat {lvalue},cv::SparseMat {lvalue} [,int=-1])

channels( (SparseMat)arg1) -> int :

    C++ signature :
        int channels(cv::SparseMat {lvalue})

clear( (SparseMat)arg1) -> None :

    C++ signature :
        void clear(cv::SparseMat {lvalue})

clone( (SparseMat)arg1) -> SparseMat :

    C++ signature :
        cv::SparseMat clone(cv::SparseMat {lvalue})

convertTo( (SparseMat)arg1, (SparseMat)m, (object)rtype [, (object)alpha=1]) -> None :

    C++ signature :
        void convertTo(cv::SparseMat {lvalue},cv::SparseMat {lvalue},int [,double=1])

convertTo( (SparseMat)arg1, (Mat)m, (object)rtype [, (object)alpha=1 [, (object)beta=0]]) -> None :

    C++ signature :
        void convertTo(cv::SparseMat {lvalue},cv::Mat {lvalue},int [,double=1 [,double=0]])

convertTo( (SparseMat)arg1, (MatND)m, (object)rtype [, (object)alpha=1 [, (object)beta=0]]) -> None :

    C++ signature :
        void convertTo(cv::SparseMat {lvalue},cv::MatND {lvalue},int [,double=1 [,double=0]])

copyTo( (SparseMat)arg1, (SparseMat)m) -> None :

    C++ signature :
        void copyTo(cv::SparseMat {lvalue},cv::SparseMat {lvalue})

copyTo( (SparseMat)arg1, (Mat)m) -> None :

    C++ signature :
        void copyTo(cv::SparseMat {lvalue},cv::Mat {lvalue})

copyTo( (SparseMat)arg1, (MatND)m) -> None :

    C++ signature :
        void copyTo(cv::SparseMat {lvalue},cv::MatND {lvalue})

create( (SparseMat)inst, (Mat)_sizes, (object)_type) -> None :
    
    Argument '_sizes':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).
    Argument 'dims':
        Dependent argument: omitted from the function's calling sequence, as 
        its value is derived from argument '_sizes'.

    C++ signature :
        void create(cv::SparseMat {lvalue},cv::Mat,int)

depth( (SparseMat)arg1) -> int :

    C++ signature :
        int depth(cv::SparseMat {lvalue})

dims( (SparseMat)arg1) -> int :

    C++ signature :
        int dims(cv::SparseMat {lvalue})

elemSize( (SparseMat)arg1) -> int :

    C++ signature :
        unsigned int elemSize(cv::SparseMat {lvalue})

elemSize1( (SparseMat)arg1) -> int :

    C++ signature :
        unsigned int elemSize1(cv::SparseMat {lvalue})

erase_7ee4e9a1250db62333754bd289edbba8( (SparseMat)inst, (Mat)idx) -> object :
    
    Wrapped function:
        erase
    Argument 'hashval':
        C/C++ type: ::size_t *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).
    Argument 'idx':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object erase_7ee4e9a1250db62333754bd289edbba8(cv::SparseMat {lvalue},cv::Mat)

erase_ca8730dab3cfc35be7d8c7cfc84bf06f( (SparseMat)inst, (object)i0, (object)i1, (object)i2) -> object :
    
    Wrapped function:
        erase
    Argument 'hashval':
        C/C++ type: ::size_t *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object erase_ca8730dab3cfc35be7d8c7cfc84bf06f(cv::SparseMat {lvalue},int,int,int)

erase_ce64effe5fbeb3e9588310d12240ddce( (SparseMat)inst, (object)i0, (object)i1) -> object :
    
    Wrapped function:
        erase
    Argument 'hashval':
        C/C++ type: ::size_t *.
        Python type: Python equivalence of the C/C++ type without pointer.
        Output argument: omitted from the function's calling sequence, and is 
        returned along with the function's return value (if any).

    C++ signature :
        boost::python::api::object erase_ce64effe5fbeb3e9588310d12240ddce(cv::SparseMat {lvalue},int,int)

hash( (SparseMat)arg1, (object)i0) -> int :

    C++ signature :
        unsigned int hash(cv::SparseMat {lvalue},int)

hash( (SparseMat)arg1, (object)i0, (object)i1) -> int :

    C++ signature :
        unsigned int hash(cv::SparseMat {lvalue},int,int)

hash( (SparseMat)arg1, (object)i0, (object)i1, (object)i2) -> int :

    C++ signature :
        unsigned int hash(cv::SparseMat {lvalue},int,int,int)

hash_19477be6a05d6299f1601326adc61332( (SparseMat)inst, (Mat)idx) -> object :
    
    Wrapped function:
        hash
    Argument 'idx':
        C/C++ type: int const *.
        Python type: Mat.
        Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. 
        asMat([0,1,2]) or asMat((0,1,2)).

    C++ signature :
        boost::python::api::object hash_19477be6a05d6299f1601326adc61332(cv::SparseMat,cv::Mat)

nzcount( (SparseMat)arg1) -> int :

    C++ signature :
        unsigned int nzcount(cv::SparseMat {lvalue})

release( (SparseMat)arg1) -> None :

    C++ signature :
        void release(cv::SparseMat {lvalue})

resizeHashTab( (SparseMat)arg1, (object)newsize) -> None :

    C++ signature :
        void resizeHashTab(cv::SparseMat {lvalue},unsigned int)

size([  (object)i=-1]) -> None :

    C++ signature :
        void size([ int=-1])

type( (SparseMat)arg1) -> int :

    C++ signature :
        int type(cv::SparseMat {lvalue})

flags

Get Method:

unreachable(...)

Set Method:

unreachable(...)

this

Get Method:

unreachable(...)