wcloud 0.1.0

Generate beautiful word clouds with support for masks, custom fonts, custom coloring functions, and more.
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

use ab_glyph::{point, Font, Glyph, Point, PxScale, ScaleFont, FontVec};
use image::{GrayImage, Luma, Pixel, Rgb, Rgba, RgbaImage, RgbImage};

#[derive(Clone, Debug)]
pub struct GlyphData {
    pub glyphs: Vec<Glyph>,
    pub width: u32,
    pub height: u32,
}

pub fn text_to_glyphs(text: &str, font: &FontVec, scale: PxScale) -> GlyphData {
    let scaled_font = font.as_scaled(scale);

    let mut glyphs = Vec::new();
    layout_paragraph(scaled_font, point(0.0, 0.0), 9999.0, text, &mut glyphs);

    let glyphs_height = scaled_font.height().ceil() as u32;
    let glyphs_width = {
        let min_x = glyphs.first().unwrap().position.x;
        let last_glyph = glyphs.last().unwrap();
        let max_x = last_glyph.position.x + scaled_font.h_advance(last_glyph.id);
        (max_x - min_x).ceil() as u32
    };

    GlyphData {
        glyphs,
        width: glyphs_width,
        height: glyphs_height,
    }
}

pub fn draw_glyphs_to_rgba_buffer(
    buffer: &mut RgbaImage,
    glyph_data: GlyphData,
    font: &FontVec,
    point: Point,
    rotate: bool,
    pixel: Rgba<u8>,
) {
    let width = glyph_data.width;

    for glyph in glyph_data.glyphs {
        if let Some(outlined) = font.outline_glyph(glyph) {
            let bounds = outlined.px_bounds();

            outlined.draw(|x, y, v| {
                let (final_x, final_y) = if !rotate {
                    (point.x as u32 + bounds.min.x as u32 + x, point.y as u32 + bounds.min.y as u32 + y)
                }
                else {
                    (y + point.x as u32 + bounds.min.y as u32, width + point.y as u32 - bounds.min.x as u32 - x)
                };

                let px = buffer.get_pixel_mut(final_x, final_y);

                px.apply2(&pixel, |old, new| {
                    ((v * new as f32) + (1.0 - v) * old as f32) as u8
                });

                if px != &Rgba::from([0; 4]) {
                    px.0[3] = 0xFF;
                }
            });
        }
    }
}

pub fn draw_glyphs_to_gray_buffer(
    buffer: &mut GrayImage,
    glyph_data: GlyphData,
    font: &FontVec,
    point: Point,
    rotate: bool,
) {
    let width = glyph_data.width;

    for glyph in glyph_data.glyphs {
        if let Some(outlined) = font.outline_glyph(glyph) {
            let bounds = outlined.px_bounds();

            outlined.draw(|x, y, v| {
                if v < 0.05 {
                    return;
                }

                let (final_x, final_y) = if !rotate {
                    (point.x as u32 + bounds.min.x as u32 + x, point.y as u32 + bounds.min.y as u32 + y)
                }
                else {
                    (y + point.x as u32 + bounds.min.y as u32, width + point.y as u32 - bounds.min.x as u32 - x)
                };

                let px = buffer.get_pixel_mut(final_x, final_y);
                *px = Luma([1]);
            });
        }
    }
}

pub fn layout_paragraph<F, SF>(
    font: SF,
    position: Point,
    _max_width: f32,
    text: &str,
    target: &mut Vec<Glyph>,
) where
    F: Font,
    SF: ScaleFont<F>,
{
    let v_advance = font.height() + font.line_gap();
    let mut caret = position + point(0.0, font.ascent());
    let mut last_glyph: Option<Glyph> = None;
    for c in text.chars() {
        if c.is_control() {
            if c == '\n' {
                caret = point(position.x, caret.y + v_advance);
                last_glyph = None;
            }
            continue;
        }
        let mut glyph = font.scaled_glyph(c);
        if let Some(previous) = last_glyph.take() {
            caret.x += font.kern(previous.id, glyph.id);
        }
        glyph.position = caret;

        last_glyph = Some(glyph.clone());
        caret.x += font.h_advance(glyph.id);

        // if !c.is_whitespace() && caret.x > position.x + max_width {
        //     caret = point(position.x, caret.y + v_advance);
        //     glyph.position = caret;
        //     last_glyph = None;
        // }

        target.push(glyph);
    }
}