binary_image 0.8.1

A library for handling binary images
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

use crate::BinaryImage;

use bevy_image::prelude::Image as BevyImage;
use bevy_render::render_resource::TextureFormat;
use derive_more::derive::{Display, Error};
use image::{GrayAlphaImage, ImageBuffer, LumaA, Rgba, RgbaImage};

impl TryFrom<BevyImage> for BinaryImage {
    type Error = IntoBinaryImageError;
    fn try_from(image: BevyImage) -> Result<BinaryImage, Self::Error> {
        let (width, height): (u32, u32) = (image.width(), image.height());
        match image.texture_descriptor.format {
            TextureFormat::Rg8Unorm => {
                let image: Option<GrayAlphaImage> = image
                    .data
                    .and_then(|data| ImageBuffer::from_raw(width, height, data));
                image.map(Self::from)
            }
            TextureFormat::Rgba8UnormSrgb
            | TextureFormat::Bgra8UnormSrgb
            | TextureFormat::Bgra8Unorm => {
                let image: Option<RgbaImage> = image
                    .data
                    .and_then(|data| ImageBuffer::from_raw(width, height, data));
                image.map(Self::from)
            }
            TextureFormat::R8Unorm => image.data.map(|data| Self::from_raw(width, height, &data)),
            // Throw and error if conversion isn't supported
            texture_format => return Err(IntoBinaryImageError::UnsupportedFormat(texture_format)),
        }
        .ok_or(IntoBinaryImageError::UnknownConversionError(
            image.texture_descriptor.format,
        ))
    }
}

impl TryFrom<&BevyImage> for BinaryImage {
    type Error = IntoBinaryImageError;
    fn try_from(image: &BevyImage) -> Result<BinaryImage, Self::Error> {
        let (width, height, data): (u32, u32, Option<&[u8]>) =
            (image.width(), image.height(), image.data.as_deref());

        match image.texture_descriptor.format {
            TextureFormat::Rg8Unorm => {
                let image: Option<ImageBuffer<LumaA<u8>, &[u8]>> =
                    data.and_then(|data| ImageBuffer::from_raw(width, height, data));
                image.map(Self::from)
            }
            TextureFormat::Rgba8UnormSrgb
            | TextureFormat::Bgra8UnormSrgb
            | TextureFormat::Bgra8Unorm => {
                let image: Option<ImageBuffer<Rgba<u8>, &[u8]>> =
                    data.and_then(|data| ImageBuffer::from_raw(width, height, data));
                image.map(Self::from)
            }
            TextureFormat::R8Unorm => data.map(|data| Self::from_raw(width, height, data)),
            // Throw and error if conversion isn't supported
            texture_format => return Err(IntoBinaryImageError::UnsupportedFormat(texture_format)),
        }
        .ok_or(IntoBinaryImageError::UnknownConversionError(
            image.texture_descriptor.format,
        ))
    }
}

#[non_exhaustive]
#[derive(Error, Display, Debug)]
pub enum IntoBinaryImageError {
    /// Conversion into binary image not supported for source format.
    #[display("Conversion into binary image not supported for {_0:?}.")]
    #[error(ignore)]
    UnsupportedFormat(TextureFormat),

    /// Encountered an unknown error during conversion.
    #[display("Failed to convert into {_0:?}.")]
    #[error(ignore)]
    UnknownConversionError(TextureFormat),
}

#[cfg(test)]
mod tests {
    use super::*;
    use bevy_image::{
        prelude::Image as BevyImage, CompressedImageFormats, ImageFormat, ImageSampler, ImageType,
    };
    use bevy_render::render_asset::RenderAssetUsages;

    #[test]
    fn test_conversion_rgba() {
        let bevy_image = BevyImage::from_buffer(
            include_bytes!("../assets/car.png"), // buffer
            ImageType::Format(ImageFormat::Png),
            CompressedImageFormats::default(),
            true,
            ImageSampler::default(),
            RenderAssetUsages::default(),
        )
        .unwrap();

        let binary_image: BinaryImage =
            BinaryImage::try_from(&bevy_image).expect("Conversion failed");

        assert_eq!(binary_image.width, bevy_image.width());
        assert_eq!(binary_image.height, bevy_image.height());
        // Additional checks on pixel data can be added here
    }
}