rustbitmap 0.1.0

Read, write and edit bitmap 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

use super::bit_data::BitData;
use super::bit_depth::BitDepth;
use super::image::BitMap;
use super::info_header::InfoHeader;
use super::pixel_data::PixelData;
use super::rgb_quad::RgbQuad;
use super::rgba::Rgba;

pub enum FileData {
    Bits(BitData),
    Pixels(PixelData),
}

impl FileData {
    ///
    /// Read in bytes from a from_slice and convert it into image data (pixels)
    ///
    pub fn from_slice(bit_stream: &[u8], info: &InfoHeader, colors: &RgbQuad) -> Option<FileData> {
        match info.get_bit_depth() {
            Some(b) => match b {
                BitDepth::Color2Bit | BitDepth::Color16Bit | BitDepth::Color256Bit => Some(
                    FileData::Bits(BitData::from_slice(bit_stream, info, b, colors)),
                ),
                BitDepth::AllColors | BitDepth::AllColorsAndShades => {
                    Some(FileData::Pixels(PixelData::from_slice(bit_stream, info, b)))
                }
            },
            None => None,
        }
    }

    ///
    /// Convert image data (pixels) from a bitmap into bits and bytes
    ///
    pub fn from_bitmap(bitmap: &BitMap, bit_depth: BitDepth) -> FileData {
        match bit_depth {
            BitDepth::Color2Bit | BitDepth::Color16Bit | BitDepth::Color256Bit => {
                FileData::Bits(BitData::from_bitmap(bitmap, bit_depth))
            }
            _ => FileData::Pixels(PixelData::from_bitmap(bitmap, bit_depth)),
        }
    }

    ///
    /// Get then length of the lists of colors
    ///
    pub fn len(&self) -> usize {
        match self {
            FileData::Bits(b) => b.len(),
            FileData::Pixels(p) => p.len(),
        }
    }

    ///
    /// get the size of the list of colors if they were to be convert
    ///
    pub fn get_bytes_size(&self) -> u32 {
        match self {
            FileData::Bits(b) => b.get_bytes_size(),
            FileData::Pixels(p) => p.get_bytes_size(),
        }
    }

    ///
    /// convert the list of colors to bytes
    ///
    pub fn as_bytes(&self) -> Vec<u8> {
        match self {
            FileData::Bits(b) => b.as_bytes(),
            FileData::Pixels(p) => p.as_bytes(),
        }
    }

    ///
    /// convert the list of colors to RGBA
    ///
    pub fn as_rgba(&self) -> Vec<Rgba> {
        match self {
            FileData::Bits(b) => b.as_rgba(),
            FileData::Pixels(p) => p.as_rgba(),
        }
    }
}

#[cfg(debug_assertions)]
impl std::fmt::Display for FileData {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            FileData::Bits(b) => write!(f, "{}", b),
            FileData::Pixels(p) => write!(f, "{}", p),
        }
    }
}