[go: up one dir, main page]

plotters 0.1.10

Plot Drawing Library in Pure Rust for both native and WASM applications
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
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

use super::palette::Palette;
/// The abstraction of a color
use std::marker::PhantomData;

/// Any color representation
pub trait Color {
    /// Convert the RGB representation to the standard RGB tuple
    fn rgb(&self) -> (u8, u8, u8);

    /// Get the alpha channel of the color
    fn alpha(&self) -> f64;
}

/// The trait for any color that can composite with other color
pub trait Mixable: Color {
    /// Introduce alpha channel to the color
    fn mix(&self, alpha: f64) -> CompsitableColor<Self> {
        CompsitableColor(self, alpha)
    }
}

impl<T: Color + Sized> Mixable for T {}

impl Color for Box<&dyn Color> {
    fn rgb(&self) -> (u8, u8, u8) {
        self.as_ref().rgb()
    }

    fn alpha(&self) -> f64 {
        self.as_ref().alpha()
    }
}

/// Color without alpha channel
pub trait SimpleColor {
    fn rgb(&self) -> (u8, u8, u8);
}

impl<T: SimpleColor> Color for T {
    fn rgb(&self) -> (u8, u8, u8) {
        SimpleColor::rgb(self)
    }

    fn alpha(&self) -> f64 {
        1.0
    }
}

/// A color in the given palette
pub struct PaletteColor<P: Palette>(usize, PhantomData<P>);

impl<P: Palette> PaletteColor<P> {
    /// Pick a color from the palette
    pub fn pick(idx: usize) -> PaletteColor<P> {
        return PaletteColor(idx % P::COLORS.len(), PhantomData);
    }
}

impl<P: Palette> SimpleColor for PaletteColor<P> {
    fn rgb(&self) -> (u8, u8, u8) {
        P::COLORS[self.0]
    }
}

/// Simple color with additional alpha channel
pub struct CompsitableColor<'a, T: Color + ?Sized>(&'a T, f64);

impl<'a, T: Color> Color for CompsitableColor<'a, T> {
    fn rgb(&self) -> (u8, u8, u8) {
        (self.0).rgb()
    }

    fn alpha(&self) -> f64 {
        (self.0).alpha() * self.1
    }
}

/// The color described by it's RGB value
pub struct RGBColor(pub u8, pub u8, pub u8);

impl SimpleColor for RGBColor {
    fn rgb(&self) -> (u8, u8, u8) {
        (self.0, self.1, self.2)
    }
}

pub struct Transparent;
pub struct White;
pub struct Black;
pub struct Red;
pub struct Green;
pub struct Blue;
pub struct Yellow;
pub struct Cyan;
pub struct Magenta;

impl SimpleColor for White {
    fn rgb(&self) -> (u8, u8, u8) {
        return (255, 255, 255);
    }
}

impl SimpleColor for Black {
    fn rgb(&self) -> (u8, u8, u8) {
        return (0, 0, 0);
    }
}

impl SimpleColor for Green {
    fn rgb(&self) -> (u8, u8, u8) {
        return (0, 255, 0);
    }
}

impl SimpleColor for Red {
    fn rgb(&self) -> (u8, u8, u8) {
        return (255, 0, 0);
    }
}

impl SimpleColor for Blue {
    fn rgb(&self) -> (u8, u8, u8) {
        return (0, 0, 255);
    }
}

impl SimpleColor for Cyan {
    fn rgb(&self) -> (u8, u8, u8) {
        return (0, 255, 255);
    }
}

impl SimpleColor for Yellow {
    fn rgb(&self) -> (u8, u8, u8) {
        return (255, 255, 0);
    }
}

impl SimpleColor for Magenta {
    fn rgb(&self) -> (u8, u8, u8) {
        return (255, 255, 0);
    }
}

impl Color for Transparent {
    fn rgb(&self) -> (u8, u8, u8) {
        return (0, 0, 0);
    }
    fn alpha(&self) -> f64 {
        return 0.0;
    }
}