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
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

use std::io::Cursor;

use crate::error::WasmImageError;
use crate::load::{load_image, SourceImage};
use crate::source_type::SourceType;
use image::ImageFormat;
pub use settings::Settings;

#[cfg(feature = "wasm")]
use {js_sys::Uint8Array, wasm_bindgen::prelude::*};

pub mod settings;
pub(crate) mod svg;

fn write_image(
    img: &image::DynamicImage,
    file_type: Option<ImageFormat>,
) -> Result<Vec<u8>, WasmImageError> {
    let mut output: Vec<u8> = Vec::new();

    let target_type = file_type.unwrap_or(ImageFormat::Png);

    img.write_to(&mut Cursor::new(&mut output), target_type)?;

    Ok(output)
}

/// Image pre-processing, to ensure that the image can be converted to the target format.
fn process_image(
    img: &SourceImage,
    source_type: Option<ImageFormat>,
    target_type: Option<ImageFormat>,
    settings: Option<&Settings>,
) -> Result<image::DynamicImage, WasmImageError> {
    let img = img.rasterize(settings)?;

    let target_type = target_type.unwrap_or(ImageFormat::Png);

    let img = match source_type {
        Some(ImageFormat::Hdr) => image::DynamicImage::ImageRgba8(img.to_rgba8()),
        _ => img,
    };

    let processed = match target_type {
        ImageFormat::Jpeg
        | ImageFormat::Qoi
        | ImageFormat::Farbfeld
        | ImageFormat::Pnm
        | ImageFormat::Tga => image::DynamicImage::ImageRgb8(img.to_rgb8()),
        ImageFormat::Ico => img.resize(256, 256, image::imageops::FilterType::Lanczos3),
        ImageFormat::OpenExr => image::DynamicImage::ImageRgba32F(img.to_rgba32f()),
        ImageFormat::Hdr => image::DynamicImage::ImageRgb32F(img.to_rgb32f()),
        _ => img,
    };

    Ok(processed)
}

#[cfg(feature = "wasm")]
#[wasm_bindgen(js_name = convertImage)]
#[allow(clippy::needless_pass_by_value)]
/// Convert an image from one format to another.
/// # Arguments
/// * `file` - The image file to convert.
/// * `src_type` - The MIME type of the source image.
/// * `target_type` - The MIME type of the target image.
/// * `cb` - A callback function to report progress.
/// * `convert_settings` - Settings for the conversion.
/// # Errors
/// Returns an error if the conversion fails.
pub fn convert_image(
    file: &Uint8Array,
    src_type: &str,
    target_type: &str,
    cb: &js_sys::Function,
    convert_settings: Option<Settings>,
) -> Result<Uint8Array, JsValue> {
    let src_mime_type = SourceType::from_mime_type(src_type);

    crate::progress::report(cb, 10.0, "Starting conversion");

    let file = file.to_vec();

    crate::progress::report(cb, 35.0, "Loading image");

    let img = load_image(&file, src_mime_type.as_ref())
        .map_err(|e| JsValue::from_str(e.to_string().as_str()))?;

    crate::progress::report(cb, 50.0, "Processing image");

    let img = process_image(
        &img,
        ImageFormat::from_mime_type(src_type),
        ImageFormat::from_mime_type(target_type),
        convert_settings.as_ref(),
    )
    .map_err(|e| JsValue::from_str(e.to_string().as_str()))?;

    crate::progress::report(cb, 70.0, "Converting image");

    let output = write_image(&img, ImageFormat::from_mime_type(target_type))
        .map_err(|e| JsValue::from_str(e.to_string().as_str()))?;

    crate::progress::report(cb, 100.0, "Conversion complete");

    Ok(Uint8Array::from(output.as_slice()))
}

#[cfg(not(feature = "wasm"))]
/// Convert an image from one format to another.
/// # Arguments
/// * `file` - The image file to convert.
/// * `src_type` - The MIME type of the source image.
/// * `target_type` - The MIME type of the target image.
/// * `convert_settings` - Settings for the conversion.
/// # Errors
/// Returns an error if the conversion fails.
/// # Example
/// ```rust
/// ```
pub fn convert_image(
    file: &[u8],
    src_type: &str,
    target_type: &str,
    convert_settings: &Option<Settings>,
) -> Result<Vec<u8>, WasmImageError> {
    let src_mime_type = SourceType::from_mime_type(src_type);

    let img = load_image(file, src_mime_type.as_ref())?;

    let img = process_image(
        &img,
        ImageFormat::from_mime_type(src_type),
        ImageFormat::from_mime_type(target_type),
        convert_settings.as_ref(),
    )?;

    write_image(&img, ImageFormat::from_mime_type(target_type))
}