Trait opencv::hub_prelude::_InputArrayTrait

pub trait _InputArrayTrait {
    pub fn as_raw__InputArray(&self) -> *const c_void;
    pub fn as_raw_mut__InputArray(&mut self) -> *mut c_void;

    pub fn get_mat(&self, idx: i32) -> Result<Mat> { ... }
    pub fn get_mat_(&self, idx: i32) -> Result<Mat> { ... }
    pub fn get_umat(&self, idx: i32) -> Result<UMat> { ... }
    pub fn get_mat_vector(&self, mv: &mut Vector<Mat>) -> Result<()> { ... }
    pub fn get_umat_vector(&self, umv: &mut Vector<UMat>) -> Result<()> { ... }
    pub fn get_gpu_mat_vector(&self, gpumv: &mut Vector<GpuMat>) -> Result<()> { ... }
    pub fn get_gpu_mat(&self) -> Result<GpuMat> { ... }
    pub fn get_o_gl_buffer(&self) -> Result<Buffer> { ... }
    pub fn get_flags(&self) -> Result<i32> { ... }
    pub fn get_obj(&self) -> Result<*mut c_void> { ... }
    pub fn get_sz(&self) -> Result<Size> { ... }
    pub fn kind(&self) -> Result<_InputArray_KindFlag> { ... }
    pub fn dims(&self, i: i32) -> Result<i32> { ... }
    pub fn cols(&self, i: i32) -> Result<i32> { ... }
    pub fn rows(&self, i: i32) -> Result<i32> { ... }
    pub fn size(&self, i: i32) -> Result<Size> { ... }
    pub fn sizend(&self, sz: &mut i32, i: i32) -> Result<i32> { ... }
    pub fn same_size(&self, arr: &dyn ToInputArray) -> Result<bool> { ... }
    pub fn total(&self, i: i32) -> Result<size_t> { ... }
    pub fn typ(&self, i: i32) -> Result<i32> { ... }
    pub fn depth(&self, i: i32) -> Result<i32> { ... }
    pub fn channels(&self, i: i32) -> Result<i32> { ... }
    pub fn is_continuous(&self, i: i32) -> Result<bool> { ... }
    pub fn is_submatrix(&self, i: i32) -> Result<bool> { ... }
    pub fn empty(&self) -> Result<bool> { ... }
    pub fn copy_to(&self, arr: &mut dyn ToOutputArray) -> Result<()> { ... }
    pub fn copy_to_masked(
        &self, 
        arr: &mut dyn ToOutputArray, 
        mask: &dyn ToInputArray
    ) -> Result<()> { ... }
    pub fn offset(&self, i: i32) -> Result<size_t> { ... }
    pub fn step(&self, i: i32) -> Result<size_t> { ... }
    pub fn is_mat(&self) -> Result<bool> { ... }
    pub fn is_umat(&self) -> Result<bool> { ... }
    pub fn is_mat_vector(&self) -> Result<bool> { ... }
    pub fn is_umat_vector(&self) -> Result<bool> { ... }
    pub fn is_matx(&self) -> Result<bool> { ... }
    pub fn is_vector(&self) -> Result<bool> { ... }
    pub fn is_gpu_mat(&self) -> Result<bool> { ... }
    pub fn is_gpu_mat_vector(&self) -> Result<bool> { ... }
}

This is the proxy class for passing read-only input arrays into OpenCV functions.

It is defined as:

   typedef const _InputArray& InputArray;

where _InputArray is a class that can be constructed from Mat, Mat_<T>, Matx<T, m, n>, std::vector<T>, std::vector<std::vector<T> >, std::vector<Mat>, std::vector<Mat_<T> >, UMat, std::vector<UMat> or double. It can also be constructed from a matrix expression.

Since this is mostly implementation-level class, and its interface may change in future versions, we do not describe it in details. There are a few key things, though, that should be kept in mind:

• When you see in the reference manual or in OpenCV source code a function that takes InputArray, it means that you can actually pass Mat, Matx, vector<T> etc. (see above the complete list).
• Optional input arguments: If some of the input arrays may be empty, pass cv::noArray() (or simply cv::Mat() as you probably did before).
• The class is designed solely for passing parameters. That is, normally you should not declare class members, local and global variables of this type.
• If you want to design your own function or a class method that can operate of arrays of multiple types, you can use InputArray (or OutputArray) for the respective parameters. Inside a function you should use _InputArray::getMat() method to construct a matrix header for the array (without copying data). _InputArray::kind() can be used to distinguish Mat from vector<> etc., but normally it is not needed.

Here is how you can use a function that takes InputArray :

   std::vector<Point2f> vec;
   // points or a circle
   for( int i = 0; i < 30; i++ )
       vec.push_back(Point2f((float)(100 + 30*cos(i*CV_PI*2/5)),
                              (float)(100 - 30*sin(i*CV_PI*2/5))));
   cv::transform(vec, vec, cv::Matx23f(0.707, -0.707, 10, 0.707, 0.707, 20));

That is, we form an STL vector containing points, and apply in-place affine transformation to the vector using the 2x3 matrix created inline as Matx<float, 2, 3> instance.

Here is how such a function can be implemented (for simplicity, we implement a very specific case of it, according to the assertion statement inside) :

   void myAffineTransform(InputArray _src, OutputArray _dst, InputArray _m)
   {
       // get Mat headers for input arrays. This is O(1) operation,
       // unless _src and/or _m are matrix expressions.
       Mat src = _src.getMat(), m = _m.getMat();
       CV_Assert( src.type() == CV_32FC2 && m.type() == CV_32F && m.size() == Size(3, 2) );
 
       // [re]create the output array so that it has the proper size and type.
       // In case of Mat it calls Mat::create, in case of STL vector it calls vector::resize.
       _dst.create(src.size(), src.type());
       Mat dst = _dst.getMat();
 
       for( int i = 0; i < src.rows; i++ )
           for( int j = 0; j < src.cols; j++ )
           {
               Point2f pt = src.at<Point2f>(i, j);
               dst.at<Point2f>(i, j) = Point2f(m.at<float>(0, 0)*pt.x +
                                                m.at<float>(0, 1)*pt.y +
                                                m.at<float>(0, 2),
                                                m.at<float>(1, 0)*pt.x +
                                                m.at<float>(1, 1)*pt.y +
                                                m.at<float>(1, 2));
           }
   }

There is another related type, InputArrayOfArrays, which is currently defined as a synonym for InputArray:

   typedef InputArray InputArrayOfArrays;

It denotes function arguments that are either vectors of vectors or vectors of matrices. A separate synonym is needed to generate Python/Java etc. wrappers properly. At the function implementation level their use is similar, but _InputArray::getMat(idx) should be used to get header for the idx-th component of the outer vector and _InputArray::size().area() should be used to find the number of components (vectors/matrices) of the outer vector.

In general, type support is limited to cv::Mat types. Other types are forbidden. But in some cases we need to support passing of custom non-general Mat types, like arrays of cv::KeyPoint, cv::DMatch, etc. This data is not intended to be interpreted as an image data, or processed somehow like regular cv::Mat. To pass such custom type use rawIn() / rawOut() / rawInOut() wrappers. Custom type is wrapped as Mat-compatible CV_8UC<N> values (N = sizeof(T), N <= CV_CN_MAX).

Required methods

pub fn as_raw__InputArray(&self) -> *const c_void

pub fn as_raw_mut__InputArray(&mut self) -> *mut c_void

Loading content...

Provided methods

pub fn get_mat(&self, idx: i32) -> Result<Mat>

C++ default parameters

• idx: -1

pub fn get_mat_(&self, idx: i32) -> Result<Mat>

C++ default parameters

• idx: -1

pub fn get_umat(&self, idx: i32) -> Result<UMat>

C++ default parameters

• idx: -1

pub fn get_mat_vector(&self, mv: &mut Vector<Mat>) -> Result<()>

pub fn get_umat_vector(&self, umv: &mut Vector<UMat>) -> Result<()>

pub fn get_gpu_mat_vector(&self, gpumv: &mut Vector<GpuMat>) -> Result<()>

pub fn get_gpu_mat(&self) -> Result<GpuMat>

pub fn get_o_gl_buffer(&self) -> Result<Buffer>

pub fn get_flags(&self) -> Result<i32>

pub fn get_obj(&self) -> Result<*mut c_void>

pub fn get_sz(&self) -> Result<Size>

pub fn kind(&self) -> Result<_InputArray_KindFlag>

pub fn dims(&self, i: i32) -> Result<i32>

C++ default parameters

• i: -1

pub fn cols(&self, i: i32) -> Result<i32>

C++ default parameters

• i: -1

pub fn rows(&self, i: i32) -> Result<i32>

C++ default parameters

• i: -1

pub fn size(&self, i: i32) -> Result<Size>

C++ default parameters

• i: -1

pub fn sizend(&self, sz: &mut i32, i: i32) -> Result<i32>

C++ default parameters

• i: -1

pub fn same_size(&self, arr: &dyn ToInputArray) -> Result<bool>

pub fn total(&self, i: i32) -> Result<size_t>

C++ default parameters

• i: -1

pub fn typ(&self, i: i32) -> Result<i32>

C++ default parameters

• i: -1

pub fn depth(&self, i: i32) -> Result<i32>

C++ default parameters

• i: -1

pub fn channels(&self, i: i32) -> Result<i32>

C++ default parameters

• i: -1

pub fn is_continuous(&self, i: i32) -> Result<bool>

C++ default parameters

• i: -1

pub fn is_submatrix(&self, i: i32) -> Result<bool>

C++ default parameters

• i: -1

pub fn empty(&self) -> Result<bool>

pub fn copy_to(&self, arr: &mut dyn ToOutputArray) -> Result<()>

pub fn copy_to_masked(
    &self,
    arr: &mut dyn ToOutputArray,
    mask: &dyn ToInputArray
) -> Result<()>

pub fn offset(&self, i: i32) -> Result<size_t>

C++ default parameters

• i: -1

pub fn step(&self, i: i32) -> Result<size_t>

C++ default parameters

• i: -1

pub fn is_mat(&self) -> Result<bool>

pub fn is_umat(&self) -> Result<bool>

pub fn is_mat_vector(&self) -> Result<bool>

pub fn is_umat_vector(&self) -> Result<bool>

pub fn is_matx(&self) -> Result<bool>

pub fn is_vector(&self) -> Result<bool>

pub fn is_gpu_mat(&self) -> Result<bool>

pub fn is_gpu_mat_vector(&self) -> Result<bool>

Loading content...

Implementors

impl _InputArrayTrait for _InputArray

pub fn as_raw__InputArray(&self) -> *const c_void

pub fn as_raw_mut__InputArray(&mut self) -> *mut c_void

impl _InputArrayTrait for _InputOutputArray

pub fn as_raw__InputArray(&self) -> *const c_void

pub fn as_raw_mut__InputArray(&mut self) -> *mut c_void

impl _InputArrayTrait for _OutputArray

pub fn as_raw__InputArray(&self) -> *const c_void

pub fn as_raw_mut__InputArray(&mut self) -> *mut c_void

Loading content...