psd 0.3.5

A Rust API for parsing and working with PSD files.
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224

//! FIXME: Combine these all into one test that iterates through a vector of
//! (PathBuf, [f32; 4])

use anyhow::Result;
use psd::Psd;

const BLEND_NORMAL_BLUE_RED_PIXEL: [u8; 4] = [85, 0, 170, 192];
const BLEND_MULTIPLY_BLUE_RED_PIXEL: [u8; 4] = [85, 0, 85, 192];
const BLEND_SCREEN_BLUE_RED_PIXEL: [u8; 4] = [170, 0, 170, 192];
const BLEND_OVERLAY_BLUE_RED_PIXEL: [u8; 4] = [170, 0, 85, 192];

const BLEND_DARKEN_BLUE_RED_PIXEL: [u8; 4] = [85, 0, 85, 192];
const BLEND_LIGHTEN_BLUE_RED_PIXEL: [u8; 4] = [170, 0, 170, 192];

const BLEND_COLOR_BURN_BLUE_RED_PIXEL: [u8; 4] = [170, 0, 85, 192];
const BLEND_COLOR_DODGE_BLUE_RED_PIXEL: [u8; 4] = [170, 0, 85, 192];

const BLEND_LINEAR_BURN_BLUE_RED_PIXEL: [u8; 4] = [85, 0, 85, 192];
const BLEND_LINEAR_DODGE_BLUE_RED_PIXEL: [u8; 4] = [170, 0, 170, 192];

const BLEND_HARD_LIGHT_BLUE_RED_PIXEL: [u8; 4] = [85, 0, 170, 192];
const BLEND_SOFT_LIGHT_BLUE_RED_PIXEL: [u8; 4] = [170, 0, 85, 192];
const BLEND_VIVID_LIGHT_BLUE_RED_PIXEL: [u8; 4] = [85, 0, 170, 192];
const BLEND_LINEAR_LIGHT_BLUE_RED_PIXEL: [u8; 4] = [85, 0, 169, 192];
const BLEND_PIN_LIGHT_BLUE_RED_PIXEL: [u8; 4] = [85, 0, 170, 192];
const BLEND_HARD_MIX_BLUE_RED_PIXEL: [u8; 4] = [170, 0, 85, 192];

const BLEND_SUBTRACT_BLUE_RED_PIXEL: [u8; 4] = [170, 0, 85, 192];
const BLEND_DIVIDE_BLUE_RED_PIXEL: [u8; 4] = [170, 0, 85, 192];

const BLEND_DIFFERENCE_BLUE_RED_PIXEL: [u8; 4] = [170, 0, 170, 192];
const BLEND_EXCLUSION_BLUE_RED_PIXEL: [u8; 4] = [170, 0, 170, 192];

/// cargo test --test blend normal -- --exact
#[test]
fn normal() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-normal.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_NORMAL_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend multiply -- --exact
#[test]
fn multiply() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-multiply.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_MULTIPLY_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend screen -- --exact
#[test]
fn screen() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-screen.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_SCREEN_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend overlay -- --exact
#[test]
fn overlay() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-overlay.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_OVERLAY_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend darken -- --exact
#[test]
fn darken() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-darken.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_DARKEN_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend lighten -- --exact
#[test]
fn lighten() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-lighten.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_LIGHTEN_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend color_burn -- --exact
#[test]
fn color_burn() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-color-burn.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_COLOR_BURN_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend color_dodge -- --exact
#[test]
fn color_dodge() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-color-dodge.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_COLOR_DODGE_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend linear_burn -- --exact
#[test]
fn linear_burn() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-linear-burn.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_LINEAR_BURN_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend linear_dodge -- --exact
#[test]
fn linear_dodge() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-linear-dodge.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_LINEAR_DODGE_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend hard_light -- --exact
#[test]
fn hard_light() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-hard-light.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_HARD_LIGHT_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend soft_light -- --exact
#[test]
fn soft_light() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-soft-light.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_SOFT_LIGHT_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend divide -- --exact
#[test]
fn divide() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-divide.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_DIVIDE_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend subtract -- --exact
#[test]
fn subtract() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-subtract.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_SUBTRACT_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend difference -- --exact
#[test]
fn difference() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-difference.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_DIFFERENCE_BLUE_RED_PIXEL);

    Ok(())
}

/// cargo test --test blend exclusion -- --exact
#[test]
fn exclusion() -> Result<()> {
    let psd = include_bytes!("./fixtures/blending/blue-red-1x1-exclusion.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;
    assert_eq!(image[0..4], BLEND_EXCLUSION_BLUE_RED_PIXEL);

    Ok(())
}