lifehash 0.1.0

A Lifehash implementation 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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use crate::colors::rgb;
use crate::utils::{clamped, modulo};
use std::io::{Error, ErrorKind};

pub struct Color {
    hue: f64,
    saturation: f64,
    brightness: f64,
}
impl Color {
    pub fn new(hue: f64, saturation: f64, brightness: f64) -> Self {
        Self {
            hue,
            saturation,
            brightness,
        }
    }
    pub fn rgb(&self) -> Result<rgb::Color, Error> {
        let v = clamped(self.brightness);
        let s = clamped(self.saturation);
        let red;
        let green;
        let blue;
        if s <= 0.0 {
            red = v;
            green = v;
            blue = v;
        } else {
            let mut h = modulo(self.hue, 1.0);
            if h < 0.0 {
                h += 1.0;
            }
            h *= 6.0;
            let i = h.floor() as i32;
            let f = h - i as f64;
            let p = v * (1.0 - s);
            let q = v * (1.0 - s * f);
            let t = v * (1.0 - s * (1.0 - f));
            match i {
                0 => {
                    red = v;
                    green = t;
                    blue = p;
                }
                1 => {
                    red = q;
                    green = v;
                    blue = p;
                }
                2 => {
                    red = p;
                    green = v;
                    blue = t;
                }
                3 => {
                    red = p;
                    green = q;
                    blue = v;
                }
                4 => {
                    red = t;
                    green = p;
                    blue = v;
                }
                5 => {
                    red = v;
                    green = p;
                    blue = q;
                }
                _ => {
                    return Err(Error::new(ErrorKind::InvalidData, "Invalid HSB color."));
                }
            }
        }
        Ok(rgb::Color::new(red, green, blue))
    }
}