refilelabs-image 0.3.1

Wasm-based image processing library developed by re;file labs
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

use image::ImageFormat;

use crate::{
    convert::{
        settings::{Settings, SvgSettings},
        svg::svg_to_png,
    },
    error::WasmImageError,
    source_type::SourceType,
};

pub(crate) enum SourceImage<'s> {
    Raster(image::DynamicImage),
    Svg(&'s [u8]),
}

impl SourceImage<'_> {
    pub(crate) fn rasterize(
        &self,
        settings: Option<&Settings>,
    ) -> Result<image::DynamicImage, WasmImageError> {
        match self {
            Self::Raster(img) => Ok(img.clone()),
            Self::Svg(svg) => {
                let svg_settings = match settings {
                    Some(Settings::Svg(settings)) => *settings,
                    _ => SvgSettings::default(),
                };
                let img = svg_to_png(svg, svg_settings)?;
                image::load_from_memory_with_format(&img, ImageFormat::Png).map_err(Into::into)
            }
        }
    }
}

pub(crate) fn load_image<'a>(
    file: &'a [u8],
    source_type: Option<&'a SourceType>,
) -> Result<SourceImage<'a>, WasmImageError> {
    let loaded_image = match source_type {
        Some(SourceType::Raster(file_type)) => {
            SourceImage::Raster(image::load_from_memory_with_format(file, *file_type)?)
        }
        Some(SourceType::Svg) => SourceImage::Svg(file),
        None => {
            let img = image::load_from_memory(file)
                .map_err(|e| WasmImageError::UnknownFileType(e.to_string()))?;
            SourceImage::Raster(img)
        }
    };

    Ok(loaded_image)
}

pub(crate) enum RawSourceImage<'s> {
    Raster(&'s [u8], ImageFormat),
    Svg(&'s [u8]),
}

pub(crate) fn load_raw_image<'a>(
    file: &'a [u8],
    source_type: Option<&'a SourceType>,
) -> Result<RawSourceImage<'a>, WasmImageError> {
    match source_type {
        Some(SourceType::Raster(file_type)) => Ok(RawSourceImage::Raster(file, *file_type)),
        Some(SourceType::Svg) => Ok(RawSourceImage::Svg(file)),
        None => {
            let img = image::guess_format(file)
                .map_err(|e| WasmImageError::UnknownFileType(e.to_string()))?;

            Ok(RawSourceImage::Raster(file, img))
        }
    }
}