Trait TryFromCv

pub trait TryFromCv<T>
where
    Self: Sized,
{
    type Error;

    // Required method
    fn try_from_cv(from: T) -> Result<Self, Self::Error>;
}

Fallible type conversion that is analogous to TryFrom.

Required Associated Types

type Error

Required Methods

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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl TryFromCv<&DynamicImage> for Mat

type Error = Error

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

impl TryFromCv<&Mat> for DynamicImage

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(mat: &Mat) -> Result<Self, Self::Error>

impl TryFromCv<&Tensor> for Mat

type Error = Error

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

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

type Error = Error

fn try_from_cv(pose: &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<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<&TchTensorAsImage> for Mat

type Error = Error

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

impl TryFromCv<DynamicImage> for Mat

type Error = Error

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

impl TryFromCv<Mat> for DynamicImage

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 TryFromCv<Tensor> for Mat

type Error = Error

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

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

type Error = Error

fn try_from_cv(pose: 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<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<TchTensorAsImage> for Mat

type Error = Error

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

impl<'a, A, D> TryFromCv<&'a Mat> for ArrayView<'a, A, D>

where A: OpenCvElement, D: Dimension,

type Error = Error

fn try_from_cv(from: &'a Mat) -> 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> 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> 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> 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> 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> 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> 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> 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> 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 [[[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> 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> 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> 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> 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> 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> 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> 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> 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 [[[[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> 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> 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> 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> 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> 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> 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> 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> 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 [[[[[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> 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> 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> 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> 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> 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> 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> 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> 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 [[[[[[bool; N6]; 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<'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<'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<'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<'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<'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<'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<'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<'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 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 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 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 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 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 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 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 N: usize> TryFromCv<&'a Tensor> for &'a [f16; N]

type Error = Error

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

impl<A, D> TryFromCv<&Mat> for Array<A, D>

where A: OpenCvElement + Clone, D: Dimension,

type Error = Error

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

impl<A, D> TryFromCv<&Tensor> for Array<A, D>

where D: Dimension, A: Element, Vec<A>: TryFrom<Tensor, Error = TchError>, Vec<i64>: ToNdArrayShape<D, Error = Error>,

type Error = Error

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

impl<A, D> TryFromCv<Mat> for Array<A, D>

where A: OpenCvElement + Clone, D: Dimension,

type Error = Error

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

impl<A, D> TryFromCv<Tensor> for Array<A, D>

where D: Dimension, A: Element, Vec<A>: TryFrom<Tensor, Error = TchError>, Vec<i64>: ToNdArrayShape<D, Error = Error>,

type Error = Error

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

impl<A, S, D> TryFromCv<&ArrayBase<S, D>> for Mat

where A: DataType, S: RawData<Elem = A> + Data, D: Dimension,

type Error = Error

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

impl<A, S, D> TryFromCv<ArrayBase<S, D>> for Mat

where A: DataType, S: RawData<Elem = A> + Data, D: Dimension,

type Error = Error

fn try_from_cv(from: ArrayBase<S, D>) -> 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<P, Container> TryFromCv<&ImageBuffer<P, Container>> for Mat

where P: Pixel, P::Subpixel: OpenCvElement, 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, P::Subpixel: OpenCvElement, Container: Deref<Target = [P::Subpixel]> + Clone,

type Error = Error

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

impl<T> TryFromCv<&Point3_<T>> for Mat

where T: DataType,

type Error = Error

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

impl<T> TryFromCv<&Point_<T>> for Mat

where T: DataType,

type Error = Error

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

impl<T> TryFromCv<&Mat> for ImageBuffer<Luma<T>, Vec<T>>

where Luma<T>: Pixel, T: OpenCvElement + Primitive + DataType,

type Error = Error

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

impl<T> TryFromCv<&Mat> for ImageBuffer<Rgb<T>, Vec<T>>

where Rgb<T>: Pixel<Subpixel = T>, T: OpenCvElement + Primitive + DataType,

type Error = Error

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

impl<T> TryFromCv<&Mat> for Point3_<T>

where T: DataType,

type Error = Error

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

impl<T> TryFromCv<&Mat> for Point_<T>

where T: DataType,

type Error = Error

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

impl<T> TryFromCv<Point3_<T>> for Mat

where T: DataType,

type Error = Error

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

impl<T> TryFromCv<Point_<T>> for Mat

where T: DataType,

type Error = Error

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

impl<T> TryFromCv<Mat> for ImageBuffer<Luma<T>, Vec<T>>

where Luma<T>: Pixel, T: OpenCvElement + Primitive + DataType,

type Error = Error

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

impl<T> TryFromCv<Mat> for ImageBuffer<Rgb<T>, Vec<T>>

where Rgb<T>: Pixel<Subpixel = T>, T: OpenCvElement + Primitive + DataType,

type Error = Error

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

impl<T> TryFromCv<Mat> for Point3_<T>

where T: DataType,

type Error = Error

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

impl<T> TryFromCv<Mat> for Point_<T>

where T: DataType,

type Error = Error

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

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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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 [[[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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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 [[[[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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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 [[[[[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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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 [[[[[[bool; N6]; 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 [bool; N]

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 N: usize> TryFromCv<&Tensor> for [f64; N]

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 N: usize> TryFromCv<&Tensor> for [i16; N]

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 N: usize> TryFromCv<&Tensor> for [i64; N]

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 N: usize> TryFromCv<&Tensor> for [f16; N]

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 N: usize> TryFromCv<Tensor> for [f32; N]

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 N: usize> TryFromCv<Tensor> for [i8; N]

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 N: usize> TryFromCv<Tensor> for [i32; N]

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 N: usize> TryFromCv<Tensor> for [u8; N]

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>

Implementors

impl TryFromCv<&DynamicImage> for TchTensorAsImage

type Error = Error

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

type Error = Error

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

type Error = Error

impl TryFromCv<&Mat> for TchTensorAsImage

type Error = Error

impl TryFromCv<DynamicImage> for TchTensorAsImage

type Error = Error

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

type Error = Error

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

type Error = Error

impl TryFromCv<Mat> for TchTensorAsImage

type Error = Error

impl<'a> TryFromCv<&'a Mat> for OpenCvMatAsTchTensor<'a>

type Error = Error

impl<T> TryFromCv<&Isometry<T, Unit<Quaternion<T>>, 3>> for OpenCvPose<Point3_<T>>

where T: DataType + RealField,

type Error = Error

impl<T> TryFromCv<Isometry<T, Unit<Quaternion<T>>, 3>> for OpenCvPose<Point3_<T>>

where T: DataType + RealField,

type Error = Error