[−][src]Struct opencv::core::Vector

pub struct Vector<T: VectorElement> where
    Self: VectorExtern<T>,  { /* fields omitted */ }

Wrapper for C++ std::vector

Implementations

`impl Vector<DMatch>`[src]

`pub fn as_raw_VectorOfDMatch(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfDMatch(&mut self) -> *mut c_void`[src]

`impl Vector<KeyPoint>`[src]

`pub fn as_raw_VectorOfKeyPoint(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfKeyPoint(&mut self) -> *mut c_void`[src]

`impl Vector<Mat>`[src]

`pub fn as_raw_VectorOfMat(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfMat(&mut self) -> *mut c_void`[src]

`impl Vector<PlatformInfo>`[src]

`pub fn as_raw_VectorOfPlatformInfo(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPlatformInfo(&mut self) -> *mut c_void`[src]

`impl Vector<Point_<i32>>`[src]

`pub fn as_raw_VectorOfPoint(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPoint(&mut self) -> *mut c_void`[src]

`impl Vector<Point_<f64>>`[src]

`pub fn as_raw_VectorOfPoint2d(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPoint2d(&mut self) -> *mut c_void`[src]

`impl Vector<Point_<f32>>`[src]

`pub fn as_raw_VectorOfPoint2f(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPoint2f(&mut self) -> *mut c_void`[src]

`impl Vector<Point3_<f64>>`[src]

`pub fn as_raw_VectorOfPoint3d(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPoint3d(&mut self) -> *mut c_void`[src]

`impl Vector<Point3_<f32>>`[src]

`pub fn as_raw_VectorOfPoint3f(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPoint3f(&mut self) -> *mut c_void`[src]

`impl Vector<Point3_<i32>>`[src]

`pub fn as_raw_VectorOfPoint3i(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPoint3i(&mut self) -> *mut c_void`[src]

`impl Vector<Range>`[src]

`pub fn as_raw_VectorOfRange(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfRange(&mut self) -> *mut c_void`[src]

`impl Vector<Rect_<i32>>`[src]

`pub fn as_raw_VectorOfRect(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfRect(&mut self) -> *mut c_void`[src]

`impl Vector<Rect_<f64>>`[src]

`pub fn as_raw_VectorOfRect2d(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfRect2d(&mut self) -> *mut c_void`[src]

`impl Vector<RotatedRect>`[src]

`pub fn as_raw_VectorOfRotatedRect(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfRotatedRect(&mut self) -> *mut c_void`[src]

`impl Vector<Scalar_<f64>>`[src]

`pub fn as_raw_VectorOfScalar(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfScalar(&mut self) -> *mut c_void`[src]

`impl Vector<Size_<i32>>`[src]

`pub fn as_raw_VectorOfSize(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfSize(&mut self) -> *mut c_void`[src]

`impl Vector<String>`[src]

`pub fn as_raw_VectorOfString(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfString(&mut self) -> *mut c_void`[src]

`impl Vector<UMat>`[src]

`pub fn as_raw_VectorOfUMat(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfUMat(&mut self) -> *mut c_void`[src]

`impl Vector<Vec2<i32>>`[src]

`pub fn as_raw_VectorOfVec2i(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec2i(&mut self) -> *mut c_void`[src]

`impl Vector<Vec3<f64>>`[src]

`pub fn as_raw_VectorOfVec3d(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec3d(&mut self) -> *mut c_void`[src]

`impl Vector<Vec3<f32>>`[src]

`pub fn as_raw_VectorOfVec3f(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec3f(&mut self) -> *mut c_void`[src]

`impl Vector<Vec3<i32>>`[src]

`pub fn as_raw_VectorOfVec3i(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec3i(&mut self) -> *mut c_void`[src]

`impl Vector<Vec4<f32>>`[src]

`pub fn as_raw_VectorOfVec4f(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec4f(&mut self) -> *mut c_void`[src]

`impl Vector<Vec4<i32>>`[src]

`pub fn as_raw_VectorOfVec4i(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec4i(&mut self) -> *mut c_void`[src]

`impl Vector<Vec6<f32>>`[src]

`pub fn as_raw_VectorOfVec6f(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec6f(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<DMatch>>`[src]

`pub fn as_raw_VectorOfVectorOfDMatch(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfDMatch(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<KeyPoint>>`[src]

`pub fn as_raw_VectorOfVectorOfKeyPoint(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfKeyPoint(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<Mat>>`[src]

`pub fn as_raw_VectorOfVectorOfMat(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfMat(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<Point_<i32>>>`[src]

`pub fn as_raw_VectorOfVectorOfPoint(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfPoint(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<Point_<f32>>>`[src]

`pub fn as_raw_VectorOfVectorOfPoint2f(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfPoint2f(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<Point3_<f64>>>`[src]

`pub fn as_raw_VectorOfVectorOfPoint3d(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfPoint3d(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<Point3_<f32>>>`[src]

`pub fn as_raw_VectorOfVectorOfPoint3f(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfPoint3f(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<Point3_<i32>>>`[src]

`pub fn as_raw_VectorOfVectorOfPoint3i(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfPoint3i(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<Range>>`[src]

`pub fn as_raw_VectorOfVectorOfRange(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfRange(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<Vec2<i32>>>`[src]

`pub fn as_raw_VectorOfVectorOfVec2i(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfVec2i(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<f64>>`[src]

`pub fn as_raw_VectorOfVectorOff64(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOff64(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<i32>>`[src]

`pub fn as_raw_VectorOfVectorOfi32(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfi32(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<i8>>`[src]

`pub fn as_raw_VectorOfVectorOfi8(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfi8(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<u8>>`[src]

`pub fn as_raw_VectorOfVectorOfu8(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfu8(&mut self) -> *mut c_void`[src]

`impl Vector<bool>`[src]

`pub fn as_raw_VectorOfbool(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfbool(&mut self) -> *mut c_void`[src]

`impl Vector<f32>`[src]

`pub fn as_raw_VectorOff32(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOff32(&mut self) -> *mut c_void`[src]

`impl Vector<f64>`[src]

`pub fn as_raw_VectorOff64(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOff64(&mut self) -> *mut c_void`[src]

`impl Vector<i32>`[src]

`pub fn as_raw_VectorOfi32(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfi32(&mut self) -> *mut c_void`[src]

`impl Vector<i8>`[src]

`pub fn as_raw_VectorOfi8(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfi8(&mut self) -> *mut c_void`[src]

`impl Vector<usize>`[src]

`pub fn as_raw_VectorOfsize_t(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfsize_t(&mut self) -> *mut c_void`[src]

`impl Vector<u8>`[src]

`pub fn as_raw_VectorOfu8(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfu8(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<i32>>`[src]

`pub fn as_raw_VectorOfMatShape(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfMatShape(&mut self) -> *mut c_void`[src]

`impl Vector<Ptr<BackendNode>>`[src]

`pub fn as_raw_VectorOfPtrOfBackendNode(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPtrOfBackendNode(&mut self) -> *mut c_void`[src]

`impl Vector<Ptr<dyn BackendWrapper + 'static>>`[src]

`pub fn as_raw_VectorOfPtrOfBackendWrapper(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPtrOfBackendWrapper(&mut self) -> *mut c_void`[src]

`impl Vector<Ptr<Layer>>`[src]

`pub fn as_raw_VectorOfPtrOfLayer(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPtrOfLayer(&mut self) -> *mut c_void`[src]

`impl Vector<Target>`[src]

`pub fn as_raw_VectorOfTarget(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfTarget(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<Vector<i32>>>`[src]

`pub fn as_raw_VectorOfVectorOfMatShape(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfMatShape(&mut self) -> *mut c_void`[src]

`impl Vector<DPMDetector_ObjectDetection>`[src]

`pub fn as_raw_VectorOfDPMDetector_ObjectDetection(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfDPMDetector_ObjectDetection(&mut self) -> *mut c_void`[src]

`impl Vector<FacemarkAAM_Config>`[src]

`pub fn as_raw_VectorOfFacemarkAAM_Config(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfFacemarkAAM_Config(&mut self) -> *mut c_void`[src]

`impl Vector<FacemarkAAM_Model_Texture>`[src]

`pub fn as_raw_VectorOfFacemarkAAM_Model_Texture(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfFacemarkAAM_Model_Texture(&mut self) -> *mut c_void`[src]

`impl Vector<FlannIndexType>`[src]

`pub fn as_raw_VectorOfFlannIndexType(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfFlannIndexType(&mut self) -> *mut c_void`[src]

`impl Vector<KeyLine>`[src]

`pub fn as_raw_VectorOfKeyLine(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfKeyLine(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<KeyLine>>`[src]

`pub fn as_raw_VectorOfVectorOfKeyLine(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfKeyLine(&mut self) -> *mut c_void`[src]

`impl Vector<DTrees_Node>`[src]

`pub fn as_raw_VectorOfDTrees_Node(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfDTrees_Node(&mut self) -> *mut c_void`[src]

`impl Vector<DTrees_Split>`[src]

`pub fn as_raw_VectorOfDTrees_Split(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfDTrees_Split(&mut self) -> *mut c_void`[src]

`impl Vector<DetectionBasedTracker_ExtObject>`[src]

`pub fn as_raw_VectorOfDetectionBasedTracker_ExtObject(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfDetectionBasedTracker_ExtObject( &mut self ) -> *mut c_void`[src]

`impl Vector<DetectionROI>`[src]

`pub fn as_raw_VectorOfDetectionROI(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfDetectionROI(&mut self) -> *mut c_void`[src]

`impl Vector<Detail_CameraParams>`[src]

`pub fn as_raw_VectorOfDetail_CameraParams(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfDetail_CameraParams(&mut self) -> *mut c_void`[src]

`impl Vector<Detail_ImageFeatures>`[src]

`pub fn as_raw_VectorOfDetail_ImageFeatures(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfDetail_ImageFeatures(&mut self) -> *mut c_void`[src]

`impl Vector<Detail_MatchesInfo>`[src]

`pub fn as_raw_VectorOfDetail_MatchesInfo(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfDetail_MatchesInfo(&mut self) -> *mut c_void`[src]

`impl Vector<Ptr<Pose3D>>`[src]

`pub fn as_raw_VectorOfPose3DPtr(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPose3DPtr(&mut self) -> *mut c_void`[src]

`impl Vector<ERStat>`[src]

`pub fn as_raw_VectorOfERStat(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfERStat(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<ERStat>>`[src]

`pub fn as_raw_VectorOfVectorOfERStat(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfERStat(&mut self) -> *mut c_void`[src]

`impl Vector<VideoCapture>`[src]

`pub fn as_raw_VectorOfVideoCapture(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVideoCapture(&mut self) -> *mut c_void`[src]

`impl Vector<VideoCaptureAPIs>`[src]

`pub fn as_raw_VectorOfVideoCaptureAPIs(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVideoCaptureAPIs(&mut self) -> *mut c_void`[src]

`impl Vector<Elliptic_KeyPoint>`[src]

`pub fn as_raw_VectorOfElliptic_KeyPoint(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfElliptic_KeyPoint(&mut self) -> *mut c_void`[src]

`impl<T: VectorElement> Vector<T> where Self: VectorExtern<T>,` [src]

`pub fn new() -> Self`[src]

Create a new Vector

`pub fn with_capacity(capacity: size_t) -> Self`[src]

Create a Vector with pre-defined capacity

`pub fn len(&self) -> size_t`[src]

Return Vector length

`pub fn is_empty(&self) -> bool`[src]

Return true if Vector is empty

`pub fn capacity(&self) -> size_t`[src]

Return Vector current capacity

`pub fn shrink_to_fit(&mut self)`[src]

Free extra capacity

`pub fn reserve(&mut self, additional: size_t)`[src]

Reserve capacity for additional new elements

`pub fn clear(&mut self)`[src]

Remove all elements

`pub fn remove(&mut self, index: size_t) -> Result<()>`[src]

Remove the element at the specified index

`pub fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>`[src]

Swap 2 elements in the Vector

`pub fn get(&self, index: size_t) -> Result<T>`[src]

Get element at the specified index

`pub unsafe fn get_unchecked(&self, index: size_t) -> T`[src]

Same as get() but without bounds checking

`pub fn iter(&self) -> VectorRefIterator<T>`[src]

`pub fn to_slice(&self) -> &[T] where Self: VectorExternCopyNonBool<T>,` [src]

`pub fn to_vec(&self) -> Vec<T>`[src]

Trait Implementations

`impl<T: VectorElement> Boxed for Vector<T> where Self: VectorExtern<T>,` [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<T: VectorElement> Drop for Vector<T> where Self: VectorExtern<T>,` [src]

`fn drop(&mut self)`[src]

`impl<T: VectorElement> IntoIterator for Vector<T> where Vector<T>: VectorExtern<T>,` [src]

`type Item = T`

The type of the elements being iterated over.

`type IntoIter = VectorIterator<T>`

Which kind of iterator are we turning this into?

`fn into_iter(self) -> Self::IntoIter`[src]

`impl<'i, T: VectorElement> IntoIterator for &'i Vector<T> where Vector<T>: VectorExtern<T>,` [src]

`type Item = T`

The type of the elements being iterated over.

`type IntoIter = VectorRefIterator<'i, T>`

Which kind of iterator are we turning this into?

`fn into_iter(self) -> Self::IntoIter`[src]

`impl Send for Vector<DMatch>`[src]

`impl Send for Vector<KeyPoint>`[src]

`impl Send for Vector<Range>`[src]

`impl Send for Vector<Rect>`[src]

`impl Send for Vector<Rect2d>`[src]

`impl Send for Vector<RotatedRect>`[src]

`impl Send for Vector<Scalar>`[src]

`impl Send for Vector<Size>`[src]

`impl Send for Vector<String>`[src]

`impl Send for Vector<UMat>`[src]

`impl Send for Vector<Vec2i>`[src]

`impl Send for Vector<Vec3d>`[src]

`impl Send for Vector<Mat>`[src]

`impl Send for Vector<Vec3f>`[src]

`impl Send for Vector<Vec3i>`[src]

`impl Send for Vector<Vec4f>`[src]

`impl Send for Vector<Vec4i>`[src]

`impl Send for Vector<Vec6f>`[src]

`impl Send for Vector<Vector<DMatch>>`[src]

`impl Send for Vector<Vector<KeyPoint>>`[src]

`impl Send for Vector<Vector<Mat>>`[src]

`impl Send for Vector<Vector<Point>>`[src]

`impl Send for Vector<Vector<Point2f>>`[src]

`impl Send for Vector<PlatformInfo>`[src]

`impl Send for Vector<Vector<Point3d>>`[src]

`impl Send for Vector<Vector<Point3f>>`[src]

`impl Send for Vector<Vector<Point3i>>`[src]

`impl Send for Vector<Vector<Range>>`[src]

`impl Send for Vector<Vector<Vec2i>>`[src]

`impl Send for Vector<Vector<f64>>`[src]

`impl Send for Vector<Vector<i32>>`[src]

`impl Send for Vector<Vector<i8>>`[src]

`impl Send for Vector<Vector<u8>>`[src]

`impl Send for Vector<bool>`[src]

`impl Send for Vector<Point>`[src]

`impl Send for Vector<f32>`[src]

`impl Send for Vector<f64>`[src]

`impl Send for Vector<i32>`[src]

`impl Send for Vector<i8>`[src]

`impl Send for Vector<size_t>`[src]

`impl Send for Vector<u8>`[src]

`impl Send for Vector<Ptr<BackendNode>>`[src]

`impl Send for Vector<Ptr<dyn BackendWrapper>>`[src]

`impl Send for Vector<Ptr<Layer>>`[src]

`impl Send for Vector<Target>`[src]

`impl Send for Vector<Point2d>`[src]

`impl Send for Vector<Vector<MatShape>>`[src]

`impl Send for Vector<DPMDetector_ObjectDetection>`[src]

`impl Send for Vector<FacemarkAAM_Config>`[src]

`impl Send for Vector<FacemarkAAM_Model_Texture>`[src]

`impl Send for Vector<FlannIndexType>`[src]

`impl Send for Vector<KeyLine>`[src]

`impl Send for Vector<Vector<KeyLine>>`[src]

`impl Send for Vector<DTrees_Node>`[src]

`impl Send for Vector<DTrees_Split>`[src]

`impl Send for Vector<DetectionBasedTracker_ExtObject>`[src]

`impl Send for Vector<Point2f>`[src]

`impl Send for Vector<DetectionROI>`[src]

`impl Send for Vector<Detail_CameraParams>`[src]

`impl Send for Vector<Detail_ImageFeatures>`[src]

`impl Send for Vector<Detail_MatchesInfo>`[src]

`impl Send for Vector<Pose3DPtr>`[src]

`impl Send for Vector<ERStat>`[src]

`impl Send for Vector<Vector<ERStat>>`[src]

`impl Send for Vector<VideoCapture>`[src]

`impl Send for Vector<VideoCaptureAPIs>`[src]

`impl Send for Vector<Elliptic_KeyPoint>`[src]

`impl Send for Vector<Point3d>`[src]

`impl Send for Vector<Point3f>`[src]

`impl Send for Vector<Point3i>`[src]

`impl<'i> VectorTrait<'i> for Vector<DMatch>`[src]

`type Arg = DMatch`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: DMatch)`[src]

`fn insert(&mut self, index: size_t, val: DMatch) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: DMatch) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: DMatch)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<KeyPoint>`[src]

`type Arg = KeyPoint`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: KeyPoint)`[src]

`fn insert(&mut self, index: size_t, val: KeyPoint) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: KeyPoint) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: KeyPoint)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Range>`[src]

`type Arg = Range`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Range)`[src]

`fn insert(&mut self, index: size_t, val: Range) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Range) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Range)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Rect>`[src]

`type Arg = Rect`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Rect)`[src]

`fn insert(&mut self, index: size_t, val: Rect) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Rect) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Rect)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Rect2d>`[src]

`type Arg = Rect2d`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Rect2d)`[src]

`fn insert(&mut self, index: size_t, val: Rect2d) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Rect2d) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Rect2d)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<RotatedRect>`[src]

`type Arg = RotatedRect`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: RotatedRect)`[src]

`fn insert(&mut self, index: size_t, val: RotatedRect) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: RotatedRect) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: RotatedRect)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Scalar>`[src]

`type Arg = Scalar`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Scalar)`[src]

`fn insert(&mut self, index: size_t, val: Scalar) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Scalar) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Scalar)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Size>`[src]

`type Arg = Size`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Size)`[src]

`fn insert(&mut self, index: size_t, val: Size) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Size) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Size)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<String>`[src]

`type Arg = &'i str`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: &str)`[src]

`fn insert(&mut self, index: size_t, val: &str) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: &str) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: &str)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<UMat>`[src]

`type Arg = UMat`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: UMat)`[src]

`fn insert(&mut self, index: size_t, val: UMat) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: UMat) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: UMat)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vec2i>`[src]

`type Arg = Vec2i`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vec2i)`[src]

`fn insert(&mut self, index: size_t, val: Vec2i) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vec2i) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vec2i)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vec3d>`[src]

`type Arg = Vec3d`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vec3d)`[src]

`fn insert(&mut self, index: size_t, val: Vec3d) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vec3d) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vec3d)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Mat>`[src]

`type Arg = Mat`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Mat)`[src]

`fn insert(&mut self, index: size_t, val: Mat) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Mat) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Mat)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vec3f>`[src]

`type Arg = Vec3f`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vec3f)`[src]

`fn insert(&mut self, index: size_t, val: Vec3f) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vec3f) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vec3f)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vec3i>`[src]

`type Arg = Vec3i`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vec3i)`[src]

`fn insert(&mut self, index: size_t, val: Vec3i) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vec3i) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vec3i)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vec4f>`[src]

`type Arg = Vec4f`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vec4f)`[src]

`fn insert(&mut self, index: size_t, val: Vec4f) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vec4f) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vec4f)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vec4i>`[src]

`type Arg = Vec4i`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vec4i)`[src]

`fn insert(&mut self, index: size_t, val: Vec4i) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vec4i) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vec4i)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vec6f>`[src]

`type Arg = Vec6f`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vec6f)`[src]

`fn insert(&mut self, index: size_t, val: Vec6f) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vec6f) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vec6f)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<DMatch>>`[src]

`type Arg = Vector<DMatch>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<DMatch>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<DMatch>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<DMatch>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<DMatch>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<KeyPoint>>`[src]

`type Arg = Vector<KeyPoint>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<KeyPoint>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<KeyPoint>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<KeyPoint>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<KeyPoint>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<Mat>>`[src]

`type Arg = Vector<Mat>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<Mat>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<Mat>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<Mat>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Mat>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<Point>>`[src]

`type Arg = Vector<Point>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<Point>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<Point>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<Point>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Point>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<Point2f>>`[src]

`type Arg = Vector<Point2f>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<Point2f>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<Point2f>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<Point2f>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Point2f>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<PlatformInfo>`[src]

`type Arg = PlatformInfo`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: PlatformInfo)`[src]

`fn insert(&mut self, index: size_t, val: PlatformInfo) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: PlatformInfo) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: PlatformInfo)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<Point3d>>`[src]

`type Arg = Vector<Point3d>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<Point3d>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<Point3d>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<Point3d>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Point3d>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<Point3f>>`[src]

`type Arg = Vector<Point3f>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<Point3f>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<Point3f>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<Point3f>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Point3f>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<Point3i>>`[src]

`type Arg = Vector<Point3i>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<Point3i>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<Point3i>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<Point3i>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Point3i>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<Range>>`[src]

`type Arg = Vector<Range>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<Range>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<Range>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<Range>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Range>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<Vec2i>>`[src]

`type Arg = Vector<Vec2i>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<Vec2i>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<Vec2i>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<Vec2i>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Vec2i>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<f64>>`[src]

`type Arg = Vector<f64>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<f64>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<f64>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<f64>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<f64>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<i32>>`[src]

`type Arg = Vector<i32>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<i32>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<i32>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<i32>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<i32>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<i8>>`[src]

`type Arg = Vector<i8>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<i8>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<i8>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<i8>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<i8>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<u8>>`[src]

`type Arg = Vector<u8>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<u8>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<u8>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<u8>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<u8>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<bool>`[src]

`type Arg = bool`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: bool)`[src]

`fn insert(&mut self, index: size_t, val: bool) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: bool) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: bool)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Point>`[src]

`type Arg = Point`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Point)`[src]

`fn insert(&mut self, index: size_t, val: Point) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Point) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Point)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<f32>`[src]

`type Arg = f32`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: f32)`[src]

`fn insert(&mut self, index: size_t, val: f32) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: f32) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: f32)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<f64>`[src]

`type Arg = f64`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: f64)`[src]

`fn insert(&mut self, index: size_t, val: f64) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: f64) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: f64)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<i32>`[src]

`type Arg = i32`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: i32)`[src]

`fn insert(&mut self, index: size_t, val: i32) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: i32) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: i32)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<i8>`[src]

`type Arg = i8`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: i8)`[src]

`fn insert(&mut self, index: size_t, val: i8) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: i8) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: i8)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<size_t>`[src]

`type Arg = size_t`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: size_t)`[src]

`fn insert(&mut self, index: size_t, val: size_t) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: size_t) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: size_t)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<u8>`[src]

`type Arg = u8`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: u8)`[src]

`fn insert(&mut self, index: size_t, val: u8) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: u8) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: u8)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Ptr<BackendNode>>`[src]

`type Arg = Ptr<BackendNode>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Ptr<BackendNode>)`[src]

`fn insert(&mut self, index: size_t, val: Ptr<BackendNode>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Ptr<BackendNode>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Ptr<BackendNode>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Ptr<dyn BackendWrapper>>`[src]

`type Arg = Ptr<dyn BackendWrapper>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Ptr<dyn BackendWrapper>)`[src]

`fn insert(&mut self, index: size_t, val: Ptr<dyn BackendWrapper>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Ptr<dyn BackendWrapper>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Ptr<dyn BackendWrapper>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Ptr<Layer>>`[src]

`type Arg = Ptr<Layer>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Ptr<Layer>)`[src]

`fn insert(&mut self, index: size_t, val: Ptr<Layer>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Ptr<Layer>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Ptr<Layer>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Target>`[src]

`type Arg = Target`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Target)`[src]

`fn insert(&mut self, index: size_t, val: Target) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Target) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Target)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Point2d>`[src]

`type Arg = Point2d`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Point2d)`[src]

`fn insert(&mut self, index: size_t, val: Point2d) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Point2d) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Point2d)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<MatShape>>`[src]

`type Arg = Vector<MatShape>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<MatShape>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<MatShape>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<MatShape>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<MatShape>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<DPMDetector_ObjectDetection>`[src]

`type Arg = DPMDetector_ObjectDetection`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: DPMDetector_ObjectDetection)`[src]

`fn insert( &mut self, index: size_t, val: DPMDetector_ObjectDetection ) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: DPMDetector_ObjectDetection) -> Result<()>`[src]

`unsafe fn set_unchecked( &mut self, index: size_t, val: DPMDetector_ObjectDetection )`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<FacemarkAAM_Config>`[src]

`type Arg = FacemarkAAM_Config`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: FacemarkAAM_Config)`[src]

`fn insert(&mut self, index: size_t, val: FacemarkAAM_Config) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: FacemarkAAM_Config) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: FacemarkAAM_Config)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<FacemarkAAM_Model_Texture>`[src]

`type Arg = FacemarkAAM_Model_Texture`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: FacemarkAAM_Model_Texture)`[src]

`fn insert( &mut self, index: size_t, val: FacemarkAAM_Model_Texture ) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: FacemarkAAM_Model_Texture) -> Result<()>`[src]

`unsafe fn set_unchecked( &mut self, index: size_t, val: FacemarkAAM_Model_Texture )`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<FlannIndexType>`[src]

`type Arg = FlannIndexType`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: FlannIndexType)`[src]

`fn insert(&mut self, index: size_t, val: FlannIndexType) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: FlannIndexType) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: FlannIndexType)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<KeyLine>`[src]

`type Arg = KeyLine`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: KeyLine)`[src]

`fn insert(&mut self, index: size_t, val: KeyLine) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: KeyLine) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: KeyLine)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<KeyLine>>`[src]

`type Arg = Vector<KeyLine>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<KeyLine>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<KeyLine>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<KeyLine>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<KeyLine>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<DTrees_Node>`[src]

`type Arg = DTrees_Node`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: DTrees_Node)`[src]

`fn insert(&mut self, index: size_t, val: DTrees_Node) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: DTrees_Node) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: DTrees_Node)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<DTrees_Split>`[src]

`type Arg = DTrees_Split`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: DTrees_Split)`[src]

`fn insert(&mut self, index: size_t, val: DTrees_Split) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: DTrees_Split) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: DTrees_Split)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<DetectionBasedTracker_ExtObject>`[src]

`type Arg = DetectionBasedTracker_ExtObject`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: DetectionBasedTracker_ExtObject)`[src]

`fn insert( &mut self, index: size_t, val: DetectionBasedTracker_ExtObject ) -> Result<()>`[src]

`fn set( &mut self, index: size_t, val: DetectionBasedTracker_ExtObject ) -> Result<()>`[src]

`unsafe fn set_unchecked( &mut self, index: size_t, val: DetectionBasedTracker_ExtObject )`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Point2f>`[src]

`type Arg = Point2f`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Point2f)`[src]

`fn insert(&mut self, index: size_t, val: Point2f) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Point2f) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Point2f)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<DetectionROI>`[src]

`type Arg = DetectionROI`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: DetectionROI)`[src]

`fn insert(&mut self, index: size_t, val: DetectionROI) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: DetectionROI) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: DetectionROI)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Detail_CameraParams>`[src]

`type Arg = Detail_CameraParams`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Detail_CameraParams)`[src]

`fn insert(&mut self, index: size_t, val: Detail_CameraParams) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Detail_CameraParams) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Detail_CameraParams)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Detail_ImageFeatures>`[src]

`type Arg = Detail_ImageFeatures`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Detail_ImageFeatures)`[src]

`fn insert(&mut self, index: size_t, val: Detail_ImageFeatures) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Detail_ImageFeatures) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Detail_ImageFeatures)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Detail_MatchesInfo>`[src]

`type Arg = Detail_MatchesInfo`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Detail_MatchesInfo)`[src]

`fn insert(&mut self, index: size_t, val: Detail_MatchesInfo) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Detail_MatchesInfo) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Detail_MatchesInfo)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Pose3DPtr>`[src]

`type Arg = Pose3DPtr`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Pose3DPtr)`[src]

`fn insert(&mut self, index: size_t, val: Pose3DPtr) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Pose3DPtr) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Pose3DPtr)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<ERStat>`[src]

`type Arg = ERStat`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: ERStat)`[src]

`fn insert(&mut self, index: size_t, val: ERStat) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: ERStat) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: ERStat)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Vector<ERStat>>`[src]

`type Arg = Vector<ERStat>`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Vector<ERStat>)`[src]

`fn insert(&mut self, index: size_t, val: Vector<ERStat>) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Vector<ERStat>) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<ERStat>)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<VideoCapture>`[src]

`type Arg = VideoCapture`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: VideoCapture)`[src]

`fn insert(&mut self, index: size_t, val: VideoCapture) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: VideoCapture) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: VideoCapture)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<VideoCaptureAPIs>`[src]

`type Arg = VideoCaptureAPIs`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: VideoCaptureAPIs)`[src]

`fn insert(&mut self, index: size_t, val: VideoCaptureAPIs) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: VideoCaptureAPIs) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: VideoCaptureAPIs)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Elliptic_KeyPoint>`[src]

`type Arg = Elliptic_KeyPoint`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Elliptic_KeyPoint)`[src]

`fn insert(&mut self, index: size_t, val: Elliptic_KeyPoint) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Elliptic_KeyPoint) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Elliptic_KeyPoint)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Point3d>`[src]

`type Arg = Point3d`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Point3d)`[src]

`fn insert(&mut self, index: size_t, val: Point3d) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Point3d) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Point3d)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Point3f>`[src]

`type Arg = Point3f`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Point3f)`[src]

`fn insert(&mut self, index: size_t, val: Point3f) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Point3f) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Point3f)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

`impl<'i> VectorTrait<'i> for Vector<Point3i>`[src]

`type Arg = Point3i`

`fn with_capacity(capacity: size_t) -> Self`[src]

`fn push(&mut self, val: Point3i)`[src]

`fn insert(&mut self, index: size_t, val: Point3i) -> Result<()>`[src]

`fn set(&mut self, index: size_t, val: Point3i) -> Result<()>`[src]

`unsafe fn set_unchecked(&mut self, index: size_t, val: Point3i)`[src]

`fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self`[src]

Auto Trait Implementations

`impl<T> RefUnwindSafe for Vector<T> where T: RefUnwindSafe,`

`impl<T> !Send for Vector<T>`

`impl<T> !Sync for Vector<T>`

`impl<T> Unpin for Vector<T> where T: Unpin,`

`impl<T> UnwindSafe for Vector<T> where T: UnwindSafe,`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl IntoIterator for I where I: Iterator,` [src]

`type Item = ::Item`

The type of the elements being iterated over.

`type IntoIter = I`

Which kind of iterator are we turning this into?

`fn into_iter(self) -> I`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

[−][src]Struct opencv::core::Vector

Implementations

impl Vector<DMatch>[src]

pub fn as_raw_VectorOfDMatch(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfDMatch(&mut self) -> *mut c_void[src]

impl Vector<KeyPoint>[src]

pub fn as_raw_VectorOfKeyPoint(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfKeyPoint(&mut self) -> *mut c_void[src]

impl Vector<Mat>[src]

pub fn as_raw_VectorOfMat(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfMat(&mut self) -> *mut c_void[src]

impl Vector<PlatformInfo>[src]

pub fn as_raw_VectorOfPlatformInfo(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfPlatformInfo(&mut self) -> *mut c_void[src]

impl Vector<Point_<i32>>[src]

pub fn as_raw_VectorOfPoint(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfPoint(&mut self) -> *mut c_void[src]

impl Vector<Point_<f64>>[src]

pub fn as_raw_VectorOfPoint2d(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfPoint2d(&mut self) -> *mut c_void[src]

impl Vector<Point_<f32>>[src]

pub fn as_raw_VectorOfPoint2f(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfPoint2f(&mut self) -> *mut c_void[src]

impl Vector<Point3_<f64>>[src]

pub fn as_raw_VectorOfPoint3d(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfPoint3d(&mut self) -> *mut c_void[src]

impl Vector<Point3_<f32>>[src]

pub fn as_raw_VectorOfPoint3f(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfPoint3f(&mut self) -> *mut c_void[src]

impl Vector<Point3_<i32>>[src]

pub fn as_raw_VectorOfPoint3i(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfPoint3i(&mut self) -> *mut c_void[src]

impl Vector<Range>[src]

pub fn as_raw_VectorOfRange(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfRange(&mut self) -> *mut c_void[src]

impl Vector<Rect_<i32>>[src]

pub fn as_raw_VectorOfRect(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfRect(&mut self) -> *mut c_void[src]

impl Vector<Rect_<f64>>[src]

pub fn as_raw_VectorOfRect2d(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfRect2d(&mut self) -> *mut c_void[src]

impl Vector<RotatedRect>[src]

pub fn as_raw_VectorOfRotatedRect(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfRotatedRect(&mut self) -> *mut c_void[src]

impl Vector<Scalar_<f64>>[src]

pub fn as_raw_VectorOfScalar(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfScalar(&mut self) -> *mut c_void[src]

impl Vector<Size_<i32>>[src]

pub fn as_raw_VectorOfSize(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfSize(&mut self) -> *mut c_void[src]

impl Vector<String>[src]

pub fn as_raw_VectorOfString(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfString(&mut self) -> *mut c_void[src]

impl Vector<UMat>[src]

pub fn as_raw_VectorOfUMat(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfUMat(&mut self) -> *mut c_void[src]

impl Vector<Vec2<i32>>[src]

pub fn as_raw_VectorOfVec2i(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfVec2i(&mut self) -> *mut c_void[src]

impl Vector<Vec3<f64>>[src]

pub fn as_raw_VectorOfVec3d(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfVec3d(&mut self) -> *mut c_void[src]

impl Vector<Vec3<f32>>[src]

pub fn as_raw_VectorOfVec3f(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfVec3f(&mut self) -> *mut c_void[src]

impl Vector<Vec3<i32>>[src]

pub fn as_raw_VectorOfVec3i(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfVec3i(&mut self) -> *mut c_void[src]

impl Vector<Vec4<f32>>[src]

pub fn as_raw_VectorOfVec4f(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfVec4f(&mut self) -> *mut c_void[src]

impl Vector<Vec4<i32>>[src]

pub fn as_raw_VectorOfVec4i(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfVec4i(&mut self) -> *mut c_void[src]

impl Vector<Vec6<f32>>[src]

pub fn as_raw_VectorOfVec6f(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfVec6f(&mut self) -> *mut c_void[src]

impl Vector<Vector<DMatch>>[src]

pub fn as_raw_VectorOfVectorOfDMatch(&self) -> *const c_void[src]

pub fn as_raw_mut_VectorOfVectorOfDMatch(&mut self) -> *mut c_void[src]

`impl Vector<DMatch>`[src]

`pub fn as_raw_VectorOfDMatch(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfDMatch(&mut self) -> *mut c_void`[src]

`impl Vector<KeyPoint>`[src]

`pub fn as_raw_VectorOfKeyPoint(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfKeyPoint(&mut self) -> *mut c_void`[src]

`impl Vector<Mat>`[src]

`pub fn as_raw_VectorOfMat(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfMat(&mut self) -> *mut c_void`[src]

`impl Vector<PlatformInfo>`[src]

`pub fn as_raw_VectorOfPlatformInfo(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPlatformInfo(&mut self) -> *mut c_void`[src]

`impl Vector<Point_<i32>>`[src]

`pub fn as_raw_VectorOfPoint(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPoint(&mut self) -> *mut c_void`[src]

`impl Vector<Point_<f64>>`[src]

`pub fn as_raw_VectorOfPoint2d(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPoint2d(&mut self) -> *mut c_void`[src]

`impl Vector<Point_<f32>>`[src]

`pub fn as_raw_VectorOfPoint2f(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPoint2f(&mut self) -> *mut c_void`[src]

`impl Vector<Point3_<f64>>`[src]

`pub fn as_raw_VectorOfPoint3d(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPoint3d(&mut self) -> *mut c_void`[src]

`impl Vector<Point3_<f32>>`[src]

`pub fn as_raw_VectorOfPoint3f(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPoint3f(&mut self) -> *mut c_void`[src]

`impl Vector<Point3_<i32>>`[src]

`pub fn as_raw_VectorOfPoint3i(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfPoint3i(&mut self) -> *mut c_void`[src]

`impl Vector<Range>`[src]

`pub fn as_raw_VectorOfRange(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfRange(&mut self) -> *mut c_void`[src]

`impl Vector<Rect_<i32>>`[src]

`pub fn as_raw_VectorOfRect(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfRect(&mut self) -> *mut c_void`[src]

`impl Vector<Rect_<f64>>`[src]

`pub fn as_raw_VectorOfRect2d(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfRect2d(&mut self) -> *mut c_void`[src]

`impl Vector<RotatedRect>`[src]

`pub fn as_raw_VectorOfRotatedRect(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfRotatedRect(&mut self) -> *mut c_void`[src]

`impl Vector<Scalar_<f64>>`[src]

`pub fn as_raw_VectorOfScalar(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfScalar(&mut self) -> *mut c_void`[src]

`impl Vector<Size_<i32>>`[src]

`pub fn as_raw_VectorOfSize(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfSize(&mut self) -> *mut c_void`[src]

`impl Vector<String>`[src]

`pub fn as_raw_VectorOfString(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfString(&mut self) -> *mut c_void`[src]

`impl Vector<UMat>`[src]

`pub fn as_raw_VectorOfUMat(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfUMat(&mut self) -> *mut c_void`[src]

`impl Vector<Vec2<i32>>`[src]

`pub fn as_raw_VectorOfVec2i(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec2i(&mut self) -> *mut c_void`[src]

`impl Vector<Vec3<f64>>`[src]

`pub fn as_raw_VectorOfVec3d(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec3d(&mut self) -> *mut c_void`[src]

`impl Vector<Vec3<f32>>`[src]

`pub fn as_raw_VectorOfVec3f(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec3f(&mut self) -> *mut c_void`[src]

`impl Vector<Vec3<i32>>`[src]

`pub fn as_raw_VectorOfVec3i(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec3i(&mut self) -> *mut c_void`[src]

`impl Vector<Vec4<f32>>`[src]

`pub fn as_raw_VectorOfVec4f(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec4f(&mut self) -> *mut c_void`[src]

`impl Vector<Vec4<i32>>`[src]

`pub fn as_raw_VectorOfVec4i(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec4i(&mut self) -> *mut c_void`[src]

`impl Vector<Vec6<f32>>`[src]

`pub fn as_raw_VectorOfVec6f(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVec6f(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<DMatch>>`[src]

`pub fn as_raw_VectorOfVectorOfDMatch(&self) -> *const c_void`[src]

`pub fn as_raw_mut_VectorOfVectorOfDMatch(&mut self) -> *mut c_void`[src]

`impl Vector<Vector<KeyPoint>>`[src]

`pub fn as_raw_VectorOfVectorOfKeyPoint(&self) -> *const c_void`[src]