[−][src]Struct opencv::core::_InputArray
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).
Implementations
impl _InputArray
[src]
pub fn as_raw__InputArray(&self) -> *const c_void
[src]
pub fn as_raw_mut__InputArray(&mut self) -> *mut c_void
[src]
impl _InputArray
[src]
pub fn default() -> Result<_InputArray>
[src]
pub fn new(_flags: i32, _obj: *mut c_void) -> Result<_InputArray>
[src]
pub fn from_mat(m: &Mat) -> Result<_InputArray>
[src]
pub fn from_matexpr(expr: &MatExpr) -> Result<_InputArray>
[src]
pub fn from_mat_vec(vec: &Vector<Mat>) -> Result<_InputArray>
[src]
pub fn from_bool_vec(vec: &Vector<bool>) -> Result<_InputArray>
[src]
pub fn from_f64(val: &f64) -> Result<_InputArray>
[src]
pub fn from_umat(um: &UMat) -> Result<_InputArray>
[src]
pub fn from_umat_vec(umv: &Vector<UMat>) -> Result<_InputArray>
[src]
Trait Implementations
impl Boxed for _InputArray
[src]
unsafe fn from_raw(ptr: *mut c_void) -> Self
[src]
fn into_raw(self) -> *mut c_void
[src]
fn as_raw(&self) -> *const c_void
[src]
fn as_raw_mut(&mut self) -> *mut c_void
[src]
impl Drop for _InputArray
[src]
impl Send for _InputArray
[src]
impl _InputArrayTrait for _InputArray
[src]
fn as_raw__InputArray(&self) -> *const c_void
[src]
fn as_raw_mut__InputArray(&mut self) -> *mut c_void
[src]
fn get_mat(&self, idx: i32) -> Result<Mat>
[src]
fn get_mat_(&self, idx: i32) -> Result<Mat>
[src]
fn get_umat(&self, idx: i32) -> Result<UMat>
[src]
fn get_mat_vector(&self, mv: &mut Vector<Mat>) -> Result<()>
[src]
fn get_umat_vector(&self, umv: &mut Vector<UMat>) -> Result<()>
[src]
fn get_flags(&self) -> Result<i32>
[src]
fn get_obj(&self) -> Result<*mut c_void>
[src]
fn get_sz(&self) -> Result<Size>
[src]
fn kind(&self) -> Result<_InputArray_KindFlag>
[src]
fn dims(&self, i: i32) -> Result<i32>
[src]
fn cols(&self, i: i32) -> Result<i32>
[src]
fn rows(&self, i: i32) -> Result<i32>
[src]
fn size(&self, i: i32) -> Result<Size>
[src]
fn sizend(&self, sz: &mut i32, i: i32) -> Result<i32>
[src]
fn same_size(&self, arr: &dyn ToInputArray) -> Result<bool>
[src]
fn total(&self, i: i32) -> Result<size_t>
[src]
fn typ(&self, i: i32) -> Result<i32>
[src]
fn depth(&self, i: i32) -> Result<i32>
[src]
fn channels(&self, i: i32) -> Result<i32>
[src]
fn is_continuous(&self, i: i32) -> Result<bool>
[src]
fn is_submatrix(&self, i: i32) -> Result<bool>
[src]
fn empty(&self) -> Result<bool>
[src]
fn copy_to(&self, arr: &mut dyn ToOutputArray) -> Result<()>
[src]
fn copy_to_with_mask(
&self,
arr: &mut dyn ToOutputArray,
mask: &dyn ToInputArray
) -> Result<()>
[src]
&self,
arr: &mut dyn ToOutputArray,
mask: &dyn ToInputArray
) -> Result<()>
fn offset(&self, i: i32) -> Result<size_t>
[src]
fn step(&self, i: i32) -> Result<size_t>
[src]
fn is_mat(&self) -> Result<bool>
[src]
fn is_umat(&self) -> Result<bool>
[src]
fn is_mat_vector(&self) -> Result<bool>
[src]
fn is_umat_vector(&self) -> Result<bool>
[src]
fn is_matx(&self) -> Result<bool>
[src]
fn is_vector(&self) -> Result<bool>
[src]
fn is_gpu_mat(&self) -> Result<bool>
[src]
fn is_gpu_mat_vector(&self) -> Result<bool>
[src]
Auto Trait Implementations
impl RefUnwindSafe for _InputArray
impl !Sync for _InputArray
impl Unpin for _InputArray
impl UnwindSafe for _InputArray
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,