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

use anyhow::{anyhow, Result};
use psd::Psd;
use psd::PsdChannelCompression;
use psd::PsdChannelKind;
use std::collections::HashMap;

const RED_PIXEL: [u8; 4] = [255, 0, 0, 255];
// const GREEN_PIXEL: [u8; 4] = [0, 255, 0, 255];
const BLUE_PIXEL: [u8; 4] = [0, 0, 255, 255];

// Transparent pixels in the image data section start [255, 255, 255, 0]
// const TRANSPARENT_PIXEL_IMAGE_DATA: [u8; 4] = [255, 255, 255, 0];

// In the layer and mask info section we fill in transparent rgba pixels ourselves as [0, 0, 0, 0]
// const TRANSPARENT_PIXEL_LAYER: [u8; 4] = [0, 0, 0, 0];

// Test that images that have transparent pixels and don't use compression
// return the correct RGBA
#[test]
fn transparency_raw_data() -> Result<()> {
    let psd = include_bytes!("./fixtures/3x3-opaque-center.psd");
    let psd = Psd::from_bytes(psd)?;

    let blue_pixels = vec![(1, 1, BLUE_PIXEL), (2, 0, BLUE_PIXEL)];

    assert_colors(psd.rgba(), &psd, &blue_pixels);

    assert_colors(
        psd.layer_by_name("OpaqueCenter")
            .ok_or(anyhow!("layer not found"))?
            .rgba(),
        &psd,
        &blue_pixels,
    );

    Ok(())
}

// Test that images that have transparent pixels and use rle compression
// return the correct RGBA
#[test]
fn transparency_rle_compressed() -> Result<()> {
    let psd = include_bytes!("./fixtures/16x16-rle-partially-opaque.psd");
    let psd = Psd::from_bytes(psd)?;

    let mut red_block = vec![];
    for left in 0..9 {
        for top in 0..9 {
            red_block.push((left + 1, top + 1, RED_PIXEL));
        }
    }

    assert_eq!(psd.compression(), &PsdChannelCompression::RleCompressed);

    assert_colors(psd.rgba(), &psd, &red_block);

    assert_eq!(
        psd.layer_by_name("OpaqueCenter")
            .ok_or(anyhow!("layer not found"))?
            .compression(PsdChannelKind::Red)?,
        PsdChannelCompression::RleCompressed
    );

    assert_colors(
        psd.layer_by_name("OpaqueCenter")
            .ok_or(anyhow!("layer not found"))?
            .rgba(),
        &psd,
        &red_block,
    );

    Ok(())
}

// Fixes an `already borrowed: BorrowMutError` that we were getting in the `flattened_pixel`
// method when we were recursing into the method and trying to borrow when we'd already borrowed.
#[test]
fn transparent_above_opaque() -> Result<()> {
    let psd = include_bytes!("./fixtures/transparent-above-opaque.psd");
    let psd = Psd::from_bytes(psd)?;

    let image = psd.flatten_layers_rgba(&|_| true)?;

    assert_eq!(image[0..4], BLUE_PIXEL);

    Ok(())
}

// Ensure that the specified, zero-indexed left, top coordinate has the provided pixel color.
// Otherwise it should be fully transparent.
// (left, top, pixel)
fn assert_colors(image: Vec<u8>, psd: &Psd, assertions: &[(usize, usize, [u8; 4])]) {
    let pixel_count = (psd.width() * psd.height()) as usize;
    let width = psd.width() as usize;

    let mut asserts = HashMap::new();
    for assertion in assertions {
        asserts.insert((assertion.0, assertion.1), assertion.2);
    }

    for idx in 0..pixel_count {
        let left = idx % width;
        let top = idx / width;

        let pixel_color = &image[idx * 4..idx * 4 + 4];

        match asserts.get(&(left, top)) {
            Some(expected_color) => {
                assert_eq!(expected_color, pixel_color);
            }
            None => {
                assert_eq!(pixel_color[3], 0, "Pixel should be transparent");
            }
        };
    }
}

fn make_image(pixel: [u8; 4], pixel_count: u32) -> Vec<u8> {
    let pixel_count = pixel_count as usize;
    let mut image = vec![0; pixel_count * 4];

    for idx in 0..pixel_count {
        image[idx * 4] = pixel[0];
        image[idx * 4 + 1] = pixel[1];
        image[idx * 4 + 2] = pixel[2];
        image[idx * 4 + 3] = pixel[3];
    }

    image
}

fn put_pixel(image: &mut Vec<u8>, width: usize, left: usize, top: usize, new: [u8; 4]) {
    let idx = (top * width) + left;
    image[idx * 4] = new[0];
    image[idx * 4 + 1] = new[1];
    image[idx * 4 + 2] = new[2];
    image[idx * 4 + 3] = new[3];
}