36 #define POSIX_SOURCE 1
37 #include "sinfo_vltPort.h"
46 #include "sinfo_function_1d.h"
47 #include "sinfo_cube_construct.h"
48 #include "sinfo_spectrum_ops.h"
49 #include "sinfo_wave_calibration.h"
50 #include "sinfo_utilities.h"
51 #include "sinfo_utils_wrappers.h"
52 #include "sinfo_local_types.h"
53 #include "sinfo_fft_base.h"
56 sinfo_sort_slitlets(
const int kslit);
60 sinfo_sort_slitlets_array(
const int slit,
int* row_index);
87 sinfo_new_convolve_ns_image_by_gauss( cpl_image * lineImage,
90 cpl_image * returnImage ;
91 float* row_buffer=NULL ;
100 if ( lineImage == NULL )
105 ilx=cpl_image_get_size_x(lineImage);
106 ily=cpl_image_get_size_y(lineImage);
107 pidata=cpl_image_get_data_float(lineImage);
115 if ( NULL == ( returnImage = cpl_image_new(ilx,ily,CPL_TYPE_FLOAT ) ))
120 podata=cpl_image_get_data_float(returnImage);
123 row_buffer=cpl_calloc(ily,
sizeof(
float)) ;
125 for ( row = 0 ; row < ily ; row++ )
127 for ( col = 0 ; col < ilx ; col++ )
129 if ( isnan(pidata[col+row*ilx]) )
131 row_buffer[col] = 0. ;
135 row_buffer[col] = pidata[col + row*ilx] ;
143 filter = sinfo_function1d_filter_lowpass( row_buffer,
147 for ( col = 0 ; col < ily ; col++ )
149 podata[col + row*ilx] = filter[col] ;
152 sinfo_function1d_del (filter) ;
154 cpl_free(row_buffer);
179 sinfo_north_south_test( cpl_image * ns_image,
184 float estimated_dist,
189 int i, j, k, m, row, col, n, ni, na ;
190 int position, counter;
191 int xdim, ndat, its, numpar ;
192 pixelvalue row_buf[cpl_image_get_size_x(ns_image)] ;
193 float sum, mean, maxval ;
196 float distances_buf[cpl_image_get_size_y(ns_image)][n_slitlets-1] ;
197 float x_position[n_slitlets] ;
198 float * xdat, * wdat ;
200 int found[3*n_slitlets], found_clean[3*n_slitlets] ;
201 int found_cleanit[3*n_slitlets] ;
204 int foundit, begin, end ;
210 if ( ns_image == NULL )
215 ilx=cpl_image_get_size_x(ns_image);
217 pidata=cpl_image_get_data_float(ns_image);
220 if ( n_slitlets < 1 )
225 if ( halfWidth < 0 || halfWidth >= estimated_dist )
242 if (NULL == (distances = (
float *) cpl_calloc ( n_slitlets - 1 ,
250 for ( row = bottom ; row < top ; row++ )
252 int zeroindicator = 0 ;
255 for ( i = 0 ; i < n_slitlets-1 ; i++ )
257 distances_buf[row][i] = ZERO ;
261 for ( col = 0 ; col < ilx ; col++ )
263 row_buf[col] = pidata[col + row*ilx] ;
269 for ( i = 0 ; i < ilx ; i++ )
271 if ( isnan(row_buf[i]) )
278 mean = sum / (float)n ;
283 for ( i = 0 ; i < ilx ; i++ )
285 if (isnan(row_buf[i]))
289 if ( row_buf[i] > sqrt(mean*mean*9) )
296 if ( n < n_slitlets )
299 "in row: %d, found number: %d, mean: %g",
307 for ( i = 1 ; i < n ; i ++ )
309 if ( found[i] - found[i-1] < halfWidth )
311 begin = found[i] - halfWidth ;
316 end = found[i] + halfWidth ;
325 for ( j = begin ; j <= end ; j++ )
328 if (isnan(row_buf[j]))
332 if (row_buf[j] >= maxval )
334 maxval = row_buf[j] ;
338 if (maxval == -FLT_MAX)
342 for ( k = 0 ; k < na ; k++ )
344 if ( found_cleanit[k] >= begin &&
345 found_cleanit[k] < foundit )
350 for ( k = 0 ; k < n ; k++ )
352 if ( found[k] == foundit)
355 if ( found_cleanit[na-1] != found[k] )
357 found_cleanit[na] = found[k] ;
362 found_cleanit[na] = found[k] ;
372 found_cleanit[na] = found[0] ;
374 found_cleanit[na] = found[1] ;
380 if ( found_cleanit[na-1] != found[i-1])
382 found_cleanit[na] = found[i-1] ;
385 if ( found_cleanit[na-1] != found[i])
387 found_cleanit[na] = found[i] ;
393 found_cleanit[na] = found[i] ;
401 for ( i = 1 ; i < na ; i++ )
403 if ( (
float)(found_cleanit[i] - found_cleanit[i-1]) <
404 (estimated_dist - devtol) ||
405 (
float)(found_cleanit[i] - found_cleanit[i-1]) >
406 (estimated_dist + devtol) )
412 found_clean[j-1] = found_cleanit[i-1] ;
413 found_clean[j] = found_cleanit[i] ;
418 if ( j > n_slitlets )
422 for ( i = 1 ; i < j ; i++ )
424 if ( (
float)(found_clean[i] - found_clean[i-1]) <
425 (estimated_dist - devtol ) ||
426 (
float)(found_clean[i] - found_clean[i-1]) >
427 (estimated_dist + devtol ) )
434 found_clean[ni-1] = found_clean[i-1] ;
435 found_clean[ni] = found_clean[i] ;
439 if ( ni != n_slitlets )
442 " found in row: %d, found number: %d",
451 else if ( j < n_slitlets )
453 cpl_msg_debug (
"north_south_test3:",
454 "t3 wrong number of intensity columns "
455 "found in row: %d , found number: %d, mean: %g\n",
461 for ( i = 0 ; i < j ; i++ )
464 if ( NULL == (line = sinfo_new_vector (2*halfWidth + 1)) )
467 cpl_free(distances) ;
472 xdat = (
float *) cpl_calloc( line -> n_elements,
sizeof (
float) ) ;
473 wdat = (
float *) cpl_calloc( line -> n_elements,
sizeof (
float) ) ;
474 mpar = (
int *) cpl_calloc( MAXPAR,
sizeof (
int) ) ;
475 par = sinfo_new_fit_params(1) ;
478 for ( k = found_clean[i]-halfWidth ;
479 k <= found_clean[i]+halfWidth ; k++ )
489 else if ( isnan(row_buf[k]) )
496 line -> data[m] = row_buf[k] ;
500 if ( zeroindicator == 1 )
502 sinfo_new_destroy_vector(line) ;
506 sinfo_new_destroy_fit_params(&par) ;
515 position = -INT32_MAX ;
516 for ( k = 0 ; k < m ; k++ )
520 if ( line -> data[k] >= maxval )
522 maxval = line -> data[k] ;
529 ndat = line -> n_elements ;
534 (*par) -> fit_par[1] = fwhm ;
535 (*par) -> fit_par[2] = (float) position ;
536 (*par) -> fit_par[3] = (float) (line -> data[0] +
537 line -> data[line->n_elements - 1]) / 2.0 ;
538 (*par) -> fit_par[0] = maxval - ((*par) -> fit_par[3]) ;
542 if ( (*par) -> fit_par[0] < minDiff )
545 "in row: %d in slitlet %d\n", row, i) ;
546 sinfo_new_destroy_vector(line) ;
550 sinfo_new_destroy_fit_params(&par) ;
554 for ( k = 0 ; k < MAXPAR ; k++ )
556 (*par) -> derv_par[k] = 0.0 ;
561 if ( 0 > ( iters = sinfo_new_lsqfit_c( xdat, &xdim,
562 line -> data, wdat, &ndat,
564 (*par) -> derv_par, mpar,
565 &numpar, &tol, &its, &lab)) )
573 sinfo_new_destroy_vector(line) ;
577 sinfo_new_destroy_fit_params(&par) ;
582 if ( (*par) -> fit_par[0] <= 0. ||
583 (*par) -> fit_par[1] <= 0. ||
584 (*par) -> fit_par[2] < 0. )
587 "not used! in row %d in slitlet %d",
589 sinfo_new_destroy_vector(line) ;
593 sinfo_new_destroy_fit_params(&par) ;
599 (*par) -> fit_par[2] = (float) (found_clean[i] - halfWidth) +
600 (*par) -> fit_par[2] ;
601 x_position[counter] = (*par) -> fit_par[2] ;
605 sinfo_new_destroy_fit_params(&par) ;
606 sinfo_new_destroy_vector ( line ) ;
611 if (zeroindicator == 1)
617 if ( counter != n_slitlets )
623 for ( i = 1 ; i < n_slitlets ; i++ )
625 distances_buf[row][i-1] = x_position[i] - x_position[i-1] ;
633 for ( i = 0 ; i < n_slitlets-1 ; i++ )
637 for ( row = bottom ; row < top ; row++ )
639 if ( fabs( distances_buf[row][i] - estimated_dist ) > devtol ||
640 isnan(distances_buf[row][i]) )
650 sum += distances_buf[row][i] ;
656 "completely!, deviations of distances from number "
657 "of slitlets too big\n" ) ;
658 cpl_free(distances) ;
663 distances[i] = sum / (float)n ;
698 sinfo_new_make_cube ( cpl_image * calibImage,
700 float * correct_diff_dist )
702 cpl_imagelist * returnCube ;
708 if ( NULL == calibImage )
713 ilx=cpl_image_get_size_x(calibImage);
714 ily=cpl_image_get_size_y(calibImage);
715 float* pidata=cpl_image_get_data_float(calibImage);
717 if ( NULL == distances )
723 if ( NULL == correct_diff_dist )
729 if ( N_SLITLETS != 32 )
734 imsize = ilx / N_SLITLETS ;
737 if ( NULL == (returnCube = cpl_imagelist_new()) )
744 for ( z = 0 ; z < ily ; z++ )
747 cpl_image* o_img=cpl_image_new(imsize,N_SLITLETS,CPL_TYPE_FLOAT);
748 float* podata=cpl_image_get_data_float(o_img);
751 int slit_index = -1 ;
753 for ( col = 0 ; col < ilx ; col++ )
755 if ( col % imsize == 0 )
760 if((slit_index=sinfo_sort_slitlets(kslit)) == -1) {
762 "spiffi image, there must be 32 slitlets!") ;
763 cpl_imagelist_delete(returnCube) ;
774 kpix = sinfo_new_nint(distances[kslit-1]) ;
781 correct_diff_dist[slit_index] = distances[kslit-1] -
787 correct_diff_dist[slit_index] = 0. ;
792 podata[recol+slit_index*imsize] = pidata[col+kpix+z*ilx];
795 if ( recol > imsize )
798 "image, shouldn't happen!\n") ;
799 cpl_imagelist_delete(returnCube) ;
820 sinfo_sort_slitlets(
const int kslit)
924 "spiffi image, there must be 32 slitlets!") ;
952 sinfo_sort_slitlets_array(
const int slit,
int* row_index)
1000 row_index[14] = 15 ;
1006 row_index[16] = 31 ;
1009 row_index[17] = 16 ;
1012 row_index[18] = 30 ;
1015 row_index[19] = 17 ;
1018 row_index[20] = 29 ;
1021 row_index[21] = 18 ;
1024 row_index[22] = 28 ;
1027 row_index[23] = 19 ;
1030 row_index[24] = 27 ;
1033 row_index[25] = 20 ;
1036 row_index[26] = 26 ;
1039 row_index[27] = 21 ;
1042 row_index[28] = 25 ;
1045 row_index[29] = 22 ;
1048 row_index[30] = 24 ;
1051 row_index[31] = 23 ;
1055 "image, there must be 32 slitlets!\n") ;
1087 sinfo_new_make_cube_spi ( cpl_image * calibImage,
1088 float ** slit_edges,
1091 cpl_imagelist * returnCube ;
1107 if ( NULL == calibImage )
1112 ilx=cpl_image_get_size_x(calibImage);
1113 ily=cpl_image_get_size_y(calibImage);
1114 pidata=cpl_image_get_data_float(calibImage);
1116 if ( NULL == slit_edges )
1118 sinfo_msg_error(
"no slit_edges array given from sinfo_fitSlits()!/n") ;
1122 if ( N_SLITLETS != 32 )
1127 imsize = ilx / N_SLITLETS ;
1130 if ( NULL == (row_index = (
int*) cpl_calloc(N_SLITLETS,
sizeof(
int)) ) )
1135 if ( NULL == (beginCol = (
int*) cpl_calloc(N_SLITLETS,
sizeof(
int)) ) )
1138 cpl_free(row_index) ;
1141 if ( NULL == (center = (
float*) cpl_calloc(N_SLITLETS,
sizeof(
float)) ) )
1144 cpl_free (row_index) ;
1145 cpl_free (beginCol) ;
1148 if ( NULL == (returnCube = cpl_imagelist_new()) )
1151 cpl_free (row_index) ;
1152 cpl_free (beginCol) ;
1158 for ( slit = 0 ; slit < N_SLITLETS ; slit++ )
1161 center[slit] = (slit_edges[slit][1] + slit_edges[slit][0]) / 2. ;
1167 if(-1 == sinfo_sort_slitlets_array(slit,row_index)) {
1168 cpl_imagelist_delete(returnCube) ;
1169 cpl_free (row_index) ;
1170 cpl_free (beginCol) ;
1176 float start = center[slit] - (float) (imsize - 1)/2. ;
1177 beginCol[slit] = sinfo_new_nint (start) ;
1179 float diff = start - (float)beginCol[slit] ;
1186 shift[row_index[slit]] = diff ;
1190 for ( z = 0 ; z < ily ; z++ )
1192 cpl_image* o_img=cpl_image_new(imsize,N_SLITLETS,CPL_TYPE_FLOAT);
1193 float* podata=cpl_image_get_data_float(o_img);
1194 for ( slit = 0 ; slit < N_SLITLETS ; slit++ )
1196 col_counter = beginCol[slit] ;
1198 for ( col = 0 ; col < imsize ; col++ )
1200 if ( col_counter > ilx-1 )
1204 if ( col_counter + z*ilx < 0 )
1206 podata[col+row_index[slit]*imsize] = pidata[0] ;
1210 podata[col+row_index[slit]*imsize]=pidata[col_counter+z*ilx];
1216 cpl_imagelist_set(returnCube,o_img,z);
1218 cpl_free (row_index) ;
1219 cpl_free (beginCol) ;
1257 sinfo_new_make_cube_dist ( cpl_image * calibImage,
1262 cpl_imagelist * returnCube ;
1277 if ( NULL == calibImage )
1282 ilx=cpl_image_get_size_x(calibImage);
1283 ily=cpl_image_get_size_y(calibImage);
1284 pidata=cpl_image_get_data_float(calibImage);
1286 if ( NULL == distances )
1288 sinfo_msg_error(
"no distances array given from north_south_test()!") ;
1292 if ( N_SLITLETS != 32 )
1297 imsize = ilx / N_SLITLETS ;
1300 if ( NULL == (row_index = (
int*) cpl_calloc(N_SLITLETS,
sizeof(
int)) ) )
1305 if ( NULL == (beginCol = (
int*) cpl_calloc(N_SLITLETS,
sizeof(
int)) ) )
1308 cpl_free(row_index) ;
1311 if ( NULL == (returnCube = cpl_imagelist_new()) )
1314 cpl_free(row_index) ;
1315 cpl_free(beginCol) ;
1322 for ( slit = 0 ; slit < N_SLITLETS ; slit++ )
1331 if(-1 == sinfo_sort_slitlets_array(slit,row_index)) {
1332 cpl_imagelist_delete(returnCube) ;
1333 cpl_free(row_index) ;
1334 cpl_free(beginCol) ;
1345 di += distances[slit-1] ;
1346 start = firstCol + di ;
1348 beginCol[slit] = sinfo_new_nint(start) ;
1352 float diff = start - (float)beginCol[slit] ;
1359 shift[row_index[slit]] = diff ;
1363 for ( z = 0 ; z < ily ; z++ )
1365 cpl_image* o_img=cpl_image_new(imsize,N_SLITLETS,CPL_TYPE_FLOAT);
1366 podata=cpl_image_get_data_float(o_img);
1367 for ( slit = 0 ; slit < N_SLITLETS ; slit++ )
1369 col_counter = beginCol[slit] ;
1371 for ( col = 0 ; col < imsize ; col++ )
1373 if ( col_counter > ilx-1 )
1377 if ( col_counter + z*ilx < 0 )
1379 podata[col+row_index[slit]*imsize] = podata[0] ;
1383 podata[col+row_index[slit]*imsize]=pidata[col_counter+z*ilx];
1389 cpl_imagelist_set(returnCube,o_img,z);
1391 cpl_free (row_index) ;
1392 cpl_free (beginCol) ;
1428 sinfo_new_make_3D_cube_dist ( cpl_image * calibImage,
1433 cpl_imagelist * returnCube ;
1445 if ( NULL == calibImage )
1450 ilx=cpl_image_get_size_x(calibImage);
1451 ily=cpl_image_get_size_y(calibImage);
1452 float* pidata=cpl_image_get_data_float(calibImage);
1454 if ( NULL == distances )
1456 sinfo_msg_error(
"no distances array given from north_south_test()!") ;
1460 if ( N_SLITLETS != 16 )
1465 imsize = ilx / N_SLITLETS ;
1468 if ( NULL == (row_index = (
int*) cpl_calloc(N_SLITLETS,
sizeof(
int)) ) )
1473 if ( NULL == (beginCol = (
int*) cpl_calloc(N_SLITLETS,
sizeof(
int)) ) )
1476 cpl_free(row_index) ;
1479 if ( NULL == (returnCube = cpl_imagelist_new()) )
1482 cpl_free(row_index) ;
1483 cpl_free(beginCol) ;
1490 for ( slit = 0 ; slit < N_SLITLETS ; slit++ )
1499 row_index[slit] = slit ;
1508 di += distances[slit-1] ;
1509 start = firstCol + di ;
1511 beginCol[slit] = sinfo_new_nint(start) ;
1515 float diff = start - (float)beginCol[slit] ;
1522 shift[row_index[slit]] = diff ;
1526 for ( z = 0 ; z < ily ; z++ )
1528 cpl_image* o_img=cpl_image_new(imsize,N_SLITLETS,CPL_TYPE_FLOAT);
1529 float* podata=cpl_image_get_data_float(o_img);
1530 for ( slit = 0 ; slit < N_SLITLETS ; slit++ )
1532 col_counter = beginCol[slit] ;
1534 for ( col = 0 ; col < imsize ; col++ )
1536 if ( col_counter > ilx-1 )
1540 podata[col+row_index[slit]*imsize]=pidata[col_counter+z*ilx];
1544 cpl_imagelist_set(returnCube,o_img,z);
1546 cpl_free (row_index) ;
1547 cpl_free (beginCol) ;
1574 sinfo_new_make_3D_cube ( cpl_image * calibImage,
1578 cpl_imagelist * returnCube ;
1584 if ( NULL == calibImage )
1589 ilx=cpl_image_get_size_x(calibImage);
1590 ily=cpl_image_get_size_y(calibImage);
1591 float* pidata=cpl_image_get_data_float(calibImage);
1593 if ( NULL == kpixshift )
1599 if ( kpixfirst < 0 )
1605 if ( N_SLITLETS != 16 )
1610 imsize = ilx / N_SLITLETS ;
1612 if ( NULL == (returnCube = cpl_imagelist_new()) )
1619 for ( z = 0 ; z < ily ; z++ )
1621 cpl_image* o_img=cpl_image_new(imsize,N_SLITLETS,CPL_TYPE_FLOAT);
1622 float* podata=cpl_image_get_data_float(o_img);
1626 for ( col = 0 ; col < ilx ; col++ )
1628 if ( col % imsize == 0 )
1631 kslit = col/imsize ;
1632 kpix = kpixfirst + kpixshift[kslit] ;
1636 podata[recol+kslit*imsize] = pidata[col+kpix+z*ilx] ;
1638 if ( recol > imsize )
1641 "shouldn't happen!\n") ;
1642 cpl_imagelist_delete(returnCube) ;
1646 cpl_imagelist_set(returnCube,o_img,z);
1668 sinfo_new_determine_mask_cube ( cpl_imagelist * sourceMaskCube,
1672 cpl_imagelist * retCube ;
1683 if ( sourceMaskCube == NULL )
1688 ilx=cpl_image_get_size_x(cpl_imagelist_get(sourceMaskCube,0));
1689 ily=cpl_image_get_size_y(cpl_imagelist_get(sourceMaskCube,0));
1690 inp=cpl_imagelist_get_size(sourceMaskCube);
1693 if ( lowLimit > 0. )
1698 if ( highLimit >= 1. || highLimit < 0. )
1704 retCube = cpl_imagelist_duplicate (sourceMaskCube) ;
1709 for ( z = 0 ; z < onp ; z++ )
1711 cpl_image* o_img=cpl_imagelist_get(retCube,0);
1712 float* podata=cpl_image_get_data_float(o_img);
1713 for ( n = 0 ; n < (int) olx*oly; n++ )
1715 if ( podata[n] == 0. )
1719 if ( podata[n] == 1. )
1723 if ( podata[n] >= lowLimit &&
1724 podata[n] <= highLimit )
1779 sinfo_new_interpol_cube ( cpl_imagelist * sourceCube,
1780 cpl_imagelist * maskCube,
1784 cpl_imagelist * returnCube ;
1787 int n_im, n_bad, n_bad1, n_bad2 ;
1788 int n_planes, specn, nspec1 ;
1789 int i, m, n, z, ni, kk, p ;
1790 int dis, dismin, dismax ;
1792 int xcordi, ycordi, xcordm, ycordm ;
1804 if ( NULL == sourceCube )
1811 ilx=cpl_image_get_size_x(cpl_imagelist_get(sourceCube,0));
1812 ily=cpl_image_get_size_y(cpl_imagelist_get(sourceCube,0));
1813 inp=cpl_imagelist_get_size(sourceCube);
1815 if ( NULL == maskCube )
1821 if ( n_neighbors <= 0 )
1824 "direction given!") ;
1828 if ( max_radius <= 0 )
1831 "an image plane given!") ;
1835 returnCube = cpl_imagelist_duplicate(sourceCube) ;
1840 spec1=cpl_calloc(300,
sizeof(
float)) ;
1841 spec=sinfo_new_2Dfloatarray(100,2*n_neighbors+1) ;
1844 for ( z = 0 ; z < n_planes ; z++ )
1846 cpl_image* m_img=cpl_imagelist_get(maskCube,z);
1847 pmdata=cpl_image_get_data_float(m_img);
1848 cpl_image* o_img=cpl_imagelist_get(returnCube,z);
1849 float* podata=cpl_image_get_data_float(o_img);
1856 if ( z < n_neighbors )
1860 else if ( n_planes - z <= n_neighbors)
1862 n = n_planes - z -1 ;
1869 for ( i = 0 ; i < n_im ; i ++ )
1872 if ( pmdata[i] != 0. )
1886 for ( ni = z-n ; ni <= z+n ; ni++ )
1888 if ( pmdata[i] == 0. )
1911 if ( (2*n+1 - n_bad) < 3 || (n - n_bad1) < 1 || (n - n_bad2) < 1 )
1919 for ( ni = z-n ; ni <= z+n ; ni++ )
1921 i_img=cpl_imagelist_get(sourceCube,ni);
1922 pidata=cpl_image_get_data_float(i_img);
1923 spec[1][kk] = pmdata[i] != 0. ? pidata[i] : ZERO ;
1935 for ( m = 0 ; m < n_im ; m++ )
1937 if ( pmdata[m] == 0. )
1955 dis = abs(xcordi-xcordm) + abs(ycordi-ycordm) ;
1956 if ( dis <= dismin || dis > dismax )
1978 for ( ni = z-n ; ni <= z+n ; ni++ )
1980 if ( pmdata[i] == 0. || pmdata[m] == 0. )
1985 if ( n_bad > 2*n-1 )
1994 for ( ni = z-n ; ni <= z+n ; ni++ )
1996 i_img=cpl_imagelist_get(sourceCube,ni);
1997 pidata=cpl_image_get_data_float(i_img);
1998 spec[specn][kk] = pmdata[m] != 0. ? pidata[m] : ZERO ;
2013 if ( dismax > max_radius )
2027 for ( kk = 0 ; kk < 2*n+1 ; kk++ )
2035 if ( isnan(spec[1][kk]) )
2037 for ( p = 2 ; p <= specn ; p++ )
2039 spec[p][kk] = ZERO ;
2044 for ( p = 2 ; p <= specn ; p++ )
2046 if ( !isnan(spec[p][kk]) && spec[p][kk] != 0. &&
2047 !isnan(spec[p][n]) )
2049 spec[p][kk] = spec[1][kk] /
2050 spec[p][kk] * spec[p][n] ;
2054 spec[p][kk] = ZERO ;
2069 for ( p = 2 ; p <= specn ; p++ )
2071 for ( kk = 0 ; kk < 2*n+1 ; kk++ )
2073 if ( !isnan(spec[p][kk]) && kk != n )
2075 spec1[nspec1] = spec[p][kk] ;
2088 podata[i] = sinfo_new_median(spec1, nspec1) ;
2092 sinfo_new_destroy_2Dfloatarray(&spec,2*n_neighbors+1) ;
2123 sinfo_new_fine_tune_cube( cpl_imagelist * cube,
2124 float * correct_diff_dist,
2127 cpl_imagelist * returnCube ;
2128 float* row_data=NULL ;
2129 float* corrected_row_data=NULL ;
2131 float sum, new_sum ;
2136 int imsize, n_points ;
2148 ilx=cpl_image_get_size_x(cpl_imagelist_get(cube,0));
2149 ily=cpl_image_get_size_y(cpl_imagelist_get(cube,0));
2150 inp=cpl_imagelist_get_size(cube);
2152 if ( NULL == correct_diff_dist )
2161 returnCube = cpl_imagelist_duplicate(cube);
2165 returnCube = cpl_imagelist_duplicate(cube);
2168 if ( imsize != N_SLITLETS )
2171 sinfo_free_imagelist(&returnCube);
2175 n_points = n_order + 1 ;
2176 if ( n_points % 2 == 0 )
2178 firstpos = (int)(n_points/2) - 1 ;
2182 firstpos = (int)(n_points/2) ;
2184 xnum=cpl_calloc(n_order+1,
sizeof(
float)) ;
2186 for ( i = 0 ; i < n_points ; i++ )
2191 row_data=cpl_calloc(ilx,
sizeof(
float)) ;
2192 corrected_row_data=cpl_calloc(ilx,
sizeof(
float)) ;
2194 for ( z = 0 ; z < inp ; z++ )
2196 cpl_image* i_img=cpl_imagelist_get(cube,z);
2197 float* pidata=cpl_image_get_data_float(i_img);
2198 cpl_image* o_img=cpl_imagelist_get(returnCube,z);
2199 float* podata=cpl_image_get_data_float(o_img);
2202 for ( row = 0 ; row < imsize ; row++ )
2204 for ( col = 0 ; col < ilx ; col++ )
2206 corrected_row_data[col] = 0. ;
2209 for ( col = 0 ; col < ilx ; col++ )
2211 row_data[col] = pidata[col+row*ilx] ;
2212 if ( isnan(row_data[col]) )
2214 row_data[col] = 0. ;
2215 for ( i = col - firstpos ;
2216 i < col -firstpos+n_points ; i++ )
2218 if ( i < 0 ) continue ;
2219 if ( i >= ilx) continue ;
2220 corrected_row_data[i] = ZERO ;
2223 if ( col != 0 && col != ilx - 1 )
2225 sum += row_data[col] ;
2231 for ( col = 0 ; col < ilx ; col++ )
2234 if ( isnan(corrected_row_data[col]) )
2238 if ( col - firstpos < 0 )
2240 imageptr = &row_data[0] ;
2241 eval = correct_diff_dist[row] + col ;
2243 else if ( col - firstpos + n_points >= ilx )
2245 imageptr = &row_data[ilx - n_points] ;
2246 eval = correct_diff_dist[row] + col + n_points - ilx ;
2250 imageptr = &row_data[col-firstpos] ;
2251 eval = correct_diff_dist[row] + firstpos ;
2256 corrected_row_data[col]=sinfo_new_nev_ille(xnum, imageptr,
2257 n_order, eval, &flag);
2260 if ( col != 0 && col != ilx - 1 )
2262 new_sum += corrected_row_data[col] ;
2265 for ( col = 0 ; col < ilx ; col++ )
2270 podata[col+row*ilx] = ZERO ;
2272 else if ( col == ilx - 1 )
2274 podata[col+row*ilx] = ZERO ;
2278 if ( isnan(corrected_row_data[col]) )
2280 podata[col+row*ilx] = ZERO ;
2284 if ( new_sum == 0. ) new_sum = 1. ;
2286 podata[col+row*ilx] = corrected_row_data[col] ;
2294 cpl_free(row_data) ;
2295 cpl_free(corrected_row_data) ;
2325 sinfo_new_fine_tune_cube_by_FFT( cpl_imagelist * cube,
2326 float * correct_diff_dist )
2328 cpl_imagelist * returnCube ;
2330 float* row_data=NULL ;
2331 dcomplex* data=NULL ;
2332 dcomplex* corrected_data=NULL ;
2341 int blank_indicator ;
2358 ilx=cpl_image_get_size_x(cpl_imagelist_get(cube,0));
2359 ily=cpl_image_get_size_y(cpl_imagelist_get(cube,0));
2360 inp=cpl_imagelist_get_size(cube);
2363 if ( NULL == correct_diff_dist )
2369 returnCube = cpl_imagelist_duplicate( cube ) ;
2372 if ( imsize != N_SLITLETS )
2375 sinfo_free_imagelist(&returnCube);
2379 data=cpl_calloc(ilx,
sizeof(dcomplex)) ;
2380 corrected_data=cpl_calloc(ilx,
sizeof(dcomplex)) ;
2382 row_data=cpl_calloc(ilx,
sizeof(
float)) ;
2384 for ( z = 0 ; z < inp ; z++ )
2386 cpl_image* i_img=cpl_imagelist_get(cube,z);
2387 float* pidata=cpl_image_get_data_float(i_img);
2388 cpl_image* o_img=cpl_imagelist_get(returnCube,z);
2389 float* podata=cpl_image_get_data_float(o_img);
2391 for ( row = 0 ; row < imsize ; row++ )
2393 blank_indicator = 1 ;
2394 for ( col = 0 ; col < ilx ; col++ )
2397 row_data[col] = pidata[col+row*ilx] ;
2398 data[col].x = row_data[col] ;
2401 if ( isnan(row_data[col]) )
2403 blank_indicator = 0 ;
2408 if ( blank_indicator == 0 )
2410 for ( col = 0 ; col < ilx ; col++ )
2412 podata[col+row*ilx] = ZERO ;
2418 sinfo_fftn( data, nn, 1, 1 ) ;
2421 phi = 2*PI_NUMB/(float)ilx * correct_diff_dist[row] ;
2422 for ( i = 0 ; i < ilx ; i++ )
2428 pphi = phi * (float)(i) ;
2430 coph = cos ( pphi ) ;
2431 siph = sin ( pphi ) ;
2436 pphi = phi * (float)(i - ilx/2) ;
2438 coph = cos ( pphi ) ;
2439 siph = sin ( pphi ) ;
2449 corrected_data[i].x = data[i].x * coph - data[i].y * siph ;
2451 corrected_data[i].y = data[i].x * siph + data[i].y * coph ;
2455 sinfo_fftn( corrected_data, nn, 1, -1 ) ;
2458 for ( i = 0 ; i < ilx ; i++ )
2460 corrected_data[i].x /= ilx ;
2461 corrected_data[i].y /= ilx ;
2466 for ( col = 0 ; col < ilx ; col++ )
2470 podata[col+row*ilx] = ZERO ;
2472 else if ( col == ilx - 1 )
2474 podata[col+row*ilx] = ZERO ;
2478 podata[col+row*ilx] = corrected_data[col].x ;
2485 cpl_free(corrected_data) ;
2521 cpl_imagelist * sinfo_new_fine_tune_cube_by_spline ( cpl_imagelist * cube,
2522 float * correct_diff_dist )
2524 cpl_imagelist * returnCube ;
2526 float* row_data=NULL ;
2527 float* corrected_row_data=NULL ;
2531 float sum, new_sum ;
2544 ilx=cpl_image_get_size_x(cpl_imagelist_get(cube,0));
2545 ily=cpl_image_get_size_y(cpl_imagelist_get(cube,0));
2546 inp=cpl_imagelist_get_size(cube);
2548 if ( NULL == correct_diff_dist )
2555 if ( imsize != N_SLITLETS )
2561 returnCube = cpl_imagelist_duplicate( cube ) ;
2563 row_data=cpl_calloc(ilx,
sizeof(
float)) ;
2564 corrected_row_data=cpl_calloc(ilx,
sizeof(
float)) ;
2565 xnum=cpl_calloc(ilx,
sizeof(
float)) ;
2566 eval=cpl_calloc(ilx,
sizeof(
float)) ;
2569 for ( i = 0 ; i < ilx ; i++ )
2575 for ( z = 0 ; z < inp ; z++ )
2577 cpl_image* i_img=cpl_imagelist_get(cube,z);
2578 float* pidata=cpl_image_get_data_float(i_img);
2579 cpl_image* o_img=cpl_imagelist_get(returnCube,z);
2580 float* podata=cpl_image_get_data_float(o_img);
2582 for ( row = 0 ; row < imsize ; row++ )
2584 for ( col = 0 ; col < ilx ; col++ )
2586 corrected_row_data[col] = 0. ;
2591 for ( col = 0 ; col < ilx ; col++ )
2593 eval[col] = correct_diff_dist[row] + (float)col ;
2594 row_data[col] = pidata[col+row*ilx] ;
2595 if (col != 0 && col != ilx - 1 && !isnan(row_data[col]) )
2597 sum += row_data[col] ;
2599 if (isnan(row_data[col]) )
2601 for ( i = col -1 ; i <= col+1 ; i++ )
2603 if ( i < 0 ) continue ;
2604 if ( i >= ilx ) continue ;
2605 corrected_row_data[i] = ZERO ;
2607 row_data[col] = 0. ;
2616 if ( -1 == sinfo_function1d_natural_spline(xnum,row_data, ilx,
2617 eval,corrected_row_data,
2621 cpl_imagelist_delete(returnCube) ;
2626 for ( col = 0 ; col < ilx ; col++ )
2628 if (isnan(corrected_row_data[col])) continue ;
2631 if ( col != 0 && col != ilx - 1 )
2633 new_sum += corrected_row_data[col] ;
2636 for ( col = 0 ; col < ilx ; col++ )
2645 podata[col+row*ilx] = ZERO ;
2647 else if ( col == ilx - 1 )
2649 podata[col+row*ilx] = ZERO ;
2653 if ( isnan(corrected_row_data[col]) )
2655 podata[col+row*ilx] = ZERO ;
2659 if (new_sum == 0.) new_sum = 1. ;
2664 podata[col+row*ilx] = corrected_row_data[col] ;
2671 cpl_free(row_data) ;
2672 cpl_free(corrected_row_data) ;
2702 sinfo_new_calibrate_ns_test( cpl_image * ns_image,
2707 float estimated_dist,
2712 int i, j, k, m, row, col, n, ni, na ;
2713 int position, counter;
2714 int xdim, ndat, its, numpar ;
2715 float sum, mean, maxval ;
2718 float * ret_distances ;
2720 float * xdat, * wdat ;
2723 pixelvalue* row_buf=NULL ;
2724 float** distances_buf=NULL ;
2725 float* x_position=NULL ;
2727 int* found_clean=NULL ;
2728 int* found_cleanit=NULL ;
2732 int foundit, begin, end ;
2740 if ( ns_image == NULL )
2745 if ( n_slitlets < 1 )
2750 if ( halfWidth < 0 || halfWidth >= estimated_dist )
2767 if (NULL==(distances=(
float *)cpl_calloc( n_slitlets ,
sizeof (
float) )))
2773 if (NULL == (ret_distances = (
float *) cpl_calloc ( n_slitlets ,
2780 ilx=cpl_image_get_size_x(ns_image);
2781 ily=cpl_image_get_size_y(ns_image);
2782 pidata=cpl_image_get_data_float(ns_image);
2784 row_buf=(pixelvalue*)cpl_calloc(ilx,
sizeof(pixelvalue)) ;
2785 x_position=cpl_calloc(n_slitlets,
sizeof(
float)) ;
2786 found=cpl_calloc(3*n_slitlets,
sizeof(
int));
2787 found_clean=cpl_calloc(3*n_slitlets,
sizeof(
int)) ;
2788 found_cleanit=cpl_calloc(3*n_slitlets,
sizeof(
int)) ;
2789 distances_buf=sinfo_new_2Dfloatarray(ily,n_slitlets) ;
2792 for ( row = 0 ; row < ily ; row++ )
2794 int zeroindicator = 0 ;
2797 for ( i = 0 ; i < n_slitlets ; i++ )
2799 distances_buf[row][i] = ZERO ;
2803 for ( col = 0 ; col < ilx ; col++ )
2805 row_buf[col] = pidata[col + row*ilx] ;
2811 for ( i = 0 ; i < ilx ; i++ )
2813 if ( isnan(row_buf[i]) )
2820 mean = sum / (float)n ;
2824 for ( i = 0 ; i < ilx ; i++ )
2826 if (isnan(row_buf[i]))
2830 if ( row_buf[i] > mean + ESTIMATE )
2837 if ( n < n_slitlets )
2840 "found in row: %d, found number: %d", row, n) ;
2847 for ( i = 1 ; i < n ; i ++ )
2849 if ( found[i] - found[i-1] < halfWidth )
2851 begin = found[i] - halfWidth ;
2856 end = found[i] + halfWidth ;
2865 for ( j = begin ; j <= end ; j++ )
2868 if (isnan(row_buf[j]))
2872 if (row_buf[j] >= maxval )
2874 maxval = row_buf[j] ;
2878 if (maxval == -FLT_MAX)
2882 for ( k = 0 ; k < na ; k++ )
2884 if ( found_cleanit[k] >= begin &&
2885 found_cleanit[k] < foundit )
2890 for ( k = 0 ; k < n ; k++ )
2892 if ( found[k] == foundit)
2894 if ( found_cleanit[na-1] != found[k] )
2896 found_cleanit[na] = found[k] ;
2906 found_cleanit[na] = found[0] ;
2908 found_cleanit[na] = found[1] ;
2913 if ( found_cleanit[na-1] != found[i-1])
2915 found_cleanit[na] = found[i-1] ;
2918 if ( found_cleanit[na-1] != found[i])
2920 found_cleanit[na] = found[i] ;
2929 for ( i = 1 ; i < na ; i++ )
2931 if ( (
float)(found_cleanit[i] - found_cleanit[i-1]) <
2932 (estimated_dist - devtol) ||
2933 (
float)(found_cleanit[i] - found_cleanit[i-1]) >
2934 (estimated_dist + devtol) )
2940 found_clean[j-1] = found_cleanit[i-1] ;
2941 found_clean[j] = found_cleanit[i] ;
2946 if ( j > n_slitlets )
2950 for ( i = 1 ; i < j ; i++ )
2952 if ( (
float)(found_clean[i] - found_clean[i-1]) <
2953 (estimated_dist - devtol ) ||
2954 (
float)(found_clean[i] - found_clean[i-1]) >
2955 (estimated_dist + devtol ) )
2961 found_clean[ni-1] = found_clean[i-1] ;
2962 found_clean[ni] = found_clean[i] ;
2966 if ( ni != n_slitlets )
2969 "found in row: %d, found number: %d",
2978 else if ( j < n_slitlets )
2981 "in row: %d , found number: %d\n", row, j) ;
2986 for ( i = 0 ; i < j ; i++ )
2989 if ( NULL == (line = sinfo_new_vector (2*halfWidth + 1)) )
2992 cpl_free(distances) ;
2997 xdat = (
float *) cpl_calloc( line -> n_elements,
sizeof (
float) ) ;
2998 wdat = (
float *) cpl_calloc( line -> n_elements,
sizeof (
float) ) ;
2999 mpar = (
int *) cpl_calloc( MAXPAR,
sizeof (
int) ) ;
3000 par = sinfo_new_fit_params(1) ;
3003 for ( k = found_clean[i]-halfWidth ;
3004 k <= found_clean[i]+halfWidth ; k++ )
3010 else if ( k >= ilx )
3014 else if ( isnan(row_buf[k]) )
3021 line -> data[m] = row_buf[k] ;
3025 if ( zeroindicator == 1 )
3027 sinfo_new_destroy_vector(line) ;
3031 sinfo_new_destroy_fit_params(&par) ;
3040 position = -INT32_MAX ;
3041 for ( k = 0 ; k < m ; k++ )
3045 if ( line -> data[k] >= maxval )
3047 maxval = line -> data[k] ;
3054 ndat = line -> n_elements ;
3059 (*par) -> fit_par[1] = fwhm ;
3060 (*par) -> fit_par[2] = (float) position ;
3061 (*par) -> fit_par[3] = (float) (line -> data[0] +
3062 line -> data[line->n_elements - 1]) / 2.0 ;
3063 (*par) -> fit_par[0] = maxval - ((*par) -> fit_par[3]) ;
3067 if ( (*par) -> fit_par[0] < minDiff )
3070 "in row: %d in slitlet %d\n", row, i) ;
3071 sinfo_new_destroy_vector(line) ;
3075 sinfo_new_destroy_fit_params(&par) ;
3079 for ( k = 0 ; k < MAXPAR ; k++ )
3081 (*par) -> derv_par[k] = 0.0 ;
3086 if ( 0 > ( iters = sinfo_new_lsqfit_c(xdat, &xdim,
3088 &ndat, (*par) -> fit_par,
3089 (*par) -> derv_par, mpar,
3099 sinfo_new_destroy_vector(line) ;
3103 sinfo_new_destroy_fit_params(&par) ;
3108 if ( (*par) -> fit_par[0] <= 0. || (*par) -> fit_par[1] <= 0. ||
3109 (*par) -> fit_par[2] < 0. )
3112 "used! in row %d in slitlet %d", row, i) ;
3113 sinfo_new_destroy_vector(line) ;
3117 sinfo_new_destroy_fit_params(&par) ;
3123 (*par) -> fit_par[2] = (float) (found_clean[i] - halfWidth) +
3124 (*par) -> fit_par[2] ;
3125 x_position[counter] = (*par) -> fit_par[2] ;
3129 sinfo_new_destroy_fit_params(&par) ;
3130 sinfo_new_destroy_vector ( line ) ;
3135 if (zeroindicator == 1)
3141 if ( counter != n_slitlets )
3144 "in row: %d", row) ;
3148 for ( i = 0 ; i < n_slitlets ; i++ )
3150 distances_buf[row][i] = x_position[i] - (15.5 + 32.*(float)i) ;
3158 for ( i = 0 ; i < n_slitlets ; i++ )
3162 for ( row = bottom ; row < top ; row++ )
3164 if ( fabs( distances_buf[row][i] ) > devtol ||
3165 isnan(distances_buf[row][i]) )
3175 sum += distances_buf[row][i] ;
3181 " completely!, deviations of distances from"
3182 " devtol too big" ) ;
3183 cpl_free(distances) ;
3188 distances[i] = sum / (float)n ;
3195 for ( i = 0 ; i < n_slitlets ; i++ )
3198 if( (row_index=sinfo_sort_slitlets(i)) == -1) {
3200 cpl_free (distances) ;
3203 ret_distances[row_index] = distances[i] ;
3205 cpl_free(distances) ;
3208 cpl_free(x_position) ;
3210 cpl_free(found_clean) ;
3211 cpl_free(found_cleanit) ;
3212 sinfo_new_destroy_2Dfloatarray(&distances_buf,n_slitlets) ;
3215 return ret_distances ;
3242 sinfo_new_make_true_resamp(cpl_image * calibImage,
3243 cpl_image * wavemap)
3245 cpl_image * returnImage ;
3261 wlx=cpl_image_get_size_x(wavemap);
3263 pwdata=cpl_image_get_data_float(wavemap);
3267 for(i=0;i<wlx-1;i++)
3269 if((pwdata[i]-pwdata[i+1])>0.0025 || (pwdata[i]-pwdata[i+1])<-0.0025)
3278 clx=cpl_image_get_size_x(calibImage);
3279 cly=cpl_image_get_size_y(calibImage);
3280 pcdata=cpl_image_get_data_float(calibImage);
3282 imsize = clx / N_SLITLETS ;
3285 returnImage = cpl_image_new(clx,cly,CPL_TYPE_FLOAT);
3286 prdata=cpl_image_get_data_float(returnImage);
3287 for ( z = 0 ; z < cly ; z++ )
3289 for ( col = 0 ; col < clx ; col++ )
3290 prdata[col+z*clx]=ZERO;
3295 for ( z = 0 ; z < cly ; z++ )
3300 for ( col = 0 ; col < clx ; col++ )
3308 if(col>=sinfo_new_nint(edges[i]) &&
3309 col<sinfo_new_nint(edges[i+1]))
3313 int slit_index = -1 ;
3314 if( (slit_index=sinfo_sort_slitlets(kslit)) == -1) {
3316 "spiffi image, there must be 32 "
3324 if((col-sinfo_new_nint(edges[kslit]))>0 &&
3325 (col-sinfo_new_nint(edges[kslit]))<imsize-1 )
3326 prdata[(col-sinfo_new_nint(edges[kslit]))+
3327 slit_index*imsize+z*clx] =
3330 prdata[(col-sinfo_new_nint(edges[kslit]))+
3331 slit_index*imsize+z*clx] = ZERO;
3336 return returnImage ;
#define sinfo_msg_debug(...)
Print a debug message.
#define sinfo_msg_error(...)
Print an error message.
#define sinfo_msg_warning(...)
Print an warning message.