ceo 0.1.0

CUDA Engined Optics
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

#ifndef __SHACKHARTMANN__
#define __SHACKHARTMANN__

#ifndef __UTILITIES_H__
#include "utilities.h"
#endif

#ifndef __SOURCE_H__
#include "source.h"
#endif

#ifndef __IMAGING_H__
#include "imaging.h"
#endif

#ifndef __CENTROIDING_H__
#include "centroiding.h"
#endif

struct shackHartmann {

  int N_WFS;
  int N_SIDE_LENSLET, N_LENSLET;
  int N_ACTUATOR;
  int N_SLOPE;
  float *d__c0, *d__cx0, *d__cy0;
  mask valid_lenslet;
  mask valid_actuator;
  imaging camera;
  centroiding data_proc;
  int DFT_osf;
  float lenslet_pitch;
  float pixel_scale;
  float intensity_threshold;
  float slopes_gain;
  void setup(int N_SIDE_LENSLET, int N_PX_LENSLET, float d,
             int DFT_osf_, int N_PX_IMAGE, int BIN_IMAGE, int N_GS);
  void cleanup(void);
  void identify_valid_lenslet(source *src, float threshold);
  void set_reference_slopes(source *src);
  void calibrate(source *src, float threshold);
  void propagate(source *gs);
  void propagate(source *gs, int *maks);
  void process(void);
  void analyze(source *gs);
  void get_valid_reference_slopes(float *d__valid_slopes);
  void get_valid_slopes(float *d__valid_slopes);
  void masked_slopes(float *d__valid_slopes, mask *lenslet_mask);
  void get_valid_slopes_norm(float *d__valid_slopes_norm);
  float* get_frame_dev_ptr(void);
  void update_lenslet(float *filter);
};
 
struct geometricShackHartmann {

  int N_WFS;
  int N_SIDE_LENSLET, N_LENSLET;
  int N_ACTUATOR;
  int N_SLOPE;
  float *d__c0, *d__cx0, *d__cy0;
  mask valid_lenslet;
  mask valid_actuator;
  imaging camera;
  centroiding data_proc;
  int DFT_osf;
  float lenslet_pitch;
  float pixel_scale;
  float intensity_threshold;
  float slopes_gain;
  float *_d__c_, *_d__cx_, *_d__cy_;
  int N_FRAME;
  cublasHandle_t handle;
  void setup(int N_SIDE_LENSLET, float d, int N_GS);
  void cleanup(void);
  void identify_valid_lenslet(source *src, float threshold);
  void set_reference_slopes(source *src);
  void calibrate(source *src, float threshold);
  void propagate(source *gs);
  void propagate(source *gs, int *maks);
  void process(void);
  void analyze(source *gs);
  void get_valid_reference_slopes(float *d__valid_slopes);
  void get_valid_slopes(float *d__valid_slopes);
  void masked_slopes(float *d__valid_slopes, mask *lenslet_mask);
  void get_valid_slopes_norm(float *d__valid_slopes_norm);
  void folded_slopes(float *d__valid_slopes, mask *lenslet_mask);
  void reset(void);
};

struct tt7 {

  int N_WFS;
  int N_SIDE_LENSLET, N_LENSLET;
  int N_ACTUATOR;
  int N_SLOPE;
  float *d__c0, *d__cx0, *d__cy0;
  mask valid_lenslet;
  mask valid_actuator;
  imaging camera;
  centroiding data_proc;
  int DFT_osf;
  float lenslet_pitch;
  float pixel_scale;
  float intensity_threshold;
  float slopes_gain;
  void setup(int N_SIDE_LENSLET, int N_PX_LENSLET, float d,
             int DFT_osf_, int N_PX_IMAGE, int BIN_IMAGE, int N_GS);
  void cleanup(void);
  void identify_valid_lenslet(source *src, float threshold);
  void set_reference_slopes(source *src);
  void calibrate(source *src, float threshold);
  void propagate(source *gs);
  void propagate(source *gs, int *maks);
  void process(void);
  void analyze(source *gs);
  void get_valid_reference_slopes(float *d__valid_slopes);
  void get_valid_slopes(float *d__valid_slopes);
  void masked_slopes(float *d__valid_slopes, mask *lenslet_mask);
  void get_valid_slopes_norm(float *d__valid_slopes_norm);
  float* get_frame_dev_ptr(void);
  void update_lenslet(float *filter);
};

#endif // __SHACKHARTMANN__