astroimsim-data 0.1.4

Data package for astroimsim ecosystem.
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
129
130
131
132
133
134
135

use std::fs;
use astroimsim_geometry::coordinate_system::CoordinateSystem;
use astroimsim_geometry::grid2d::{Corners, GRID2D};
use astroimsim_geometry::points::Point;
use crate::psf::{DataFile, PSF, Load};

#[derive(Debug)]
pub struct PsfGrid {
    label:&'static str,
    grid: GRID2D,
    data:Vec<(usize,PSF)>,
    valid: bool,
    directory_path:&'static str,
    center_fits_keys:(&'static str, &'static str),

}

impl PsfGrid{
    pub fn new(label:&'static str,grid: GRID2D,directory_path:&'static str,center_fits_keys:(&'static str, &'static str)) -> PsfGrid{
        PsfGrid{
            label,
            data: vec![],
            grid: grid,
            valid:false,
            directory_path,
            center_fits_keys,
        }
    }
    pub fn load_data_frames(&mut self, x_num:usize,y_num:usize){
        println!("Loading data frames into grid. This overwrites any data previously loaded");
        let mut data = vec![];
        let paths = fs::read_dir(self.directory_path).unwrap();
        let mut counter = 0;
        for path in paths {
            println!("loading {:?}",path);
            counter += 1;
            let path = path.unwrap().path();

            let frame = PSF::load_file(
                path,
                (Load::FromKey(self.center_fits_keys.0.to_string()), Load::FromKey(self.center_fits_keys.1.to_string())),
                (Load::FromValue(self.grid.x_size),Load::FromValue(self.grid.y_size)),
                x_num,y_num,
            );
            let frame_index = frame.snap_to_grid(&self.grid);
            data.push((frame_index,frame))
        }
        data.sort_by_key(|x|x.0);
        self.data = data;
        println!("Loaded {counter} files into a Grid Struct from {:?}",self.directory_path);
        assert_eq!(counter,self.grid.num_points,"Loaded the wrong number of PSF files");
    }



    pub fn validate(&mut self) -> bool {
        //check to make sure there are the same number of data frames as there are grid points
        if self.data.len() != self.grid.num_points{
            println!("Validation failed: expected {:?} data frames, have {:?}",self.grid.num_points,self.data.len());
            self.valid = false;
            return false
        };
        //check to make sure that every grid point has a data frame
        let mut missing = Vec::new();
        let mut counter = 0;
        for grid_number in 0..self.grid.num_points{
            counter += 1;
            if !self.data.iter().any(|(index,_)| *index==grid_number) {
                missing.push(grid_number)
            }
        };
        if missing.len() > 0{
            println!("Validation failed! Missing data frames for the following grid positions: {:?} ",missing);
            self.valid = false;
            false
        }else{
            self.data.sort_by_key(|x|x.0);
            self.valid = true;
            true
        }}


    pub fn interpolated_psf(&self, point:&Point) -> Vec<Vec<f32>>{
        //println!("Converting from {:?}", point);

        //  println!("To {:?}",(x,y));


        let interpolation_data = self.grid.interpolation_coefficients(&point.clone());

        /*
        let psf_files = interpolation_data.corners
            .iter()
            .map(|index|self.data[index].clone()).collect();
        let q11 = self.data[Q11].clone();
        let q12 = self.data[Q12].clone();
        let q21 = self.data[Q21].clone();
        let q22 = self.data[Q22].clone();

        assert_eq!(q11.0,Q11);
        assert_eq!(q12.0,Q12);
        assert_eq!(q21.0,Q21);
        assert_eq!(q22.0,Q22);

        let interpolated_data:Vec<f32> =
            q11.1.data.into_iter().flatten().zip(
                q12.1.data.into_iter().flatten().zip(
                    q21.1.data.into_iter().flatten().zip(
                        q22.1.data.into_iter().flatten()))).map(
                |(q11,(q12,(q21,q22)))| {
                    (q11*c11 as f32 + q12*c12 as f32 + q21*c21 as f32 + q22*c22 as f32)/normalization as f32
                }).collect();
        PSF::repack_data(interpolated_data)

         */
        vec![vec![]]



    }




    pub fn grid_psf(&self, index:usize)-> Vec<Vec<f32>>{
        let (i, psf) = self.data[index].clone();
        assert_eq!(index,i);
        psf.data

    }

}