Struct opencv::core::_InputArray
source · pub struct _InputArray { /* private fields */ }
Expand description
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§
source§impl _InputArray
impl _InputArray
pub fn default() -> Result<_InputArray>
pub unsafe fn new(_flags: i32, _obj: *mut c_void) -> Result<_InputArray>
pub fn from_mat(m: &impl MatTraitConst) -> Result<BoxedRef<'_, _InputArray>>
pub fn from_matexpr( expr: &impl MatExprTraitConst ) -> Result<BoxedRef<'_, _InputArray>>
pub fn from_mat_vec(vec: &Vector<Mat>) -> Result<BoxedRef<'_, _InputArray>>
pub fn from_bool_vec(vec: &Vector<bool>) -> Result<BoxedRef<'_, _InputArray>>
pub fn from_f64(val: &f64) -> Result<BoxedRef<'_, _InputArray>>
pub fn from_gpumat( d_mat: &impl GpuMatTraitConst ) -> Result<BoxedRef<'_, _InputArray>>
pub fn from_gpumat_vec( d_mat_array: &Vector<GpuMat> ) -> Result<BoxedRef<'_, _InputArray>>
pub fn from_opengl( buf: &impl BufferTraitConst ) -> Result<BoxedRef<'_, _InputArray>>
pub fn from_hostmem( cuda_mem: &impl HostMemTraitConst ) -> Result<BoxedRef<'_, _InputArray>>
pub fn from_umat(um: &impl UMatTraitConst) -> Result<BoxedRef<'_, _InputArray>>
pub fn from_umat_vec(umv: &Vector<UMat>) -> Result<BoxedRef<'_, _InputArray>>
pub fn from_byte_slice(vec: &[u8]) -> Result<BoxedRef<'_, _InputArray>>
Trait Implementations§
source§impl Boxed for _InputArray
impl Boxed for _InputArray
source§unsafe fn from_raw(
ptr: <_InputArray as OpenCVFromExtern>::ExternReceive
) -> Self
unsafe fn from_raw( ptr: <_InputArray as OpenCVFromExtern>::ExternReceive ) -> Self
source§fn into_raw(self) -> <_InputArray as OpenCVTypeExternContainer>::ExternSendMut
fn into_raw(self) -> <_InputArray as OpenCVTypeExternContainer>::ExternSendMut
source§fn as_raw(&self) -> <_InputArray as OpenCVTypeExternContainer>::ExternSend
fn as_raw(&self) -> <_InputArray as OpenCVTypeExternContainer>::ExternSend
source§fn as_raw_mut(
&mut self
) -> <_InputArray as OpenCVTypeExternContainer>::ExternSendMut
fn as_raw_mut( &mut self ) -> <_InputArray as OpenCVTypeExternContainer>::ExternSendMut
source§impl Debug for _InputArray
impl Debug for _InputArray
source§impl Drop for _InputArray
impl Drop for _InputArray
source§impl From<_InputOutputArray> for _InputArray
impl From<_InputOutputArray> for _InputArray
source§fn from(s: _InputOutputArray) -> Self
fn from(s: _InputOutputArray) -> Self
source§impl From<_OutputArray> for _InputArray
impl From<_OutputArray> for _InputArray
source§fn from(s: _OutputArray) -> Self
fn from(s: _OutputArray) -> Self
source§impl ToInputArray for _InputArray
impl ToInputArray for _InputArray
fn input_array(&self) -> Result<BoxedRef<'_, _InputArray>>
source§impl _InputArrayTrait for _InputArray
impl _InputArrayTrait for _InputArray
fn as_raw_mut__InputArray(&mut self) -> *mut c_void
source§impl _InputArrayTraitConst for _InputArray
impl _InputArrayTraitConst for _InputArray
fn as_raw__InputArray(&self) -> *const c_void
fn get_mat_vector(&self, mv: &mut Vector<Mat>) -> Result<()>
fn get_umat_vector(&self, umv: &mut Vector<UMat>) -> Result<()>
fn get_gpu_mat_vector(&self, gpumv: &mut Vector<GpuMat>) -> Result<()>
fn get_gpu_mat(&self) -> Result<GpuMat>
fn get_o_gl_buffer(&self) -> Result<Buffer>
fn get_flags(&self) -> Result<i32>
fn get_obj(&self) -> Result<*mut c_void>
fn get_sz(&self) -> Result<Size>
fn kind(&self) -> Result<_InputArray_KindFlag>
fn same_size(&self, arr: &impl ToInputArray) -> Result<bool>
fn empty(&self) -> Result<bool>
fn copy_to(&self, arr: &mut impl ToOutputArray) -> Result<()>
fn copy_to_masked( &self, arr: &mut impl ToOutputArray, mask: &impl ToInputArray ) -> Result<()>
fn is_mat(&self) -> Result<bool>
fn is_umat(&self) -> Result<bool>
fn is_mat_vector(&self) -> Result<bool>
fn is_umat_vector(&self) -> Result<bool>
fn is_matx(&self) -> Result<bool>
fn is_vector(&self) -> Result<bool>
fn is_gpu_mat(&self) -> Result<bool>
fn is_gpu_mat_vector(&self) -> Result<bool>
impl Send for _InputArray
Auto Trait Implementations§
impl Freeze for _InputArray
impl RefUnwindSafe for _InputArray
impl !Sync for _InputArray
impl Unpin for _InputArray
impl UnwindSafe for _InputArray
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<Mat> ModifyInplace for Matwhere
Mat: Boxed,
impl<Mat> ModifyInplace for Matwhere
Mat: Boxed,
source§unsafe fn modify_inplace<Res>(
&mut self,
f: impl FnOnce(&Mat, &mut Mat) -> Res
) -> Res
unsafe fn modify_inplace<Res>( &mut self, f: impl FnOnce(&Mat, &mut Mat) -> Res ) -> Res
Mat
or another similar object. By passing
a mutable reference to the Mat
to this function your closure will get called with the read reference and a write references
to the same Mat
. This is of course unsafe as it breaks the Rust aliasing rules, but it might be useful for some performance
sensitive operations. One example of an OpenCV function that allows such in-place modification is imgproc::threshold
. Read more