thermark 0.36.1

Local sticker printing for pocket thermal printers over BLE/USB — QR links, inventory tags, badges, photos; no vendor app
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

//! White-background alpha compositing.

use image::{DynamicImage, GrayImage};

/// Convert an image to grayscale after flattening transparency onto white.
///
/// Thermal media has a white background. Ignoring alpha makes a transparent
/// black PNG look solid black, so both encoding and trimming route alpha
/// pixels through the same compositing rule.
pub fn grayscale_on_white(img: DynamicImage) -> GrayImage {
    if !img.has_alpha() {
        return img.into_luma8();
    }

    flatten_alpha_on_white(img).into_luma8()
}

/// Composite alpha-bearing channels over white in their native precision.
///
/// Luminance conversion happens afterwards through `DynamicImage::into_luma8`.
/// Keeping that order preserves the image crate's color conversion and makes
/// an opaque RGBA pixel identical to the corresponding RGB pixel.
fn flatten_alpha_on_white(img: DynamicImage) -> DynamicImage {
    match img {
        DynamicImage::ImageLumaA8(mut pixels) => {
            for pixel in pixels.pixels_mut() {
                pixel[0] = composite_u8_on_white(pixel[0], pixel[1]);
                pixel[1] = u8::MAX;
            }
            DynamicImage::ImageLumaA8(pixels)
        }
        DynamicImage::ImageRgba8(mut pixels) => {
            for pixel in pixels.pixels_mut() {
                let alpha = pixel[3];
                for channel in &mut pixel.0[..3] {
                    *channel = composite_u8_on_white(*channel, alpha);
                }
                pixel[3] = u8::MAX;
            }
            DynamicImage::ImageRgba8(pixels)
        }
        DynamicImage::ImageLumaA16(mut pixels) => {
            for pixel in pixels.pixels_mut() {
                pixel[0] = composite_u16_on_white(pixel[0], pixel[1]);
                pixel[1] = u16::MAX;
            }
            DynamicImage::ImageLumaA16(pixels)
        }
        DynamicImage::ImageRgba16(mut pixels) => {
            for pixel in pixels.pixels_mut() {
                let alpha = pixel[3];
                for channel in &mut pixel.0[..3] {
                    *channel = composite_u16_on_white(*channel, alpha);
                }
                pixel[3] = u16::MAX;
            }
            DynamicImage::ImageRgba16(pixels)
        }
        DynamicImage::ImageRgba32F(mut pixels) => {
            for pixel in pixels.pixels_mut() {
                let alpha = pixel[3];
                for channel in &mut pixel.0[..3] {
                    *channel = *channel * alpha + (1.0 - alpha);
                }
                pixel[3] = 1.0;
            }
            DynamicImage::ImageRgba32F(pixels)
        }
        image => image,
    }
}

fn composite_u8_on_white(channel: u8, alpha: u8) -> u8 {
    let alpha = u16::from(alpha);
    ((u16::from(channel) * alpha + u16::from(u8::MAX) * (u16::from(u8::MAX) - alpha) + 127)
        / u16::from(u8::MAX)) as u8
}

fn composite_u16_on_white(channel: u16, alpha: u16) -> u16 {
    let alpha = u64::from(alpha);
    ((u64::from(channel) * alpha
        + u64::from(u16::MAX) * (u64::from(u16::MAX) - alpha)
        + u64::from(u16::MAX) / 2)
        / u64::from(u16::MAX)) as u16
}