Trait cv_convert::FromCv

pub trait FromCv<T> {
    fn from_cv(from: T) -> Self;
}

Type conversion that is analogous to From.

Required methods

fn from_cv(from: T) -> Self

Implementations on Foreign Types

impl<T> FromCv<&'_ Point<T, 2_usize>> for Point_<T> where
    T: Scalar + ValidPointType, 

fn from_cv(from: &Point2<T>) -> Self

impl<T> FromCv<Point<T, 2_usize>> for Point_<T> where
    T: Scalar + ValidPointType, 

fn from_cv(from: Point2<T>) -> Self

impl<T> FromCv<&'_ Point_<T>> for Point2<T> where
    T: Scalar + ValidPointType, 

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

impl<T> FromCv<Point_<T>> for Point2<T> where
    T: Scalar + ValidPointType, 

fn from_cv(from: Point_<T>) -> Self

impl<T> FromCv<&'_ Point<T, 3_usize>> for Point3_<T> where
    T: Scalar + ValidPoint3Type, 

fn from_cv(from: &Point3<T>) -> Self

impl<T> FromCv<Point<T, 3_usize>> for Point3_<T> where
    T: Scalar + ValidPoint3Type, 

fn from_cv(from: Point3<T>) -> Self

impl<T> FromCv<&'_ Point3_<T>> for Point3<T> where
    T: Scalar + ValidPoint3Type, 

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

impl<T> FromCv<Point3_<T>> for Point3<T> where
    T: Scalar + ValidPoint3Type, 

fn from_cv(from: Point3_<T>) -> Self

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

fn from_cv(from: &[u8; N]) -> Self

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

fn from_cv(from: &[[u8; N2]; N1]) -> Self

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

fn from_cv(from: &[[[u8; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[u8; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[u8; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[[u8; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [u8; N]) -> Self

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

fn from_cv(from: [[u8; N2]; N1]) -> Self

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

fn from_cv(from: [[[u8; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[u8; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[u8; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[[u8; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[i8; N]) -> Self

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

fn from_cv(from: &[[i8; N2]; N1]) -> Self

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

fn from_cv(from: &[[[i8; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[i8; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[i8; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[[i8; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [i8; N]) -> Self

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

fn from_cv(from: [[i8; N2]; N1]) -> Self

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

fn from_cv(from: [[[i8; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[i8; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[i8; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[[i8; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[i16; N]) -> Self

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

fn from_cv(from: &[[i16; N2]; N1]) -> Self

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

fn from_cv(from: &[[[i16; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[i16; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[i16; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[[i16; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [i16; N]) -> Self

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

fn from_cv(from: [[i16; N2]; N1]) -> Self

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

fn from_cv(from: [[[i16; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[i16; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[i16; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[[i16; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[i32; N]) -> Self

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

fn from_cv(from: &[[i32; N2]; N1]) -> Self

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

fn from_cv(from: &[[[i32; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[i32; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[i32; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[[i32; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [i32; N]) -> Self

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

fn from_cv(from: [[i32; N2]; N1]) -> Self

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

fn from_cv(from: [[[i32; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[i32; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[i32; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[[i32; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[i64; N]) -> Self

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

fn from_cv(from: &[[i64; N2]; N1]) -> Self

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

fn from_cv(from: &[[[i64; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[i64; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[i64; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[[i64; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [i64; N]) -> Self

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

fn from_cv(from: [[i64; N2]; N1]) -> Self

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

fn from_cv(from: [[[i64; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[i64; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[i64; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[[i64; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[f16; N]) -> Self

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

fn from_cv(from: &[[f16; N2]; N1]) -> Self

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

fn from_cv(from: &[[[f16; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[f16; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[f16; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[[f16; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [f16; N]) -> Self

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

fn from_cv(from: [[f16; N2]; N1]) -> Self

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

fn from_cv(from: [[[f16; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[f16; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[f16; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[[f16; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[f32; N]) -> Self

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

fn from_cv(from: &[[f32; N2]; N1]) -> Self

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

fn from_cv(from: &[[[f32; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[f32; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[f32; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[[f32; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [f32; N]) -> Self

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

fn from_cv(from: [[f32; N2]; N1]) -> Self

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

fn from_cv(from: [[[f32; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[f32; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[f32; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[[f32; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[f64; N]) -> Self

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

fn from_cv(from: &[[f64; N2]; N1]) -> Self

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

fn from_cv(from: &[[[f64; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[f64; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[f64; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[[f64; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [f64; N]) -> Self

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

fn from_cv(from: [[f64; N2]; N1]) -> Self

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

fn from_cv(from: [[[f64; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[f64; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[f64; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[[f64; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[bool; N]) -> Self

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

fn from_cv(from: &[[bool; N2]; N1]) -> Self

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

fn from_cv(from: &[[[bool; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[bool; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[bool; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: &[[[[[[bool; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [bool; N]) -> Self

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

fn from_cv(from: [[bool; N2]; N1]) -> Self

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

fn from_cv(from: [[[bool; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[bool; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[bool; N5]; N4]; N3]; N2]; N1]) -> Self

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

fn from_cv(from: [[[[[[bool; N6]; N5]; N4]; N3]; N2]; N1]) -> Self

impl<P, Container> FromCv<&'_ ImageBuffer<P, Container>> for Tensor where
    P: Pixel + 'static,
    P::Subpixel: 'static + Element,
    Container: Deref<Target = [P::Subpixel]>, 

fn from_cv(from: &ImageBuffer<P, Container>) -> Self

impl<P, Container> FromCv<ImageBuffer<P, Container>> for Tensor where
    P: Pixel + 'static,
    P::Subpixel: 'static + Element,
    Container: Deref<Target = [P::Subpixel]>, 

fn from_cv(from: ImageBuffer<P, Container>) -> Self

impl<A, S, D> FromCv<&'_ ArrayBase<S, D>> for Tensor where
    A: Element + Clone,
    S: RawData<Elem = A> + Data,
    D: Dimension, 

fn from_cv(from: &ArrayBase<S, D>) -> Self

impl<A, S, D> FromCv<ArrayBase<S, D>> for Tensor where
    A: Element + Clone,
    S: RawData<Elem = A> + Data,
    D: Dimension, 

fn from_cv(from: ArrayBase<S, D>) -> Self

Implementors