iris-cv 0.0.0

A fast computer vision library framework in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

use thiserror::Error;

/// Error type for all Iris library operations.
#[derive(Debug, Error)]
pub enum IrisError {
    #[error("Image I/O or format error: {0}")]
    Image(#[from] image::ImageError),

    #[error("Standard I/O error: {0}")]
    Io(#[from] std::io::Error),

    #[error("Tensor operation failed: {0}")]
    Tensor(String),

    #[error("Dimension mismatch: expected {expected:?}, found {actual:?}")]
    DimensionMismatch {
        expected: Vec<usize>,
        actual: Vec<usize>,
    },

    #[error("Invalid parameter: {0}")]
    InvalidParameter(String),

    #[error("Model load failure: {0}")]
    ModelLoad(String),

    #[error("Model execution or inference failure: {0}")]
    Inference(String),

    #[error("Feature not implemented: {0}")]
    FeatureNotImplemented(String),

    #[error("Generic error: {0}")]
    Generic(String),

    #[error("Video error: {0}")]
    Video(String),
}

/// Result type for Iris library operations.
pub type Result<T> = std::result::Result<T, IrisError>;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_error_formatting() {
        let err = IrisError::Generic("test error".to_string());
        assert_eq!(format!("{}", err), "Generic error: test error");

        let err_dim = IrisError::DimensionMismatch {
            expected: vec![1, 2, 3],
            actual: vec![1, 2],
        };
        assert!(format!("{}", err_dim).contains("Dimension mismatch"));
    }
}