astro_rs/fits/header_value/
bitpix.rs

1//! Defines the BITPIX header value.
2
3use crate::fits::FitsHeaderError;
4
5use super::FitsHeaderValue;
6
7/// An enumeration of valid values corresponding to the BITPIX keyword.
8#[derive(Debug, Clone, Copy, PartialEq, Eq)]
9pub enum Bitpix {
10    /// Indicates each data element is an unsigned 8 bit integer value.
11    U8,
12    /// Indicates each data element is a signed 16 bit integer value.
13    I16,
14    /// Indicates each data element is a signed 32 bit integer value.
15    I32,
16    /// Indicates each data element is a signed 32 bit float value.
17    F32,
18    /// Indicates each data element is a signed 64 bit float value.
19    F64,
20}
21
22impl Bitpix {
23    /// Gets the number of bits that represent a value in the data section of the HDU.
24    pub fn value(&self) -> usize {
25        match self {
26            Bitpix::U8 => 8,
27            Bitpix::I16 => 16,
28            Bitpix::I32 => 32,
29            Bitpix::F32 => 32,
30            Bitpix::F64 => 64,
31        }
32    }
33}
34
35impl FitsHeaderValue for Bitpix {
36    fn from_bytes(raw: Vec<u8>) -> Result<Self, FitsHeaderError> {
37        match raw.as_slice() {
38            b"8" => Ok(Bitpix::U8),
39            b"16" => Ok(Bitpix::I16),
40            b"32" => Ok(Bitpix::I32),
41            b"-32" => Ok(Bitpix::F32),
42            b"-64" => Ok(Bitpix::F64),
43            _ => Err(FitsHeaderError::DeserializationError {
44                found: raw,
45                intent: String::from("header card bitpix value"),
46            }),
47        }
48    }
49
50    fn to_bytes(&self) -> [u8; 70] {
51        let mut result = [b' '; 70];
52        match *self {
53            Bitpix::U8 => result[19] = b'8',
54            Bitpix::I16 => {
55                let value_raw = b"16";
56                let start = 20 - value_raw.len();
57                for (i, b) in value_raw.iter().enumerate() {
58                    result[start + i] = *b;
59                }
60            }
61            Bitpix::I32 => {
62                let value_raw = b"32";
63                let start = 20 - value_raw.len();
64                for (i, b) in value_raw.iter().enumerate() {
65                    result[start + i] = *b;
66                }
67            }
68            Bitpix::F32 => {
69                let value_raw = b"-32";
70                let start = 20 - value_raw.len();
71                for (i, b) in value_raw.iter().enumerate() {
72                    result[start + i] = *b;
73                }
74            }
75            Bitpix::F64 => {
76                let value_raw = b"-64";
77                let start = 20 - value_raw.len();
78                for (i, b) in value_raw.iter().enumerate() {
79                    result[start + i] = *b;
80                }
81            }
82        }
83        result
84    }
85}