Trait cv_convert::TryFromCv

pub trait TryFromCv<T> where
    Self: Sized, {
    type Error;
    fn try_from_cv(from: T) -> Result<Self, Self::Error>;
}

Fallible type conversion that is analogous to TryFrom.

Associated Types

type Error

Required methods

fn try_from_cv(from: T) -> Result<Self, Self::Error>

Implementations on Foreign Types

impl<T> TryFromCv<&'_ Mat> for Point_<T> where
    T: DataType + ValidPointType, 

type Error = Error

fn try_from_cv(from: &Mat) -> Result<Self>

impl<T> TryFromCv<Mat> for Point_<T> where
    T: DataType + ValidPointType, 

type Error = Error

fn try_from_cv(from: Mat) -> Result<Self>

impl<T> TryFromCv<&'_ Mat> for Point3_<T> where
    T: DataType + ValidPoint3Type, 

type Error = Error

fn try_from_cv(from: &Mat) -> Result<Self>

impl<T> TryFromCv<Mat> for Point3_<T> where
    T: DataType + ValidPoint3Type, 

type Error = Error

fn try_from_cv(from: Mat) -> Result<Self>

impl<T> TryFromCv<&'_ Point_<T>> for Mat where
    T: DataType + ValidPointType, 

type Error = Error

fn try_from_cv(from: &Point_<T>) -> Result<Self>

impl<T> TryFromCv<Point_<T>> for Mat where
    T: DataType + ValidPointType, 

type Error = Error

fn try_from_cv(from: Point_<T>) -> Result<Self>

impl<T> TryFromCv<&'_ Point3_<T>> for Mat where
    T: DataType + ValidPoint3Type, 

type Error = Error

fn try_from_cv(from: &Point3_<T>) -> Result<Self>

impl<T> TryFromCv<Point3_<T>> for Mat where
    T: DataType + ValidPoint3Type, 

type Error = Error

fn try_from_cv(from: Point3_<T>) -> Result<Self>

impl TryFromCv<OpenCvPose<&'_ Point3_<f64>>> for Isometry3<f64>

type Error = Error

fn try_from_cv(pose: OpenCvPose<&Point3d>) -> Result<Self>

impl TryFromCv<&'_ OpenCvPose<Point3_<f64>>> for Isometry3<f64>

type Error = Error

fn try_from_cv(from: &OpenCvPose<Point3d>) -> Result<Self>

impl TryFromCv<OpenCvPose<Point3_<f64>>> for Isometry3<f64>

type Error = Error

fn try_from_cv(from: OpenCvPose<Point3d>) -> Result<Self>

impl TryFromCv<OpenCvPose<&'_ Mat>> for Isometry3<f64>

type Error = Error

fn try_from_cv(from: OpenCvPose<&Mat>) -> Result<Self>

impl TryFromCv<&'_ OpenCvPose<Mat>> for Isometry3<f64>

type Error = Error

fn try_from_cv(from: &OpenCvPose<Mat>) -> Result<Self>

impl TryFromCv<OpenCvPose<Mat>> for Isometry3<f64>

type Error = Error

fn try_from_cv(from: OpenCvPose<Mat>) -> Result<Self>

impl<N, R, C> TryFromCv<&'_ Mat> for OMatrix<N, R, C> where
    N: Scalar + DataType,
    R: Dim,
    C: Dim,
    DefaultAllocator: Allocator<N, R, C>, 

type Error = Error

fn try_from_cv(from: &Mat) -> Result<Self>

impl<N, R, C> TryFromCv<Mat> for OMatrix<N, R, C> where
    N: Scalar + DataType,
    R: Dim,
    C: Dim,
    DefaultAllocator: Allocator<N, R, C>, 

type Error = Error

fn try_from_cv(from: Mat) -> Result<Self>

impl<N, R, C, S> TryFromCv<&'_ Matrix<N, R, C, S>> for Mat where
    N: Scalar + DataType,
    R: Dim,
    C: Dim,
    S: Storage<N, R, C>,
    DefaultAllocator: Allocator<N, C, R>, 

type Error = Error

fn try_from_cv(from: &Matrix<N, R, C, S>) -> Result<Self>

impl<N, R, C, S> TryFromCv<Matrix<N, R, C, S>> for Mat where
    N: Scalar + DataType,
    R: Dim,
    C: Dim,
    S: Storage<N, R, C>,
    DefaultAllocator: Allocator<N, C, R>, 

type Error = Error

fn try_from_cv(from: Matrix<N, R, C, S>) -> Result<Self>

impl<N, const D: usize> TryFromCv<&'_ Translation<N, D>> for Mat where
    N: Scalar + DataType, 

type Error = Error

fn try_from_cv(translation: &Translation<N, D>) -> Result<Self>

impl<N, const D: usize> TryFromCv<Translation<N, D>> for Mat where
    N: Scalar + DataType, 

type Error = Error

fn try_from_cv(translation: Translation<N, D>) -> Result<Self>

impl TryFromCv<&'_ Mat> for Tensor

type Error = Error

fn try_from_cv(from: &Mat) -> Result<Self, Self::Error>

impl TryFromCv<Mat> for Tensor

type Error = Error

fn try_from_cv(from: Mat) -> Result<Self, Self::Error>

impl<T> TryFromCv<&'_ TensorAsImage<T>> for Mat where
    T: Borrow<Tensor>, 

type Error = Error

fn try_from_cv(from: &TensorAsImage<T>) -> Result<Self, Self::Error>

impl<T> TryFromCv<TensorAsImage<T>> for Mat where
    T: Borrow<Tensor>, 

type Error = Error

fn try_from_cv(from: TensorAsImage<T>) -> Result<Self, Self::Error>

impl TryFromCv<&'_ Tensor> for Mat

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl TryFromCv<Tensor> for Mat

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<'a, const N: usize> TryFromCv<&'a Tensor> for &'a [u8; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize> TryFromCv<&'a Tensor> for &'a [[u8; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'a Tensor> for &'a [[[u8; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'a Tensor> for &'a [[[[u8; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'a Tensor> for &'a [[[[[u8; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'a Tensor> for &'a [[[[[[u8; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<&'_ Tensor> for [u8; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<&'_ Tensor> for [[u8; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'_ Tensor> for [[[u8; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'_ Tensor> for [[[[u8; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'_ Tensor> for [[[[[u8; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'_ Tensor> for [[[[[[u8; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<Tensor> for [u8; N]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<Tensor> for [[u8; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<Tensor> for [[[u8; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<Tensor> for [[[[u8; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<Tensor> for [[[[[u8; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<Tensor> for [[[[[[u8; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<'a, const N: usize> TryFromCv<&'a Tensor> for &'a [i8; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize> TryFromCv<&'a Tensor> for &'a [[i8; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'a Tensor> for &'a [[[i8; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'a Tensor> for &'a [[[[i8; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'a Tensor> for &'a [[[[[i8; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'a Tensor> for &'a [[[[[[i8; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<&'_ Tensor> for [i8; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<&'_ Tensor> for [[i8; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'_ Tensor> for [[[i8; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'_ Tensor> for [[[[i8; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'_ Tensor> for [[[[[i8; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'_ Tensor> for [[[[[[i8; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<Tensor> for [i8; N]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<Tensor> for [[i8; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<Tensor> for [[[i8; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<Tensor> for [[[[i8; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<Tensor> for [[[[[i8; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<Tensor> for [[[[[[i8; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<'a, const N: usize> TryFromCv<&'a Tensor> for &'a [i16; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize> TryFromCv<&'a Tensor> for &'a [[i16; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'a Tensor> for &'a [[[i16; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'a Tensor> for &'a [[[[i16; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'a Tensor> for &'a [[[[[i16; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'a Tensor> for &'a [[[[[[i16; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<&'_ Tensor> for [i16; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<&'_ Tensor> for [[i16; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'_ Tensor> for [[[i16; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'_ Tensor> for [[[[i16; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'_ Tensor> for [[[[[i16; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'_ Tensor> for [[[[[[i16; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<Tensor> for [i16; N]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<Tensor> for [[i16; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<Tensor> for [[[i16; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<Tensor> for [[[[i16; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<Tensor> for [[[[[i16; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<Tensor> for [[[[[[i16; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<'a, const N: usize> TryFromCv<&'a Tensor> for &'a [i32; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize> TryFromCv<&'a Tensor> for &'a [[i32; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'a Tensor> for &'a [[[i32; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'a Tensor> for &'a [[[[i32; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'a Tensor> for &'a [[[[[i32; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'a Tensor> for &'a [[[[[[i32; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<&'_ Tensor> for [i32; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<&'_ Tensor> for [[i32; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'_ Tensor> for [[[i32; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'_ Tensor> for [[[[i32; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'_ Tensor> for [[[[[i32; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'_ Tensor> for [[[[[[i32; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<Tensor> for [i32; N]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<Tensor> for [[i32; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<Tensor> for [[[i32; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<Tensor> for [[[[i32; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<Tensor> for [[[[[i32; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<Tensor> for [[[[[[i32; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<'a, const N: usize> TryFromCv<&'a Tensor> for &'a [i64; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize> TryFromCv<&'a Tensor> for &'a [[i64; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'a Tensor> for &'a [[[i64; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'a Tensor> for &'a [[[[i64; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'a Tensor> for &'a [[[[[i64; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'a Tensor> for &'a [[[[[[i64; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<&'_ Tensor> for [i64; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<&'_ Tensor> for [[i64; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'_ Tensor> for [[[i64; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'_ Tensor> for [[[[i64; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'_ Tensor> for [[[[[i64; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'_ Tensor> for [[[[[[i64; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<Tensor> for [i64; N]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<Tensor> for [[i64; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<Tensor> for [[[i64; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<Tensor> for [[[[i64; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<Tensor> for [[[[[i64; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<Tensor> for [[[[[[i64; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<'a, const N: usize> TryFromCv<&'a Tensor> for &'a [f16; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize> TryFromCv<&'a Tensor> for &'a [[f16; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'a Tensor> for &'a [[[f16; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'a Tensor> for &'a [[[[f16; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'a Tensor> for &'a [[[[[f16; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'a Tensor> for &'a [[[[[[f16; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<&'_ Tensor> for [f16; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<&'_ Tensor> for [[f16; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'_ Tensor> for [[[f16; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'_ Tensor> for [[[[f16; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'_ Tensor> for [[[[[f16; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'_ Tensor> for [[[[[[f16; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<Tensor> for [f16; N]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<Tensor> for [[f16; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<Tensor> for [[[f16; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<Tensor> for [[[[f16; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<Tensor> for [[[[[f16; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<Tensor> for [[[[[[f16; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<'a, const N: usize> TryFromCv<&'a Tensor> for &'a [f32; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize> TryFromCv<&'a Tensor> for &'a [[f32; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'a Tensor> for &'a [[[f32; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'a Tensor> for &'a [[[[f32; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'a Tensor> for &'a [[[[[f32; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'a Tensor> for &'a [[[[[[f32; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<&'_ Tensor> for [f32; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<&'_ Tensor> for [[f32; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'_ Tensor> for [[[f32; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'_ Tensor> for [[[[f32; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'_ Tensor> for [[[[[f32; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'_ Tensor> for [[[[[[f32; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<Tensor> for [f32; N]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<Tensor> for [[f32; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<Tensor> for [[[f32; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<Tensor> for [[[[f32; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<Tensor> for [[[[[f32; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<Tensor> for [[[[[[f32; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<'a, const N: usize> TryFromCv<&'a Tensor> for &'a [f64; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize> TryFromCv<&'a Tensor> for &'a [[f64; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'a Tensor> for &'a [[[f64; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'a Tensor> for &'a [[[[f64; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'a Tensor> for &'a [[[[[f64; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'a Tensor> for &'a [[[[[[f64; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<&'_ Tensor> for [f64; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<&'_ Tensor> for [[f64; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'_ Tensor> for [[[f64; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'_ Tensor> for [[[[f64; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'_ Tensor> for [[[[[f64; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'_ Tensor> for [[[[[[f64; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<Tensor> for [f64; N]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<Tensor> for [[f64; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<Tensor> for [[[f64; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<Tensor> for [[[[f64; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<Tensor> for [[[[[f64; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<Tensor> for [[[[[[f64; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<'a, const N: usize> TryFromCv<&'a Tensor> for &'a [bool; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize> TryFromCv<&'a Tensor> for &'a [[bool; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'a Tensor> for &'a [[[bool; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'a Tensor> for &'a [[[[bool; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'a Tensor> for &'a [[[[[bool; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<'a, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'a Tensor> for &'a [[[[[[bool; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<&'_ Tensor> for [bool; N]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<&'_ Tensor> for [[bool; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<&'_ Tensor> for [[[bool; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<&'_ Tensor> for [[[[bool; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<&'_ Tensor> for [[[[[bool; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<&'_ Tensor> for [[[[[[bool; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<const N: usize> TryFromCv<Tensor> for [bool; N]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize> TryFromCv<Tensor> for [[bool; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize> TryFromCv<Tensor> for [[[bool; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize> TryFromCv<Tensor> for [[[[bool; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> TryFromCv<Tensor> for [[[[[bool; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> TryFromCv<Tensor> for [[[[[[bool; N6]; N5]; N4]; N3]; N2]; N1]

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl TryFromCv<&'_ DynamicImage> for Tensor

type Error = Error

fn try_from_cv(from: &DynamicImage) -> Result<Self, Self::Error>

impl TryFromCv<DynamicImage> for Tensor

type Error = Error

fn try_from_cv(from: DynamicImage) -> Result<Self, Self::Error>

impl<A, D> TryFromCv<Tensor> for Array<A, D> where
    D: Dimension,
    A: Element,
    Vec<A>: From<Tensor>,
    Vec<i64>: ToNdArrayShape<D, Error = Error>, 

type Error = Error

fn try_from_cv(from: Tensor) -> Result<Self, Self::Error>

impl<A, D> TryFromCv<&'_ Tensor> for Array<A, D> where
    D: Dimension,
    A: Element,
    Vec<A>: From<Tensor>,
    Vec<i64>: ToNdArrayShape<D, Error = Error>, 

type Error = Error

fn try_from_cv(from: &Tensor) -> Result<Self, Self::Error>

impl<P, Container> TryFromCv<ImageBuffer<P, Container>> for Mat where
    P: Pixel + 'static,
    P::Subpixel: 'static,
    Container: Deref<Target = [P::Subpixel]> + Clone, 

type Error = Error

fn try_from_cv(from: ImageBuffer<P, Container>) -> Result<Self, Self::Error>

impl<P, Container> TryFromCv<&'_ ImageBuffer<P, Container>> for Mat where
    P: Pixel + 'static,
    P::Subpixel: 'static,
    Container: Deref<Target = [P::Subpixel]> + Clone, 

type Error = Error

fn try_from_cv(from: &ImageBuffer<P, Container>) -> Result<Self, Self::Error>

impl TryFromCv<&'_ DynamicImage> for Mat

type Error = Error

fn try_from_cv(from: &DynamicImage) -> Result<Self, Self::Error>

impl TryFromCv<DynamicImage> for Mat

type Error = Error

fn try_from_cv(from: DynamicImage) -> Result<Self, Self::Error>

Implementors

impl TryFromCv<&'_ Isometry<f32, Unit<Quaternion<f32>>, 3_usize>> for OpenCvPose<Mat>

impl TryFromCv<&'_ Isometry<f64, Unit<Quaternion<f64>>, 3_usize>> for OpenCvPose<Mat>

impl TryFromCv<Isometry<f32, Unit<Quaternion<f32>>, 3_usize>> for OpenCvPose<Mat>

impl TryFromCv<Isometry<f64, Unit<Quaternion<f64>>, 3_usize>> for OpenCvPose<Mat>

impl TryFromCv<Mat> for TensorFromMat

impl<T> TryFromCv<&'_ Isometry<T, Unit<Quaternion<T>>, 3_usize>> for OpenCvPose<Point3_<T>> where
    T: DataType + ValidPoint3Type + RealField, 

impl<T> TryFromCv<Isometry<T, Unit<Quaternion<T>>, 3_usize>> for OpenCvPose<Point3_<T>> where
    T: DataType + ValidPoint3Type + RealField,