pepecore 0.1.3

A Rust library for image decoding, encoding, and processing using an efficient SVec data structure.
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

//! Module providing high-level API to read image or PSD files/buffers into `SVec`.
//!
//! This module exports two functions: `read_in_path` and `read_in_buffer`, supporting various image color modes
//! (dynamic, gray, rgb, rgba, gray+alpha) and automatically detecting PSD format via magic bytes.
//!
//! # Examples
//!
//! ```rust
//! use pepecore::read::{read_in_path,read_in_buffer};
//! use pepecore::svec::SVec;
//! use pepecore::enums::ImgColor;
//!
//! // Read a JPEG file as RGB image:
//! let svec: SVec = read_in_path("photo.jpg", ImgColor::RGB)
//!     .expect("Failed to read image");
//! assert_eq!(svec.shape.get_channels(), Some(3));
//!
//! // Read a PSD file from buffer dynamically:
//! let buffer: Vec<u8> = std::fs::read("design.psd").unwrap();
//! let dynamic = read_in_buffer(&buffer, ImgColor::DYNAMIC)
//!     .expect("Failed to decode PSD");
//! println!("PSD size: {:?}", dynamic.shape());
//! ```

use crate::array::svec::SVec;
use crate::enums::ImgColor;
use crate::errors::DecodeError;
use crate::errors::DecodeError::FileOpenError;
use crate::ops::read::decode::{
    img_din_decode, img_gray_decode, img_graya_decode, img_rgb_decode, img_rgba_decode, psd_din_decode, psd_gray_decode,
    psd_graya_decode, psd_rgb_decode, psd_rgba_decode,
};
use filebuffer::FileBuffer;
/// Read image from file path into `SVec`, choosing decoder by `ImgColor` and format.
///
/// Automatically detects PSD files by magic bytes `56 66 80 83`.
/// For non-PSD, delegates to common image decoders.
///
/// # Parameters
///
/// - `path`: Path on filesystem to image or PSD file.
/// - `img_color`: Desired output color mode (`DYNAMIC`, `GRAY`, `RGB`, `RGBA`, `GRAYA`).
///
/// # Errors
///
/// Returns `FileOpenError` if file cannot be opened, or relevant decoder errors.
///
/// # Examples
///
/// ```rust
/// use pepecore::read::read_in_path;
/// use pepecore::enums::ImgColor;
///
/// let svec = read_in_path("diagram.psd", ImgColor::RGBA).unwrap();
/// assert_eq!(svec.shape.get_channels(), Some(4));
/// ```

pub fn read_in_path(path: &str, img_color: ImgColor) -> Result<SVec, DecodeError> {
    let img_buffer = FileBuffer::open(path).map_err(|e| FileOpenError(format!("Path: {} FileBuffer error: {:?}", path, e)))?;
    Ok(match &img_buffer[..4] {
        [56, 66, 80, 83] => match img_color {
            ImgColor::DYNAMIC => psd_din_decode(&img_buffer)?,
            ImgColor::GRAY => psd_gray_decode(&img_buffer)?,
            ImgColor::RGB => psd_rgb_decode(&img_buffer)?,
            ImgColor::RGBA => psd_rgba_decode(&img_buffer)?,
            ImgColor::GRAYA => psd_graya_decode(&img_buffer)?,
        },
        _ => match img_color {
            ImgColor::DYNAMIC => img_din_decode(&img_buffer)?,
            ImgColor::GRAY => img_gray_decode(&img_buffer)?,
            ImgColor::RGB => img_rgb_decode(&img_buffer)?,
            ImgColor::RGBA => img_rgba_decode(&img_buffer)?,
            ImgColor::GRAYA => img_graya_decode(&img_buffer)?,
        },
    })
}
/// Decode image from in-memory buffer into `SVec`, choosing decoder by `ImgColor`.
///
/// Uses the same auto-detection logic as `read_in_path`, except without file I/O.
///
/// # Parameters
///
/// - `img_buffer`: Byte slice of image or PSD data.
/// - `img_color`: Desired output color mode.
///
/// # Errors
///
/// Returns relevant decoder `DecodeError`.
///
/// # Examples
///
/// ```rust
/// use pepecore::read::read_in_buffer;
/// use pepecore::enums::ImgColor;
///
/// let data: Vec<u8> = std::fs::read("image.png").unwrap();
/// let gray = read_in_buffer(&data, ImgColor::GRAY).unwrap();
/// assert_eq!(gray.shape.get_channels(), None);
/// ```
pub fn read_in_buffer(img_buffer: &[u8], img_color: ImgColor) -> Result<SVec, DecodeError> {
    Ok(match &img_buffer[..4] {
        [56, 66, 80, 83] => match img_color {
            ImgColor::DYNAMIC => psd_din_decode(&img_buffer)?,
            ImgColor::GRAY => psd_gray_decode(&img_buffer)?,
            ImgColor::RGB => psd_rgb_decode(&img_buffer)?,
            ImgColor::RGBA => psd_rgba_decode(&img_buffer)?,
            ImgColor::GRAYA => psd_graya_decode(&img_buffer)?,
        },
        _ => match img_color {
            ImgColor::DYNAMIC => img_din_decode(&img_buffer)?,
            ImgColor::GRAY => img_gray_decode(&img_buffer)?,
            ImgColor::RGB => img_rgb_decode(&img_buffer)?,
            ImgColor::RGBA => img_rgba_decode(&img_buffer)?,
            ImgColor::GRAYA => img_gray_decode(&img_buffer)?,
        },
    })
}