fitskit 0.2.0

Pure Rust FITS v4.0 reader/writer with tile-compression read and write
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

use crate::error::{Error, Result};

/// Size of one FITS block in bytes.
pub const BLOCK_SIZE: usize = 2880;

/// Size of one header record (keyword card) in bytes.
pub const RECORD_SIZE: usize = 80;

/// Number of records per header block.
pub const RECORDS_PER_BLOCK: usize = BLOCK_SIZE / RECORD_SIZE;

/// BITPIX values per FITS standard.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Bitpix {
    U8,
    I16,
    I32,
    I64,
    F32,
    F64,
}

impl Bitpix {
    pub fn to_i64(self) -> i64 {
        match self {
            Bitpix::U8 => 8,
            Bitpix::I16 => 16,
            Bitpix::I32 => 32,
            Bitpix::I64 => 64,
            Bitpix::F32 => -32,
            Bitpix::F64 => -64,
        }
    }

    pub fn from_i64(val: i64) -> Result<Self> {
        match val {
            8 => Ok(Bitpix::U8),
            16 => Ok(Bitpix::I16),
            32 => Ok(Bitpix::I32),
            64 => Ok(Bitpix::I64),
            -32 => Ok(Bitpix::F32),
            -64 => Ok(Bitpix::F64),
            _ => Err(Error::UnsupportedBitpix(val)),
        }
    }

    pub fn bytes_per_value(self) -> usize {
        match self {
            Bitpix::U8 => 1,
            Bitpix::I16 => 2,
            Bitpix::I32 => 4,
            Bitpix::I64 => 8,
            Bitpix::F32 => 4,
            Bitpix::F64 => 8,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn bitpix_round_trip() {
        for bp in [
            Bitpix::U8,
            Bitpix::I16,
            Bitpix::I32,
            Bitpix::I64,
            Bitpix::F32,
            Bitpix::F64,
        ] {
            assert_eq!(Bitpix::from_i64(bp.to_i64()).unwrap(), bp);
        }
    }

    #[test]
    fn bitpix_invalid() {
        assert!(Bitpix::from_i64(0).is_err());
        assert!(Bitpix::from_i64(128).is_err());
    }

    #[test]
    fn bytes_per_value() {
        assert_eq!(Bitpix::U8.bytes_per_value(), 1);
        assert_eq!(Bitpix::I16.bytes_per_value(), 2);
        assert_eq!(Bitpix::F64.bytes_per_value(), 8);
    }
}