crseo 2.5.3

Cuda Engined Optics Rust Interface
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

use crate::{Builder, Centroiding};

use super::imaging::ImagingBuilder;

/// Centroiding builder
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct CentroidingBuilder {
    n_lenslet: usize,
    n_sensor: usize,
    data_units: f64,
}

impl CentroidingBuilder {
    pub fn n_lenslet(mut self, n_lenslet: usize) -> Self {
        self.n_lenslet = n_lenslet;
        self
    }
    pub fn n_sensor(mut self, n_sensor: usize) -> Self {
        self.n_sensor = n_sensor;
        self
    }
}

impl Default for CentroidingBuilder {
    fn default() -> Self {
        Self {
            n_lenslet: 1,
            n_sensor: 1,
            data_units: 1.,
        }
    }
}

impl From<&ImagingBuilder> for CentroidingBuilder {
    fn from(value: &ImagingBuilder) -> Self {
        Self {
            n_lenslet: value.lenslet_array.n_side_lenslet,
            n_sensor: value.n_sensor as usize,
            ..Default::default()
        }
    }
}

impl Builder for CentroidingBuilder {
    type Component = Centroiding;

    fn build(self) -> crate::Result<Self::Component> {
        let mut cmpt = Centroiding {
            _c_: Default::default(),
            _c_mask_: Default::default(),
            n_lenslet_total: 0,
            n_centroids: 0,
            units: 1f32,
            flux: vec![],
            valid_lenslets: vec![],
            n_valid_lenslet: vec![],
            centroids: vec![],
            xy_mean: None,
        };
        cmpt.n_lenslet_total = self.n_lenslet * self.n_lenslet;
        let n = cmpt.n_lenslet_total * self.n_sensor;
        cmpt.n_valid_lenslet = vec![cmpt.n_lenslet_total; self.n_sensor];
        cmpt.n_centroids = 2 * n;
        unsafe {
            cmpt._c_.setup(self.n_lenslet as i32, self.n_sensor as i32);
            cmpt._c_mask_.setup(n as i32);
        }
        cmpt.flux = vec![0.0; n];
        cmpt.centroids = vec![0.0; cmpt.n_centroids];
        cmpt.units = self.data_units as f32;
        cmpt.valid_lenslets(None, Some(vec![1i8; n]));
        Ok(cmpt)
    }
}