Trait cv_convert::prelude::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>

Object Safety

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<&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<&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<DynamicImage> for Mat

type Error = Error

fn try_from_cv(from: DynamicImage) -> 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<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<'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 Matwhere 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 Matwhere 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 Matwhere 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 Matwhere 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 Matwhere 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 Matwhere N: Scalar + DataType,

type Error = Error

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

impl<P, Container> TryFromCv<&ImageBuffer<P, Container>> for Matwhere 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 Matwhere 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 Matwhere T: DataType,

type Error = Error

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

impl<T> TryFromCv<&Point_<T>> for Matwhere 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 Matwhere T: DataType,

type Error = Error

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

impl<T> TryFromCv<Point_<T>> for Matwhere 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