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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
//! This module contains the `DataSet` trait for representing datasets of images and labels for training.
//!
//! # Examples
//!
//! ```
//! use object_detector_rust::dataset::DataSet;
//! use object_detector_rust::dataset::DummyDataSet;
//!
//! let mut dataset = DummyDataSet::new();
//! match dataset.load() {
//!     Ok(_) => {
//!         let (images, labels) = dataset.get_data();
//!         // Use the images and labels to train a classifier
//!     },
//!     Err(e) => println!("Error loading dataset: {}", e),
//! }
//! ```
//!
//! This example shows how to use the `DataSet` trait to retrieve images and labels for training a classifier.

use image::DynamicImage;
use std::error::Error;

mod folder_dataset;
pub use folder_dataset::FolderDataSet;

mod memory_dataset;
pub use memory_dataset::MemoryDataSet;

use crate::types::AnnotatedImage;

/// Trait representing a dataset of images and labels for training
pub trait DataSet {
    /// Returns the number of images in the dataset
    fn len(&self) -> usize;

    /// Returns the images and labels for training
    fn get_data(&self) -> (Vec<DynamicImage>, Vec<u32>);

    /// Loads the dataset
    fn load(&mut self) -> Result<(), Box<dyn Error>>;
}

/// trait of a set of annotated images
pub trait AnnotatedImageSet {
    /// adds an annotated image
    fn add_annotated_image(&mut self, annotated_image: AnnotatedImage);
    /// returns length of annotated images
    fn annotated_images_len(&self) -> usize;
    /// returns iterator over annotated images
    fn annotated_images(&self) -> Box<dyn Iterator<Item = &AnnotatedImage> + '_>;
}

/// Dummy dataset that returns a fixed set of images and labels
#[derive(Default)]
pub struct DummyDataSet {
    images: Vec<DynamicImage>,
    labels: Vec<u32>,
}

impl DummyDataSet {
    /// Creates a new `DummyDataSet`
    pub fn new() -> Self {
        Self {
            images: vec![],
            labels: vec![],
        }
    }
}

impl DataSet for DummyDataSet {
    fn len(&self) -> usize {
        self.images.len()
    }

    fn get_data(&self) -> (Vec<DynamicImage>, Vec<u32>) {
        (self.images.clone(), self.labels.clone())
    }

    fn load(&mut self) -> Result<(), Box<dyn Error>> {
        // Load the dummy data into the images and labels vectors
        self.images = vec![DynamicImage::new_rgba8(1, 1), DynamicImage::new_rgba8(1, 1)];
        self.labels = vec![0, 1];
        Ok(())
    }
}

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

    #[test]
    fn test_dummy_dataset() {
        let mut dataset = DummyDataSet::new();
        assert_eq!(dataset.len(), 0);
        assert_eq!(dataset.get_data(), (vec![], vec![]));

        dataset.load().unwrap();
        assert_eq!(dataset.len(), 2);
        assert_eq!(
            dataset.get_data(),
            (
                vec![DynamicImage::new_rgba8(1, 1), DynamicImage::new_rgba8(1, 1)],
                vec![0, 1]
            )
        );
    }
}