Trait opencv::prelude::Vector

pub trait Vector<'i> {
    type Storage;
    type Arg;
    fn new() -> Self
    where
        Self: Sized;
    fn len(&self) -> size_t;
    fn is_empty(&self) -> bool;
    fn capacity(&self) -> size_t;
    fn shrink_to_fit(&mut self);
    fn reserve(&mut self, additional: size_t);
    fn clear(&mut self);
    fn push(&mut self, val: Self::Arg);
    fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>;
    fn remove(&mut self, index: size_t) -> Result<()>;
    fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>;
    fn get(&self, index: size_t) -> Result<Self::Storage>;
    unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage;
    fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>;
    unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg);

    fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self
    where
        Self: Sized,
    { ... }
    fn with_capacity(capacity: size_t) -> Self
    where
        Self: Sized,
    { ... }
    fn to_vec(&self) -> Vec<Self::Storage> { ... }
}

Common interface for all C++ vector types generated by the crate

You'll need to import this trait to use any of the C++ vector wrappers, usually imported as part of the prelude.

Associated Types

type Storage

type Arg

Loading content...

Required methods

fn new() -> Self where
    Self: Sized, 

Create a new Vector

fn len(&self) -> size_t

Return Vector length

fn is_empty(&self) -> bool

Return true if Vector is empty

fn capacity(&self) -> size_t

Return Vector current capacity

fn shrink_to_fit(&mut self)

Free extra capacity

fn reserve(&mut self, additional: size_t)

Reserve capacity for additional new elements

fn clear(&mut self)

Remove all elements

fn push(&mut self, val: Self::Arg)

Add new element

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

Insert a new element at the specified index

fn remove(&mut self, index: size_t) -> Result<()>

Remove the element at the specified index

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

Swaps 2 elements in the Vector

fn get(&self, index: size_t) -> Result<Self::Storage>

Get element at the specified index

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

Same as get() but without bounds checking

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

Set element at the specified index

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

Same as set() but without bounds checking

Loading content...

Provided methods

fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self where
    Self: Sized, 

Create a Vector from iterator

fn with_capacity(capacity: size_t) -> Self where
    Self: Sized, 

Create a Vector with pre-defined capacity

fn to_vec(&self) -> Vec<Self::Storage>

Convert to Rust Vec

Loading content...

Implementors

impl<'i> Vector<'i> for VectorOfDMatch

type Storage = DMatch

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = DMatch

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfDPMDetector_ObjectDetection

type Storage = DPMDetector_ObjectDetection

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = DPMDetector_ObjectDetection

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfDTrees_Node

type Storage = DTrees_Node

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = DTrees_Node

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfDTrees_Split

type Storage = DTrees_Split

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = DTrees_Split

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfDetail_CameraParams

type Storage = Detail_CameraParams

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Detail_CameraParams

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfDetail_ImageFeatures

type Storage = Detail_ImageFeatures

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Detail_ImageFeatures

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfDetail_MatchesInfo

type Storage = Detail_MatchesInfo

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Detail_MatchesInfo

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfDetectionBasedTracker_ExtObject

type Storage = DetectionBasedTracker_ExtObject

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = DetectionBasedTracker_ExtObject

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfDetectionROI

type Storage = DetectionROI

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = DetectionROI

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfERStat

type Storage = ERStat

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = ERStat

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfElliptic_KeyPoint

type Storage = Elliptic_KeyPoint

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Elliptic_KeyPoint

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfFacemarkAAM_Config

type Storage = FacemarkAAM_Config

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = FacemarkAAM_Config

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfFacemarkAAM_Model_Texture

type Storage = FacemarkAAM_Model_Texture

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = FacemarkAAM_Model_Texture

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfFlannIndexType

type Storage = FlannIndexType

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = FlannIndexType

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfKeyLine

type Storage = KeyLine

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = KeyLine

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfKeyPoint

type Storage = KeyPoint

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = KeyPoint

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfMat

type Storage = Mat

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Mat

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfMatShape

type Storage = MatShape

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = MatShape

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfPlatformInfo

type Storage = PlatformInfo

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = PlatformInfo

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfPoint

type Storage = Point

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Point

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfPoint2d

type Storage = Point2d

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Point2d

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfPoint2f

type Storage = Point2f

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Point2f

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfPoint3d

type Storage = Point3d

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Point3d

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfPoint3f

type Storage = Point3f

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Point3f

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfPoint3i

type Storage = Point3i

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Point3i

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfPose3DPtr

type Storage = Pose3DPtr

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Pose3DPtr

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfPtrOfBackendNode

type Storage = PtrOfBackendNode

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = PtrOfBackendNode

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfPtrOfBackendWrapper

type Storage = PtrOfBackendWrapper

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = PtrOfBackendWrapper

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfPtrOfLayer

type Storage = PtrOfLayer

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = PtrOfLayer

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfRange

type Storage = Range

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Range

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfRect

type Storage = Rect

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Rect

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfRect2d

type Storage = Rect2d

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Rect2d

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfRotatedRect

type Storage = RotatedRect

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = RotatedRect

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfScalar

type Storage = Scalar

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Scalar

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfSize

type Storage = Size

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Size

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfString

type Storage = String

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = &'i str

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfTarget

type Storage = Target

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Target

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfUMat

type Storage = UMat

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = UMat

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVec2i

type Storage = Vec2i

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Vec2i

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfVec3d

type Storage = Vec3d

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Vec3d

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfVec3f

type Storage = Vec3f

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Vec3f

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfVec3i

type Storage = Vec3i

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Vec3i

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfVec4f

type Storage = Vec4f

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Vec4f

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfVec4i

type Storage = Vec4i

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Vec4i

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfVec6f

type Storage = Vec6f

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = Vec6f

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfVectorOfDMatch

type Storage = VectorOfDMatch

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfDMatch

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfERStat

type Storage = VectorOfERStat

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfERStat

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfKeyLine

type Storage = VectorOfKeyLine

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfKeyLine

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfKeyPoint

type Storage = VectorOfKeyPoint

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfKeyPoint

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfMat

type Storage = VectorOfMat

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfMat

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfMatShape

type Storage = VectorOfMatShape

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfMatShape

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfPoint

type Storage = VectorOfPoint

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfPoint

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfPoint2f

type Storage = VectorOfPoint2f

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfPoint2f

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfPoint3d

type Storage = VectorOfPoint3d

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfPoint3d

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfPoint3f

type Storage = VectorOfPoint3f

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfPoint3f

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfPoint3i

type Storage = VectorOfPoint3i

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfPoint3i

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfRange

type Storage = VectorOfRange

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfRange

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfVec2i

type Storage = VectorOfVec2i

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfVec2i

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOff64

type Storage = VectorOff64

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOff64

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfi32

type Storage = VectorOfi32

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfi32

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfi8

type Storage = VectorOfi8

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfi8

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVectorOfu8

type Storage = VectorOfu8

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VectorOfu8

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVideoCapture

type Storage = VideoCapture

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VideoCapture

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

fn get(&self, index: size_t) -> Result<Self::Storage>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOfVideoCaptureAPIs

type Storage = VideoCaptureAPIs

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = VideoCaptureAPIs

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfbool

type Storage = bool

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = bool

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

impl<'i> Vector<'i> for VectorOff32

type Storage = f32

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = f32

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOff64

type Storage = f64

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = f64

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfi32

type Storage = i32

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = i32

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfi8

type Storage = i8

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = i8

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfsize_t

type Storage = size_t

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = size_t

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

impl<'i> Vector<'i> for VectorOfu8

type Storage = u8

fn new() -> Self

fn len(&self) -> size_t

fn is_empty(&self) -> bool

fn capacity(&self) -> size_t

fn shrink_to_fit(&mut self)

fn reserve(&mut self, additional: size_t)

fn remove(&mut self, index: size_t) -> Result<()>

fn swap(&mut self, index1: size_t, index2: size_t) -> Result<()>

fn clear(&mut self)

type Arg = u8

fn get(&self, index: size_t) -> Result<Self::Storage>

fn push(&mut self, val: Self::Arg)

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn get_unchecked(&self, index: size_t) -> Self::Storage

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

fn to_vec(&self) -> Vec<Self::Storage>

Loading content...