kornia-io 0.2.0

Image and Video IO library in Rust for computer vision
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use std::any::Any;

use crate::stream::{
    error::StreamCaptureError,
    rtsp::{rtsp_camera_pipeline_description, RTSPCameraConfig},
    v4l2::{v4l2_camera_pipeline_description, V4L2CameraConfig},
    StreamCapture,
};

/// A trait for camera capture configuration.
///
/// This trait allows for different types of camera configurations to be used
/// with the `CameraCapture` struct.
pub trait CameraCaptureConfig: Any {
    /// Returns the configuration as a trait object.
    ///
    /// This method is used for runtime type checking and downcasting.
    fn as_any(&self) -> &dyn Any;
}

/// A camera capture object that grabs frames from a camera.
///
/// This struct wraps a `StreamCapture` and provides a convenient interface
/// for capturing frames from various types of cameras.
pub struct CameraCapture(pub StreamCapture);

impl CameraCapture {
    /// Creates a new CameraCapture object.
    ///
    /// This method constructs a new `CameraCapture` based on the provided configuration.
    /// It supports different types of camera configurations, such as V4L2 and RTSP.
    ///
    /// # Arguments
    ///
    /// * `config` - A trait object implementing `CameraCaptureConfig` that specifies the camera configuration.
    ///
    /// # Returns
    ///
    /// A `Result` containing either a new `CameraCapture` instance or a `StreamCaptureError`.
    ///
    /// # Errors
    ///
    /// This function will return an error if:
    /// - The configuration is invalid (e.g., empty device or URL)
    /// - The configuration type is unknown
    /// - The `StreamCapture` creation fails
    pub fn new(config: &dyn CameraCaptureConfig) -> Result<Self, StreamCaptureError> {
        let pipeline = if let Some(config) = config.as_any().downcast_ref::<V4L2CameraConfig>() {
            // check that the device is not empty
            if config.device.is_empty() {
                return Err(StreamCaptureError::InvalidConfig(
                    "device is empty".to_string(),
                ));
            }
            v4l2_camera_pipeline_description(&config.device, config.size, config.fps)?
        } else if let Some(config) = config.as_any().downcast_ref::<RTSPCameraConfig>() {
            // check that the url is not empty
            if config.url.is_empty() {
                return Err(StreamCaptureError::InvalidConfig(
                    "url is empty".to_string(),
                ));
            }
            rtsp_camera_pipeline_description(&config.url, config.latency)?
        } else {
            return Err(StreamCaptureError::InvalidConfig(
                "unknown config type".to_string(),
            ));
        };

        Ok(Self(StreamCapture::new(&pipeline)?))
    }
}

/// Allows `CameraCapture` to be dereferenced to `StreamCapture`.
///
/// This implementation enables direct access to `StreamCapture` methods
/// on a `CameraCapture` instance.
impl std::ops::Deref for CameraCapture {
    type Target = StreamCapture;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

/// Allows `CameraCapture` to be dereferenced to `StreamCapture`.
///
/// This implementation enables direct access to `StreamCapture` methods
/// on a `CameraCapture` instance.
impl std::ops::DerefMut for CameraCapture {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}