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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

//! Rainbow converts between various color encoding formats.
//!
//! # Examples
//!
//! RGBA scales from 0-255 on all values.
//!
//! ```
//! use rainbow::Color;
//! // Create a new RGBA color object.
//! let the_color_green = rainbow::RGBA::new(10, 255, 15, 255);
//! // The RGBA values can each be accessed through the `to_u8()` function.
//! let color_values = the_color_green.to_u8();
//! # assert_eq!(color_values.0, 10);
//! assert_eq!(color_values.1, 255);
//! # assert_eq!(color_values.2, 15);
//! # assert_eq!(color_values.3, 255);
//! // Tuple makes it easy to create variables for each value.
//! let (red, green, blue, alpha) = the_color_green.to_u8();
//! # assert_eq!(red, 10);
//! assert_eq!(green, 255);
//! # assert_eq!(blue, 15);
//! # assert_eq!(alpha, 255);
//! // Or.
//! let (_, green, _, _) = the_color_green.to_u8();
//! assert_eq!(green, 255);
//! ```

pub trait Color {
    /// Create a tuple `(red, green, blue, alpha)`.
    ///
    /// Scales form 0.0 to 1.0.
    fn to_f32(&self) -> (f32, f32, f32, f32);
    /// Create a tuple `(red, green, blue, alpha)`.
    ///
    /// Scales form 0 to 255.
    fn to_u8(&self) -> (u8, u8, u8, u8);
}
/*
/// https://en.wikipedia.org/wiki/Luma_%28video%29
pub enum LumaFormula {
    REC_601,
    REC_709,
    SMPTE_240M,
}
*/

/// "Red Green Blue Alpha".
pub struct RGBA {
    red: u8,
    green: u8,
    blue: u8,
    alpha: u8
}

impl RGBA {
    pub fn new(r: u8, g: u8, b: u8, a: u8) -> RGBA {
        return RGBA {
            red: r,
            green: g,
            blue: b,
            alpha: a,
        };
    }
}

impl Color for RGBA {
    fn to_f32(&self) -> (f32, f32, f32, f32) {
        let red = self.red as f32 / 255.0f32;
        let green = self.green as f32 / 255.0f32;
        let blue = self.blue as f32 / 255.0f32;
        let alpha = self.alpha as f32 / 255.0f32;
        return (red, green, blue, alpha);
    }
    fn to_u8(&self) -> (u8, u8, u8, u8) {
        return (self.red, self.green, self.blue, self.alpha);
    }
}

pub struct RGB {
    red: u8,
    green: u8,
    blue: u8,
}

/// "Red Green Blue".
impl RGB {
    pub fn new(r: u8, g: u8, b: u8) -> RGB {
        return RGB {
            red: r,
            green: g,
            blue: b,
        };
    }
    pub fn from_hex_str(hex_str: &str) -> Result<RGB, &'static str> {
        if hex_str.len() < 7 {
            return Err("Not super duper perfect.");
        }
        let hex_bytes = hex_str.as_bytes();
        if hex_bytes[0] != 35 {
            return Err("Please start the hex string with a number sign.");
        }
        // Red
        let red = RGB::convert_byte_slice(&hex_bytes[1..3]).unwrap();
        let green = RGB::convert_byte_slice(&hex_bytes[3..5]).unwrap();
        let blue = RGB::convert_byte_slice(&hex_bytes[5..7]).unwrap();
        return Ok(RGB::new(red, green, blue));
    }
    fn convert_byte_slice(slice: &[u8]) -> Option<u8> {
        let first_byte = match RGB::hex_byte_to_number(slice[0]) {
            Some(int) => int,
            None => return None,
        };
        let second_byte = match RGB::hex_byte_to_number(slice[1]) {
            Some(int) => int,
            None => return None,
        };
    println!("{}", 16 * first_byte + second_byte);
        return Some(16 * first_byte + second_byte);
    }
    fn hex_byte_to_number(byte: u8) -> Option<u8> {
        if byte >= 48 && byte <= 57 {
            return Some(byte - 48);
        }
        if byte >= 97 && byte <= 102 {
            return Some(byte - 87);
        }
        if byte >= 65 && byte <= 70 {
            return Some(byte - 55);
        }
        return None;
    }

    // pub fn to_gra
}

impl Color for RGB {
    fn to_f32(&self) -> (f32, f32, f32, f32) {
        let red = self.red as f32 / 255.0f32;
        let green = self.green as f32 / 255.0f32;
        let blue = self.blue as f32 / 255.0f32;
        let alpha = 1.0;
        return (red, green, blue, alpha);
    }
    fn to_u8(&self) -> (u8, u8, u8, u8) {
        return (self.red, self.green, self.blue, 255);
    }
}


#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn hex_str() {
        let black = RGB::from_hex_str("#000000").unwrap();
        assert_eq!((0, 0, 0, 255), black.to_u8());
        let red = RGB::from_hex_str("#C81402").unwrap();
        assert_eq!((200, 20, 2, 255), red.to_u8());
    }
}