refilelabs-image 0.3.0

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
140
141
142

# refilelabs-image

[![Crates.io](https://img.shields.io/crates/v/refilelabs-image.svg)](https://crates.io/crates/refilelabs-image)
[![Documentation](https://docs.rs/refilelabs-image/badge.svg)](https://docs.rs/refilelabs-image)

A Rust library for advanced image manipulation and format conversion. Provides tools for loading image metadata, converting images, resizing images, and retrieving raw pixel data.

Used under the hood at [re;file labs](https://refilelabs.com/image) to power all image processing features.

## Installation

```toml
[dependencies]
refilelabs-image = "0.2.5"
```

## Features

- Load image metadata (dimensions, EXIF, GPS)
- Retrieve raw RGBA pixel data
- Convert images between formats
- Resize images to exact pixel dimensions
- Custom conversion settings (e.g. SVG rasterization size)

> **Note:** The native Rust API (`#[cfg(not(feature = "wasm"))]`) excludes `save_metadata`, which requires wasm-bindgen types. For JavaScript/WASM usage see the [npm package](https://npmx.dev/package/@refilelabs/image).

## API Reference

### `convert_image`

```rust
pub fn convert_image(
    file: &[u8],
    src_type: &str,
    target_type: &str,
    convert_settings: &Option<Settings>,
) -> Result<Vec<u8>, WasmImageError>
```

Converts an image from one format to another.

---

### `load_metadata`

```rust
pub fn load_metadata(file: &[u8], src_type: &str) -> Result<Metadata, WasmImageError>
```

Extracts dimensions and EXIF metadata from an image file.

---

### `resize_image`

```rust
pub fn resize_image(
    file: &[u8],
    src_type: &str,
    width: u32,
    height: u32,
) -> Result<Vec<u8>, WasmImageError>
```

Resizes an image to exact pixel dimensions using the Lanczos3 filter. Preserves the source format. SVG input is rasterized to PNG.

---

### `get_pixels`

```rust
pub fn get_pixels(file: &[u8], src_type: &str) -> Result<ImageData, WasmImageError>
```

Decodes an image to raw RGBA pixel data.

---

## Data Structures

### `Metadata`

```rust
pub struct Metadata {
    pub width: u32,
    pub height: u32,
    pub other: Option<HashMap<String, String>>, // Non-GPS EXIF fields
    pub gps: Option<HashMap<String, String>>,   // GPS EXIF fields (None if not present)
    pub errors: Option<Vec<String>>,            // Non-fatal EXIF parse errors
}
```

### `ImageData`

```rust
pub struct ImageData {
    pub width: u32,
    pub height: u32,
    pub aspect_ratio: f32,
    pub color_depth: u8,
    pub pixels: Vec<u8>, // Raw RGBA
}
```

### `Settings`

Format-specific conversion settings. Currently supports SVG rasterization size.

---

## Usage Example

```rust
use refilelabs_image::{convert_image, get_pixels, load_metadata, resize_image};
use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let file = fs::read("input.png")?;
    let src_type = "image/png";

    let metadata = load_metadata(&file, src_type)?;
    println!("{}x{}", metadata.width, metadata.height);
    if let Some(gps) = metadata.gps {
        println!("GPS: {:?}", gps);
    }

    let converted = convert_image(&file, src_type, "image/webp", &None)?;
    fs::write("output.webp", converted)?;

    let resized = resize_image(&file, src_type, 800, 600)?;
    fs::write("output_resized.png", resized)?;

    let pixels = get_pixels(&file, src_type)?;
    println!("{} RGBA pixels", pixels.pixels.len() / 4);

    Ok(())
}
```

## License

MIT