tetra3 0.4.0

Rust implementation of Tetra3: Fast and robust star plate solver
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

use std::path::Path;

#[allow(dead_code)]
pub struct GaiaStar {
    pub source_id: i64,
    pub ra_deg: f32,
    pub dec_deg: f32,
    pub phot_g_mean_mag: f32,
    pub phot_bp_mean_mag: f32,
    pub phot_rp_mean_mag: f32,
    pub parallax: Option<f32>,
    pub pmra: Option<f32>,
    pub pmdec: Option<f32>,
}

#[allow(dead_code)]
pub fn read_gaia_csv<P: AsRef<Path>>(file: P) -> anyhow::Result<Vec<GaiaStar>> {
    let mut rdr = csv::Reader::from_path(file)?;
    rdr.records()
        .into_iter()
        .skip(1)
        .map(|result| {
            let record = result?;
            let source_id: i64 = record.get(0).unwrap_or("").parse().unwrap_or(0);
            let ra: f32 = record.get(1).unwrap_or("").parse().unwrap_or(0.0);
            let dec: f32 = record.get(2).unwrap_or("").parse().unwrap_or(0.0);
            let phot_g_mean_mag: f32 = record.get(3).unwrap_or("").parse().unwrap_or(0.0);
            let phot_bp_mean_mag: f32 = record.get(4).unwrap_or("").parse().unwrap_or(0.0);
            let phot_rp_mean_mag: f32 = record.get(5).unwrap_or("").parse().unwrap_or(0.0);
            let parallax: Option<f32> = match record.get(6) {
                Some(s) if !s.is_empty() => s.parse().ok(),
                _ => None,
            };
            let pmra: Option<f32> = match record.get(7) {
                Some(s) if !s.is_empty() => s.parse().ok(),
                _ => None,
            };
            let pmdec: Option<f32> = match record.get(8) {
                Some(s) if !s.is_empty() => s.parse().ok(),
                _ => None,
            };

            Ok(GaiaStar {
                source_id,
                ra_deg: ra,
                dec_deg: dec,
                phot_g_mean_mag,
                phot_bp_mean_mag,
                phot_rp_mean_mag,
                parallax,
                pmra,
                pmdec,
            })
        })
        .collect::<Result<Vec<GaiaStar>, csv::Error>>()
        .map_err(|e| e.into())
}

/// Load a Gaia catalog from the binary format.
///
/// Binary format spec:
/// - Header: magic "GDR3" (4 bytes) + version (u32 LE, value 1) + num_stars (u64 LE)
/// - Per star (36 bytes): source_id (i64 LE) + ra (f64 LE) + dec (f64 LE) + mag (f32 LE) + pmra (f32 LE) + pmdec (f32 LE)
#[allow(dead_code)]
pub fn load_gaia_binary<P: AsRef<Path>>(path: P) -> Result<Vec<GaiaStar>, Box<dyn std::error::Error>> {
    use std::io::Read;

    let mut file = std::fs::File::open(path)?;
    let mut header = [0u8; 16];
    file.read_exact(&mut header)?;

    // Validate magic
    if &header[0..4] != b"GDR3" {
        return Err("Invalid magic: expected GDR3".into());
    }

    // Validate version
    let version = u32::from_le_bytes(header[4..8].try_into().unwrap());
    if version != 1 {
        return Err(format!("Unsupported version: {}, expected 1", version).into());
    }

    let num_stars = u64::from_le_bytes(header[8..16].try_into().unwrap()) as usize;

    let record_size = 36;
    let mut buf = vec![0u8; num_stars * record_size];
    file.read_exact(&mut buf)?;

    let mut stars = Vec::with_capacity(num_stars);
    for i in 0..num_stars {
        let offset = i * record_size;
        let rec = &buf[offset..offset + record_size];

        let source_id = i64::from_le_bytes(rec[0..8].try_into().unwrap());
        let ra = f64::from_le_bytes(rec[8..16].try_into().unwrap());
        let dec = f64::from_le_bytes(rec[16..24].try_into().unwrap());
        let mag = f32::from_le_bytes(rec[24..28].try_into().unwrap());
        let pmra = f32::from_le_bytes(rec[28..32].try_into().unwrap());
        let pmdec = f32::from_le_bytes(rec[32..36].try_into().unwrap());

        stars.push(GaiaStar {
            source_id,
            ra_deg: ra as f32,
            dec_deg: dec as f32,
            phot_g_mean_mag: mag,
            phot_bp_mean_mag: 0.0,
            phot_rp_mean_mag: 0.0,
            parallax: None,
            pmra: Some(pmra),
            pmdec: Some(pmdec),
        });
    }

    Ok(stars)
}

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

    #[test]
    #[ignore]
    fn load_gaia_catalog() {
        let fname = "data/gaia_bright_stars.csv";
        let stars = read_gaia_csv(fname).expect("Failed to read Gaia catalog file");
        assert!(!stars.is_empty());
    }
}