Package pyopencv :: Module cxcore_hpp_point_ext :: Class MatND

Class MatND

 object --+    
          |    
??.instance --+
              |
             MatND

Property 'ndarray' provides a numpy.ndarray view on the object. If you create a reference to 'ndarray', you must keep the object unchanged until your reference is deleted, or Python may crash! Alternatively, you could create a reference to 'ndarray' by using 'asndarray(obj)', where 'obj' is an instance of this class.

To create an instance of MatND that shares the same data with an ndarray instance, use: 'asMatND(a), where 'a' is an ndarray instance. Similarly, to avoid a potential Python crash, you must keep the current instance unchanged until the reference is deleted.

Nested Classes

[hide private]

__array_1_int_32

__array_1_size_t_32

Instance Methods

[hide private]

__call__(...)
__call__( (MatND)arg1, (vector_Range)ranges) -> MatND :

__getitem__(self, *args, **kwds)

__getslice__(self, *args, **kwds)

__init__(...)
__init__( (object)arg1) -> None :

__iter__(self, *args, **kwds)

__reduce__(...)
helper for pickle

__repr__(self)
repr(x)

__setitem__(self, *args, **kwds)

__setslice__(self, *args, **kwds)

__temp_func(...)
__temp_func( (MatND)arg1) -> Mat :

assign(...)
assign( (MatND)arg1, (MatND)m) -> MatND :

assignTo(...)
assignTo( (MatND)arg1, (MatND)m, (object)type) -> None :

channels(...)
channels( (MatND)arg1) -> int :

clone(...)
clone( (MatND)arg1) -> MatND :

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

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

create(...)
create( (MatND)inst, (vector_int)_sizes, (object)_type) -> None :

depth(...)
depth( (MatND)arg1) -> int :

elemSize(...)
elemSize( (MatND)arg1) -> int :

elemSize1(...)
elemSize1( (MatND)arg1) -> int :

isContinuous(...)
isContinuous( (MatND)arg1) -> bool :

reshape(...)
reshape( (MatND)inst, (object)_newcn [, (vector_int)_newsz=vector_int(len=0, [])]) -> object :

setTo(...)
setTo( (MatND)arg1, (Scalar)s [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0): array(154, dtype=uint8)]) -> MatND :

step1(...)
step1( (MatND)arg1, (object)i) -> int :

type(...)
type( (MatND)arg1) -> int :

Inherited from unreachable.instance: __new__

Inherited from object: __delattr__, __format__, __getattribute__, __hash__, __reduce_ex__, __setattr__, __sizeof__, __str__, __subclasshook__

Class Variables

[hide private]

AUTO_STEP = -1

CONTINUOUS_FLAG = 16384

MAGIC_VAL = 1123942400

MAX_DIM = 32

__instance_size__ = 292

Properties

[hide private]

data

dims

flags

ndarray

size

step

this

Inherited from object: __class__

Method Details

[hide private]

call(...)
(Call operator)


__call__( (MatND)arg1, (vector_Range)ranges) -> MatND :

    C++ signature :
        cv::MatND __call__(cv::MatND,std::vector<cv::Range, std::allocator<cv::Range> >)

init(...)
(Constructor)


__init__( (object)arg1) -> None :

    C++ signature :
        void __init__(_object*)

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

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

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

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

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

    C++ signature :
        void* __init__(boost::python::api::object,std::vector<int, std::allocator<int> >,int)

__init__( (object)arg1, (vector_int)_sizes, (object)_type, (Scalar)s) -> object :

    C++ signature :
        void* __init__(boost::python::api::object,std::vector<int, std::allocator<int> >,int,cv::Scalar_<double>)

__init__( (object)arg1, (MatND)m, (vector_Range)ranges) -> object :

    C++ signature :
        void* __init__(boost::python::api::object,cv::MatND,std::vector<cv::Range, std::allocator<cv::Range> >)

Overrides: object.__init__

reduce(...)

helper for pickle

Overrides: object.__reduce__: (inherited documentation)

repr(self)
(Representation operator)

repr(x)

Overrides: object.__repr__: (inherited documentation)

__temp_func(...)


__temp_func( (MatND)arg1) -> Mat :
    
    Wrapped function:
        operator ::cv::Mat

    C++ signature :
        cv::Mat __temp_func(cv::MatND {lvalue})

assign(...)


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

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

assign( (MatND)arg1, (Scalar)s) -> MatND :
    
    Wrapped function:
        operator=

    C++ signature :
        cv::MatND {lvalue} assign(cv::MatND {lvalue},cv::Scalar_<double>)

assignTo(...)


assignTo( (MatND)arg1, (MatND)m, (object)type) -> None :

    C++ signature :
        void assignTo(cv::MatND {lvalue},cv::MatND {lvalue},int)

channels(...)


channels( (MatND)arg1) -> int :

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

clone(...)


clone( (MatND)arg1) -> MatND :

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

convertTo(...)


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

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

copyTo(...)


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

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

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

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

create(...)


create( (MatND)inst, (vector_int)_sizes, (object)_type) -> None :
    
    Argument '_ndims':
        Dependent argument: omitted from input. Its value is derived from 
        argument '_sizes'.
    Argument '_sizes':
        C++ type: int const *
        Python type: vector_int

    C++ signature :
        void create(cv::MatND {lvalue},std::vector<int, std::allocator<int> >,int)

depth(...)


depth( (MatND)arg1) -> int :

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

elemSize(...)


elemSize( (MatND)arg1) -> int :

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

elemSize1(...)


elemSize1( (MatND)arg1) -> int :

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

isContinuous(...)


isContinuous( (MatND)arg1) -> bool :

    C++ signature :
        bool isContinuous(cv::MatND {lvalue})

reshape(...)


reshape( (MatND)inst, (object)_newcn [, (vector_int)_newsz=vector_int(len=0, [])]) -> object :
    
    Argument '_newndims':
        Dependent argument: omitted from input. Its value is derived from 
        argument '_newsz'.
    Argument '_newsz':
        C++ type: int const *
        Python type: vector_int

    C++ signature :
        boost::python::api::object reshape(cv::MatND,int [,std::vector<int, std::allocator<int> >=vector_int(len=0, [])])

setTo(...)


setTo( (MatND)arg1, (Scalar)s [, (MatND)mask=MatND(shape=(), nchannels=1, depth=0):
array(154, dtype=uint8)]) -> MatND :

    C++ signature :
        cv::MatND {lvalue} setTo(cv::MatND {lvalue},cv::Scalar_<double> [,cv::MatND=MatND(shape=(), nchannels=1, depth=0):
array(154, dtype=uint8)])

step1(...)


step1( (MatND)arg1, (object)i) -> int :

    C++ signature :
        unsigned int step1(cv::MatND {lvalue},int)

type(...)


type( (MatND)arg1) -> int :

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

Property Details

[hide private]

data

Get Method:: unreachable(...)

dims

Get Method:: unreachable(...)
Set Method:: unreachable(...)

flags

Get Method:: unreachable(...)
Set Method:: unreachable(...)

ndarray

Get Method:: unreachable(...)

size

Get Method:: unreachable(...)

step

Get Method:: unreachable(...)

this

Get Method:: unreachable(...)

Class MatND

__call__(...) (Call operator)

__init__(...) (Constructor)

__reduce__(...)

__repr__(self) (Representation operator)

__temp_func(...)

assign(...)

assignTo(...)

channels(...)

clone(...)

convertTo(...)

copyTo(...)

create(...)

depth(...)

elemSize(...)

elemSize1(...)

isContinuous(...)

reshape(...)

setTo(...)

step1(...)

type(...)

data

dims

flags

ndarray

size

step

this

call(...)
(Call operator)

init(...)
(Constructor)

reduce(...)

repr(self)
(Representation operator)