vizkit 0.1.1

A rendering-agnostic kit for data visualization
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use super::common::{RGBInterpolator, Scheme, split_colors};

/// Color space used for [`Diverging`][`super::Diverging`] color map
#[derive(Debug, Clone)]
pub enum DivergingSpace {
    #[doc = include_str!("../../docs/brbg.svg")]
    BrBg,

    #[doc = include_str!("../../docs/piyg.svg")]
    PiYg,

    #[doc = include_str!("../../docs/prgn.svg")]
    PrGn,

    #[doc = include_str!("../../docs/puor.svg")]
    PuOr,

    #[doc = include_str!("../../docs/rdbu.svg")]
    RdBu,

    #[doc = include_str!("../../docs/rdgy.svg")]
    RdGy,

    #[doc = include_str!("../../docs/rdylbu.svg")]
    RdYlBu,

    #[doc = include_str!("../../docs/rdylgn.svg")]
    RdYlGn,

    #[doc = include_str!("../../docs/spectral.svg")]
    Spectral,
}

impl Scheme for DivergingSpace {
    fn scheme(&self) -> Vec<&str> {
        split_colors(match self {
            Self::BrBg => "5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30",
            Self::PiYg => "8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419",
            Self::PrGn => "40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b",
            Self::PuOr => "2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08",
            Self::RdBu => "67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061",
            Self::RdGy => "67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a",
            Self::RdYlBu => "a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695",
            Self::RdYlGn => "a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837",
            Self::Spectral => "9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2",
        })
    }
}

impl DivergingSpace {
    pub(crate) fn interpolator(&self) -> RGBInterpolator {
        RGBInterpolator::new(self.scheme())
    }
}

#[cfg(test)]
mod tests {
    use super::DivergingSpace;

    #[test]
    fn test_sequential() {
        let step = 100;
        let variants = [
            DivergingSpace::BrBg,
            DivergingSpace::PiYg,
            DivergingSpace::PrGn,
            DivergingSpace::PuOr,
            DivergingSpace::RdBu,
            DivergingSpace::RdGy,
            DivergingSpace::RdYlBu,
            DivergingSpace::RdYlGn,
            DivergingSpace::Spectral,
        ];
        for space in variants {
            let interpolator = space.interpolator();
            let colors: Vec<[f32; 3]> = (0..=step)
                .map(|i| interpolator.interpolate(i as f32 / step as f32))
                .collect();
            for color in colors {
                let [r, g, b] = color;
                assert!(
                    (0. ..=1.).contains(&r),
                    "red must be between [0, 1] (variant: {:?})",
                    space
                );
                assert!(
                    (0. ..=1.).contains(&g),
                    "green must be between [0, 1] (variant: {:?})",
                    space
                );
                assert!(
                    (0. ..=1.).contains(&b),
                    "blue must be between [0, 1] (variant: {:?})",
                    space
                );
            }
        }
    }
}