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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use std;

const NUM_RGB_BYTES: usize = 3;

#[derive(Debug)]
pub struct OpcPixel<'a, T: AsRef<[u8]> + 'a> {
    x: T,
    pub phantom: std::marker::PhantomData<&'a [u8]>,
}

impl<'a, T: AsRef<[u8]> + 'a> OpcPixel<'a, T> {
    pub fn new(x: T) -> Self {
        OpcPixel {
            x: x,
            phantom: std::marker::PhantomData,
        }
    }
    pub fn r(&self) -> u8 {
        self.x.as_ref()[0]
    }
    pub fn g(&self) -> u8 {
        self.x.as_ref()[1]
    }
    pub fn b(&self) -> u8 {
        self.x.as_ref()[2]
    }
}

impl<'a, T: AsRef<[u8]> + AsMut<[u8]> + 'a> OpcPixel<'a, T> {
    pub fn set_r(&mut self, v: u8) {
        self.x.as_mut()[0] = v;
    }
    pub fn set_g(&mut self, v: u8) {
        self.x.as_mut()[1] = v;
    }
    pub fn set_b(&mut self, v: u8) {
        self.x.as_mut()[2] = v;
    }
}

impl<'a, T: AsRef<[u8]> + 'a> std::convert::From<&'a OpcPixel<'a, T>> for (u8, u8, u8) {
    fn from(t: &'a OpcPixel<'a, T>) -> (u8, u8, u8) {
        (t.r(), t.g(), t.b())
    }
}

pub struct Pixels {
    pixels: Vec<u8>,
}

impl std::convert::From<Vec<u8>> for Pixels {
    fn from(t: Vec<u8>) -> Pixels {
        let mut t = t;
        let blen: usize = t.len() - (t.len() % NUM_RGB_BYTES);
        t.truncate(blen);
        Pixels { pixels: t }
    }
}

impl std::convert::From<Pixels> for Vec<u8> {
    fn from(t: Pixels) -> Vec<u8> {
        t.pixels
    }
}

impl Pixels {
    pub fn new(n: usize) -> Pixels {
        Pixels { pixels: vec![0;n*NUM_RGB_BYTES] }
    }

    pub fn iter(&self) -> PixelIterator {
        PixelIterator::new(self)
    }

    pub fn iter_mut(&mut self) -> PixelIteratorMut {
        PixelIteratorMut::new(self)
    }
}


pub struct PixelIterator<'a> {
    p: std::slice::Chunks<'a, u8>,
}

impl<'a> PixelIterator<'a> {
    fn new(p: &'a Pixels) -> Self {
        PixelIterator { p: p.pixels.chunks(NUM_RGB_BYTES) }
    }
}

impl<'a> std::iter::Iterator for PixelIterator<'a> {
    type Item = OpcPixel<'a, &'a [u8]>;

    fn next(&mut self) -> Option<Self::Item> {
        self.p.next().map(|x| OpcPixel::new(x))
    }
}

impl<'a> ExactSizeIterator for PixelIterator<'a> {
    fn len(&self) -> usize {
        self.p.len()
    }
}

pub struct PixelIteratorMut<'a> {
    p: std::slice::ChunksMut<'a, u8>,
}

impl<'a> PixelIteratorMut<'a> {
    fn new(p: &'a mut Pixels) -> Self {
        PixelIteratorMut { p: p.pixels.chunks_mut(NUM_RGB_BYTES) }
    }
}

impl<'a> std::iter::Iterator for PixelIteratorMut<'a> {
    type Item = OpcPixel<'a, &'a mut [u8]>;

    fn next(&mut self) -> Option<Self::Item> {
        self.p.next().map(|x| OpcPixel::new(x))
    }
}

impl<'a> ExactSizeIterator for PixelIteratorMut<'a> {
    fn len(&self) -> usize {
        self.p.len()
    }
}