mxlib
c++ tools for analyzing astronomical data and other tasks by Jared R. Males. [git repo]
Loading...
Searching...
No Matches
zernike_test.cpp
Go to the documentation of this file.
1/** \file zernike_test.cpp
2 * \brief Tests Zernike-index and normalization utilities.
3 */
4#include "../../catch2/catch.hpp"
5
6#include <Eigen/Dense>
7
8#define MX_NO_ERROR_REPORTS
9
10#include "../../../include/sigproc/zernike.hpp"
11
12/** testing noll_nm
13 *
14 * Verify calculation of Noll nm values from j.
15 * Goes through each of the cases in Table 1 of \cite noll_1976
16 *
17 */
18/**
19 * \ingroup zernike_unit_tests
20 */
21TEST_CASE( "testing noll_nm", "[sigproc::zernike]" )
22{
23
24 GIVEN( "a j value" )
25 {
26 WHEN( "j==0" )
27 {
28 int m, n;
29 int rv = mx::sigproc::noll_nm( n, m, 0 );
30 REQUIRE( rv == -1 );
31 }
32
33 WHEN( "j==1" )
34 {
35 int m, n;
36 int rv = mx::sigproc::noll_nm( n, m, 1 );
37 REQUIRE( rv == 0 );
38 REQUIRE( n == 0 );
39 REQUIRE( m == 0 );
40 }
41
42 WHEN( "j==2" )
43 {
44 int m, n;
45 int rv = mx::sigproc::noll_nm( n, m, 2 );
46 REQUIRE( rv == 0 );
47 REQUIRE( n == 1 );
48 REQUIRE( m == 1 );
49 }
50
51 WHEN( "j==3" )
52 {
53 int m, n;
54 int rv = mx::sigproc::noll_nm( n, m, 3 );
55 REQUIRE( rv == 0 );
56 REQUIRE( n == 1 );
57 REQUIRE( m == -1 );
58 }
59
60 WHEN( "j==4" )
61 {
62 int m, n;
63 int rv = mx::sigproc::noll_nm( n, m, 4 );
64 REQUIRE( rv == 0 );
65 REQUIRE( n == 2 );
66 REQUIRE( m == 0 );
67 }
68
69 WHEN( "j==5" )
70 {
71 int m, n;
72 int rv = mx::sigproc::noll_nm( n, m, 5 );
73 REQUIRE( rv == 0 );
74 REQUIRE( n == 2 );
75 REQUIRE( m == -2 );
76 }
77
78 WHEN( "j==6" )
79 {
80 int m, n;
81 int rv = mx::sigproc::noll_nm( n, m, 6 );
82 REQUIRE( rv == 0 );
83 REQUIRE( n == 2 );
84 REQUIRE( m == 2 );
85 }
86
87 WHEN( "j==7" )
88 {
89 int m, n;
90 int rv = mx::sigproc::noll_nm( n, m, 7 );
91 REQUIRE( rv == 0 );
92 REQUIRE( n == 3 );
93 REQUIRE( m == -1 );
94 }
95
96 WHEN( "j==8" )
97 {
98 int m, n;
99 int rv = mx::sigproc::noll_nm( n, m, 8 );
100 REQUIRE( rv == 0 );
101 REQUIRE( n == 3 );
102 REQUIRE( m == 1 );
103 }
104
105 WHEN( "j==9" )
106 {
107 int m, n;
108 int rv = mx::sigproc::noll_nm( n, m, 9 );
109 REQUIRE( rv == 0 );
110 REQUIRE( n == 3 );
111 REQUIRE( m == -3 );
112 }
113
114 WHEN( "j==10" )
115 {
116 int m, n;
117 int rv = mx::sigproc::noll_nm( n, m, 10 );
118 REQUIRE( rv == 0 );
119 REQUIRE( n == 3 );
120 REQUIRE( m == 3 );
121 }
122
123 WHEN( "j==11" )
124 {
125 int m, n;
126 int rv = mx::sigproc::noll_nm( n, m, 11 );
127 REQUIRE( rv == 0 );
128 REQUIRE( n == 4 );
129 REQUIRE( m == 0 );
130 }
131
132 WHEN( "j==12" )
133 {
134 int m, n;
135 int rv = mx::sigproc::noll_nm( n, m, 12 );
136 REQUIRE( rv == 0 );
137 REQUIRE( n == 4 );
138 REQUIRE( m == 2 );
139 }
140
141 WHEN( "j==13" )
142 {
143 int m, n;
144 int rv = mx::sigproc::noll_nm( n, m, 13 );
145 REQUIRE( rv == 0 );
146 REQUIRE( n == 4 );
147 REQUIRE( m == -2 );
148 }
149
150 WHEN( "j==14" )
151 {
152 int m, n;
153 int rv = mx::sigproc::noll_nm( n, m, 14 );
154 REQUIRE( rv == 0 );
155 REQUIRE( n == 4 );
156 REQUIRE( m == 4 );
157 }
158
159 WHEN( "j==15" )
160 {
161 int m, n;
162 int rv = mx::sigproc::noll_nm( n, m, 15 );
163 REQUIRE( rv == 0 );
164 REQUIRE( n == 4 );
165 REQUIRE( m == -4 );
166 }
167
168 WHEN( "j==16" )
169 {
170 int m, n;
171 int rv = mx::sigproc::noll_nm( n, m, 16 );
172 REQUIRE( rv == 0 );
173 REQUIRE( n == 5 );
174 REQUIRE( m == 1 );
175 }
176
177 WHEN( "j==17" )
178 {
179 int m, n;
180 int rv = mx::sigproc::noll_nm( n, m, 17 );
181 REQUIRE( rv == 0 );
182 REQUIRE( n == 5 );
183 REQUIRE( m == -1 );
184 }
185
186 WHEN( "j==18" )
187 {
188 int m, n;
189 int rv = mx::sigproc::noll_nm( n, m, 18 );
190 REQUIRE( rv == 0 );
191 REQUIRE( n == 5 );
192 REQUIRE( m == 3 );
193 }
194
195 WHEN( "j==19" )
196 {
197 int m, n;
198 int rv = mx::sigproc::noll_nm( n, m, 19 );
199 REQUIRE( rv == 0 );
200 REQUIRE( n == 5 );
201 REQUIRE( m == -3 );
202 }
203
204 WHEN( "j==20" )
205 {
206 int m, n;
207 int rv = mx::sigproc::noll_nm( n, m, 20 );
208 REQUIRE( rv == 0 );
209 REQUIRE( n == 5 );
210 REQUIRE( m == 5 );
211 }
212
213 WHEN( "j==21" )
214 {
215 int m, n;
216 int rv = mx::sigproc::noll_nm( n, m, 21 );
217 REQUIRE( rv == 0 );
218 REQUIRE( n == 5 );
219 REQUIRE( m == -5 );
220 }
221
222 WHEN( "j==22" )
223 {
224 int m, n;
225 int rv = mx::sigproc::noll_nm( n, m, 22 );
226 REQUIRE( rv == 0 );
227 REQUIRE( n == 6 );
228 REQUIRE( m == 0 );
229 }
230
231 WHEN( "j==23" )
232 {
233 int m, n;
234 int rv = mx::sigproc::noll_nm( n, m, 23 );
235 REQUIRE( rv == 0 );
236 REQUIRE( n == 6 );
237 REQUIRE( m == -2 );
238 }
239
240 WHEN( "j==24" )
241 {
242 int m, n;
243 int rv = mx::sigproc::noll_nm( n, m, 24 );
244 REQUIRE( rv == 0 );
245 REQUIRE( n == 6 );
246 REQUIRE( m == 2 );
247 }
248
249 WHEN( "j==25" )
250 {
251 int m, n;
252 int rv = mx::sigproc::noll_nm( n, m, 25 );
253 REQUIRE( rv == 0 );
254 REQUIRE( n == 6 );
255 REQUIRE( m == -4 );
256 }
257
258 WHEN( "j==26" )
259 {
260 int m, n;
261 int rv = mx::sigproc::noll_nm( n, m, 26 );
262 REQUIRE( rv == 0 );
263 REQUIRE( n == 6 );
264 REQUIRE( m == 4 );
265 }
266 }
267}
268
269/** testing zernikeQNorm
270 * Verify compilation and execution of zernikeQNorm.
271 * This does not validate the output.
272 */
273/**
274 * \ingroup zernike_unit_tests
275 */
276TEST_CASE( "testing zernikeQNorm", "[sigproc::zernike]" )
277{
278 GIVEN( "an array" )
279 {
280 WHEN( "j==1" )
281 {
282 Eigen::Array<double, -1, -1> arr, k, phi;
283 arr.resize( 32, 32 );
284 k.resize( 32, 32 );
285 phi.resize( 32, 32 );
286
287 for( int i = 0; i < 32; ++i )
288 {
289 for( int j = 0; j < 32; ++j )
290 {
291 double kx = i - 5;
292 double ky = j - 15;
293 k( i, j ) = sqrt( kx * kx + ky * ky );
294 phi( i, j ) = atan( ky / kx );
295 }
296 }
297 int rv = mx::sigproc::zernikeQNorm( arr, k, phi, 1 );
298 REQUIRE( rv == 0 );
299 }
300 }
301}
mx::sigproc::noll_nm
int noll_nm(int &n, int &m, int j)
Get the Zernike coefficients n,m corrresponding the Noll index j.
Definition zernike.cpp:35
mx::sigproc::zernikeQNorm
realT zernikeQNorm(realT k, realT phi, int n, int m)
Calculate the square-normed Fourier transform of a Zernike polynomial at position (k,...
Definition zernike.hpp:598
TEST_CASE
TEST_CASE("testing noll_nm", "[sigproc::zernike]")
Definition zernike_test.cpp:21
zernike.hpp
Working with the Zernike polynomials.