203 #define POSIX_SOURCE 1
204 #include "sinfo_vltPort.h"
213 #include "sinfo_function_1d.h"
214 #include "sinfo_cube_construct.h"
215 #include "sinfo_spectrum_ops.h"
216 #include "sinfo_wave_calibration.h"
217 #include "sinfo_utilities.h"
218 #include "sinfo_local_types.h"
219 #include "sinfo_fft_base.h"
222 sinfo_sort_slitlets(
const int kslit);
226 sinfo_sort_slitlets_array(
const int slit,
int* row_index);
249 sinfo_new_convolve_ns_image_by_gauss( cpl_image * lineImage,
252 cpl_image * returnImage ;
253 float* row_buffer=NULL ;
262 if ( lineImage == NULL )
267 ilx=cpl_image_get_size_x(lineImage);
268 ily=cpl_image_get_size_y(lineImage);
269 pidata=cpl_image_get_data_float(lineImage);
277 if ( NULL == ( returnImage = cpl_image_new(ilx,ily,CPL_TYPE_FLOAT ) ))
282 podata=cpl_image_get_data_float(returnImage);
285 row_buffer=cpl_calloc(ily,
sizeof(
float)) ;
287 for ( row = 0 ; row < ily ; row++ )
289 for ( col = 0 ; col < ilx ; col++ )
291 if ( isnan(pidata[col+row*ilx]) )
293 row_buffer[col] = 0. ;
297 row_buffer[col] = pidata[col + row*ilx] ;
305 filter = sinfo_function1d_filter_lowpass( row_buffer,
309 for ( col = 0 ; col < ily ; col++ )
311 podata[col + row*ilx] = filter[col] ;
314 sinfo_function1d_del (filter) ;
316 cpl_free(row_buffer);
337 sinfo_north_south_test( cpl_image * ns_image,
342 float estimated_dist,
347 int i, j, k, m, row, col, n, ni, na ;
348 int position, counter, iters ;
349 int xdim, ndat, its, numpar ;
350 pixelvalue row_buf[cpl_image_get_size_x(ns_image)] ;
351 float sum, mean, maxval ;
354 float distances_buf[cpl_image_get_size_y(ns_image)][n_slitlets-1] ;
355 float x_position[n_slitlets] ;
356 float * xdat, * wdat ;
358 int found[3*n_slitlets], found_clean[3*n_slitlets] ;
359 int found_cleanit[3*n_slitlets] ;
362 int foundit, begin, end ;
369 if ( ns_image == NULL )
374 ilx=cpl_image_get_size_x(ns_image);
376 pidata=cpl_image_get_data_float(ns_image);
379 if ( n_slitlets < 1 )
384 if ( halfWidth < 0 || halfWidth >= estimated_dist )
401 if (NULL == (distances = (
float *) cpl_calloc ( n_slitlets - 1 ,
409 for ( row = bottom ; row < top ; row++ )
414 for ( i = 0 ; i < n_slitlets-1 ; i++ )
416 distances_buf[row][i] = ZERO ;
420 for ( col = 0 ; col < ilx ; col++ )
422 row_buf[col] = pidata[col + row*ilx] ;
428 for ( i = 0 ; i < ilx ; i++ )
430 if ( isnan(row_buf[i]) )
437 mean = sum / (float)n ;
442 for ( i = 0 ; i < ilx ; i++ )
444 if (isnan(row_buf[i]))
448 if ( row_buf[i] > sqrt(mean*mean*9) )
455 if ( n < n_slitlets )
458 "in row: %d, found number: %d, mean: %g",
466 for ( i = 1 ; i < n ; i ++ )
468 if ( found[i] - found[i-1] < halfWidth )
470 begin = found[i] - halfWidth ;
475 end = found[i] + halfWidth ;
484 for ( j = begin ; j <= end ; j++ )
487 if (isnan(row_buf[j]))
491 if (row_buf[j] >= maxval )
493 maxval = row_buf[j] ;
497 if (maxval == -FLT_MAX)
501 for ( k = 0 ; k < na ; k++ )
503 if ( found_cleanit[k] >= begin &&
504 found_cleanit[k] < foundit )
509 for ( k = 0 ; k < n ; k++ )
511 if ( found[k] == foundit)
514 if ( found_cleanit[na-1] != found[k] )
516 found_cleanit[na] = found[k] ;
521 found_cleanit[na] = found[k] ;
531 found_cleanit[na] = found[0] ;
533 found_cleanit[na] = found[1] ;
539 if ( found_cleanit[na-1] != found[i-1])
541 found_cleanit[na] = found[i-1] ;
544 if ( found_cleanit[na-1] != found[i])
546 found_cleanit[na] = found[i] ;
552 found_cleanit[na] = found[i] ;
560 for ( i = 1 ; i < na ; i++ )
562 if ( (
float)(found_cleanit[i] - found_cleanit[i-1]) <
563 (estimated_dist - devtol) ||
564 (
float)(found_cleanit[i] - found_cleanit[i-1]) >
565 (estimated_dist + devtol) )
571 found_clean[j-1] = found_cleanit[i-1] ;
572 found_clean[j] = found_cleanit[i] ;
577 if ( j > n_slitlets )
581 for ( i = 1 ; i < j ; i++ )
583 if ( (
float)(found_clean[i] - found_clean[i-1]) <
584 (estimated_dist - devtol ) ||
585 (
float)(found_clean[i] - found_clean[i-1]) >
586 (estimated_dist + devtol ) )
593 found_clean[ni-1] = found_clean[i-1] ;
594 found_clean[ni] = found_clean[i] ;
598 if ( ni != n_slitlets )
601 " found in row: %d, found number: %d",
610 else if ( j < n_slitlets )
612 cpl_msg_debug (
"north_south_test3:",
613 "t3 wrong number of intensity columns "
614 "found in row: %d , found number: %d, mean: %g\n",
620 for ( i = 0 ; i < j ; i++ )
623 if ( NULL == (line = sinfo_new_vector (2*halfWidth + 1)) )
626 cpl_free(distances) ;
631 xdat = (
float *) cpl_calloc( line -> n_elements,
sizeof (
float) ) ;
632 wdat = (
float *) cpl_calloc( line -> n_elements,
sizeof (
float) ) ;
633 mpar = (
int *) cpl_calloc( MAXPAR,
sizeof (
int) ) ;
634 par = sinfo_new_fit_params(1) ;
637 for ( k = found_clean[i]-halfWidth ;
638 k <= found_clean[i]+halfWidth ; k++ )
648 else if ( isnan(row_buf[k]) )
655 line -> data[m] = row_buf[k] ;
659 if ( zeroindicator == 1 )
661 sinfo_new_destroy_vector(line) ;
665 sinfo_new_destroy_fit_params(&par) ;
674 position = -INT32_MAX ;
675 for ( k = 0 ; k < m ; k++ )
679 if ( line -> data[k] >= maxval )
681 maxval = line -> data[k] ;
688 ndat = line -> n_elements ;
693 (*par) -> fit_par[1] = fwhm ;
694 (*par) -> fit_par[2] = (float) position ;
695 (*par) -> fit_par[3] = (float) (line -> data[0] +
696 line -> data[line->n_elements - 1]) / 2.0 ;
697 (*par) -> fit_par[0] = maxval - ((*par) -> fit_par[3]) ;
701 if ( (*par) -> fit_par[0] < minDiff )
704 "in row: %d in slitlet %d\n", row, i) ;
705 sinfo_new_destroy_vector(line) ;
709 sinfo_new_destroy_fit_params(&par) ;
713 for ( k = 0 ; k < MAXPAR ; k++ )
715 (*par) -> derv_par[k] = 0.0 ;
719 if ( 0 > ( iters = sinfo_new_lsqfit_c( xdat, &xdim,
720 line -> data, wdat, &ndat,
722 (*par) -> derv_par, mpar,
723 &numpar, &tol, &its, &lab)) )
731 sinfo_new_destroy_vector(line) ;
735 sinfo_new_destroy_fit_params(&par) ;
740 if ( (*par) -> fit_par[0] <= 0. ||
741 (*par) -> fit_par[1] <= 0. ||
742 (*par) -> fit_par[2] < 0. )
745 "not used! in row %d in slitlet %d",
747 sinfo_new_destroy_vector(line) ;
751 sinfo_new_destroy_fit_params(&par) ;
757 (*par) -> fit_par[2] = (float) (found_clean[i] - halfWidth) +
758 (*par) -> fit_par[2] ;
759 x_position[counter] = (*par) -> fit_par[2] ;
763 sinfo_new_destroy_fit_params(&par) ;
764 sinfo_new_destroy_vector ( line ) ;
769 if (zeroindicator == 1)
775 if ( counter != n_slitlets )
781 for ( i = 1 ; i < n_slitlets ; i++ )
783 distances_buf[row][i-1] = x_position[i] - x_position[i-1] ;
791 for ( i = 0 ; i < n_slitlets-1 ; i++ )
795 for ( row = bottom ; row < top ; row++ )
797 if ( fabs( distances_buf[row][i] - estimated_dist ) > devtol ||
798 isnan(distances_buf[row][i]) )
808 sum += distances_buf[row][i] ;
814 "completely!, deviations of distances from number "
815 "of slitlets too big\n" ) ;
816 cpl_free(distances) ;
821 distances[i] = sum / (float)n ;
851 sinfo_new_make_cube ( cpl_image * calibImage,
853 float * correct_diff_dist )
855 cpl_imagelist * returnCube ;
856 int imsize, kslit, kpix ;
866 if ( NULL == calibImage )
871 ilx=cpl_image_get_size_x(calibImage);
872 ily=cpl_image_get_size_y(calibImage);
873 pidata=cpl_image_get_data_float(calibImage);
875 if ( NULL == distances )
881 if ( NULL == correct_diff_dist )
887 if ( N_SLITLETS != 32 )
892 imsize = ilx / N_SLITLETS ;
895 if ( NULL == (returnCube = cpl_imagelist_new()) )
902 for ( z = 0 ; z < ily ; z++ )
905 o_img=cpl_image_new(imsize,N_SLITLETS,CPL_TYPE_FLOAT);
906 podata=cpl_image_get_data_float(o_img);
911 for ( col = 0 ; col < ilx ; col++ )
913 if ( col % imsize == 0 )
918 if((slit_index=sinfo_sort_slitlets(kslit)) == -1) {
920 "spiffi image, there must be 32 slitlets!") ;
921 cpl_imagelist_delete(returnCube) ;
932 kpix = sinfo_new_nint(distances[kslit-1]) ;
939 correct_diff_dist[slit_index] = distances[kslit-1] -
945 correct_diff_dist[slit_index] = 0. ;
950 podata[recol+slit_index*imsize] = pidata[col+kpix+z*ilx];
953 if ( recol > imsize )
956 "image, shouldn't happen!\n") ;
957 cpl_imagelist_delete(returnCube) ;
975 sinfo_sort_slitlets(
const int kslit)
1079 "spiffi image, there must be 32 slitlets!") ;
1099 sinfo_sort_slitlets_array(
const int slit,
int* row_index)
1135 row_index[10] = 13 ;
1141 row_index[12] = 14 ;
1147 row_index[14] = 15 ;
1153 row_index[16] = 31 ;
1156 row_index[17] = 16 ;
1159 row_index[18] = 30 ;
1162 row_index[19] = 17 ;
1165 row_index[20] = 29 ;
1168 row_index[21] = 18 ;
1171 row_index[22] = 28 ;
1174 row_index[23] = 19 ;
1177 row_index[24] = 27 ;
1180 row_index[25] = 20 ;
1183 row_index[26] = 26 ;
1186 row_index[27] = 21 ;
1189 row_index[28] = 25 ;
1192 row_index[29] = 22 ;
1195 row_index[30] = 24 ;
1198 row_index[31] = 23 ;
1202 "image, there must be 32 slitlets!\n") ;
1229 sinfo_new_make_cube_spi ( cpl_image * calibImage,
1230 float ** slit_edges,
1233 cpl_imagelist * returnCube ;
1250 if ( NULL == calibImage )
1255 ilx=cpl_image_get_size_x(calibImage);
1256 ily=cpl_image_get_size_y(calibImage);
1257 pidata=cpl_image_get_data_float(calibImage);
1259 if ( NULL == slit_edges )
1261 sinfo_msg_error(
"no slit_edges array given from sinfo_fitSlits()!/n") ;
1265 if ( N_SLITLETS != 32 )
1270 imsize = ilx / N_SLITLETS ;
1273 if ( NULL == (row_index = (
int*) cpl_calloc(N_SLITLETS,
sizeof(
int)) ) )
1278 if ( NULL == (beginCol = (
int*) cpl_calloc(N_SLITLETS,
sizeof(
int)) ) )
1281 cpl_free(row_index) ;
1284 if ( NULL == (center = (
float*) cpl_calloc(N_SLITLETS,
sizeof(
float)) ) )
1287 cpl_free (row_index) ;
1288 cpl_free (beginCol) ;
1291 if ( NULL == (returnCube = cpl_imagelist_new()) )
1294 cpl_free (row_index) ;
1295 cpl_free (beginCol) ;
1301 for ( slit = 0 ; slit < N_SLITLETS ; slit++ )
1304 center[slit] = (slit_edges[slit][1] + slit_edges[slit][0]) / 2. ;
1310 if(-1 == sinfo_sort_slitlets_array(slit,row_index)) {
1311 cpl_imagelist_delete(returnCube) ;
1312 cpl_free (row_index) ;
1313 cpl_free (beginCol) ;
1319 start = center[slit] - (float) (imsize - 1)/2. ;
1320 beginCol[slit] = sinfo_new_nint (start) ;
1322 diff = start - (float)beginCol[slit] ;
1329 shift[row_index[slit]] = diff ;
1333 for ( z = 0 ; z < ily ; z++ )
1335 o_img=cpl_image_new(imsize,N_SLITLETS,CPL_TYPE_FLOAT);
1336 podata=cpl_image_get_data_float(o_img);
1337 for ( slit = 0 ; slit < N_SLITLETS ; slit++ )
1339 col_counter = beginCol[slit] ;
1341 for ( col = 0 ; col < imsize ; col++ )
1343 if ( col_counter > ilx-1 )
1347 if ( col_counter + z*ilx < 0 )
1349 podata[col+row_index[slit]*imsize] = pidata[0] ;
1353 podata[col+row_index[slit]*imsize]=pidata[col_counter+z*ilx];
1359 cpl_imagelist_set(returnCube,o_img,z);
1361 cpl_free (row_index) ;
1362 cpl_free (beginCol) ;
1394 sinfo_new_make_cube_dist ( cpl_image * calibImage,
1399 cpl_imagelist * returnCube ;
1415 if ( NULL == calibImage )
1420 ilx=cpl_image_get_size_x(calibImage);
1421 ily=cpl_image_get_size_y(calibImage);
1422 pidata=cpl_image_get_data_float(calibImage);
1424 if ( NULL == distances )
1426 sinfo_msg_error(
"no distances array given from north_south_test()!") ;
1430 if ( N_SLITLETS != 32 )
1435 imsize = ilx / N_SLITLETS ;
1438 if ( NULL == (row_index = (
int*) cpl_calloc(N_SLITLETS,
sizeof(
int)) ) )
1443 if ( NULL == (beginCol = (
int*) cpl_calloc(N_SLITLETS,
sizeof(
int)) ) )
1446 cpl_free(row_index) ;
1449 if ( NULL == (returnCube = cpl_imagelist_new()) )
1452 cpl_free(row_index) ;
1453 cpl_free(beginCol) ;
1460 for ( slit = 0 ; slit < N_SLITLETS ; slit++ )
1469 if(-1 == sinfo_sort_slitlets_array(slit,row_index)) {
1470 cpl_imagelist_delete(returnCube) ;
1471 cpl_free(row_index) ;
1472 cpl_free(beginCol) ;
1483 di += distances[slit-1] ;
1484 start = firstCol + di ;
1486 beginCol[slit] = sinfo_new_nint(start) ;
1490 diff = start - (float)beginCol[slit] ;
1497 shift[row_index[slit]] = diff ;
1501 for ( z = 0 ; z < ily ; z++ )
1503 o_img=cpl_image_new(imsize,N_SLITLETS,CPL_TYPE_FLOAT);
1504 podata=cpl_image_get_data_float(o_img);
1505 for ( slit = 0 ; slit < N_SLITLETS ; slit++ )
1507 col_counter = beginCol[slit] ;
1509 for ( col = 0 ; col < imsize ; col++ )
1511 if ( col_counter > ilx-1 )
1515 if ( col_counter + z*ilx < 0 )
1517 podata[col+row_index[slit]*imsize] = podata[0] ;
1521 podata[col+row_index[slit]*imsize]=pidata[col_counter+z*ilx];
1527 cpl_imagelist_set(returnCube,o_img,z);
1529 cpl_free (row_index) ;
1530 cpl_free (beginCol) ;
1561 sinfo_new_make_3D_cube_dist ( cpl_image * calibImage,
1566 cpl_imagelist * returnCube ;
1582 if ( NULL == calibImage )
1587 ilx=cpl_image_get_size_x(calibImage);
1588 ily=cpl_image_get_size_y(calibImage);
1589 pidata=cpl_image_get_data_float(calibImage);
1591 if ( NULL == distances )
1593 sinfo_msg_error(
"no distances array given from north_south_test()!") ;
1597 if ( N_SLITLETS != 16 )
1602 imsize = ilx / N_SLITLETS ;
1605 if ( NULL == (row_index = (
int*) cpl_calloc(N_SLITLETS,
sizeof(
int)) ) )
1610 if ( NULL == (beginCol = (
int*) cpl_calloc(N_SLITLETS,
sizeof(
int)) ) )
1613 cpl_free(row_index) ;
1616 if ( NULL == (returnCube = cpl_imagelist_new()) )
1619 cpl_free(row_index) ;
1620 cpl_free(beginCol) ;
1627 for ( slit = 0 ; slit < N_SLITLETS ; slit++ )
1636 row_index[slit] = slit ;
1645 di += distances[slit-1] ;
1646 start = firstCol + di ;
1648 beginCol[slit] = sinfo_new_nint(start) ;
1652 diff = start - (float)beginCol[slit] ;
1659 shift[row_index[slit]] = diff ;
1663 for ( z = 0 ; z < ily ; z++ )
1665 o_img=cpl_image_new(imsize,N_SLITLETS,CPL_TYPE_FLOAT);
1666 podata=cpl_image_get_data_float(o_img);
1667 for ( slit = 0 ; slit < N_SLITLETS ; slit++ )
1669 col_counter = beginCol[slit] ;
1671 for ( col = 0 ; col < imsize ; col++ )
1673 if ( col_counter > ilx-1 )
1677 podata[col+row_index[slit]*imsize]=pidata[col_counter+z*ilx];
1681 cpl_imagelist_set(returnCube,o_img,z);
1683 cpl_free (row_index) ;
1684 cpl_free (beginCol) ;
1707 sinfo_new_make_3D_cube ( cpl_image * calibImage,
1711 cpl_imagelist * returnCube ;
1712 int imsize, kslit, kpix ;
1721 if ( NULL == calibImage )
1726 ilx=cpl_image_get_size_x(calibImage);
1727 ily=cpl_image_get_size_y(calibImage);
1728 pidata=cpl_image_get_data_float(calibImage);
1730 if ( NULL == kpixshift )
1736 if ( kpixfirst < 0 )
1742 if ( N_SLITLETS != 16 )
1747 imsize = ilx / N_SLITLETS ;
1749 if ( NULL == (returnCube = cpl_imagelist_new()) )
1756 for ( z = 0 ; z < ily ; z++ )
1758 o_img=cpl_image_new(imsize,N_SLITLETS,CPL_TYPE_FLOAT);
1759 podata=cpl_image_get_data_float(o_img);
1763 for ( col = 0 ; col < ilx ; col++ )
1765 if ( col % imsize == 0 )
1768 kslit = col/imsize ;
1769 kpix = kpixfirst + kpixshift[kslit] ;
1773 podata[recol+kslit*imsize] = pidata[col+kpix+z*ilx] ;
1775 if ( recol > imsize )
1778 "shouldn't happen!\n") ;
1779 cpl_imagelist_delete(returnCube) ;
1783 cpl_imagelist_set(returnCube,o_img,z);
1801 sinfo_new_determine_mask_cube ( cpl_imagelist * sourceMaskCube,
1805 cpl_imagelist * retCube ;
1816 if ( sourceMaskCube == NULL )
1821 ilx=cpl_image_get_size_x(cpl_imagelist_get(sourceMaskCube,0));
1822 ily=cpl_image_get_size_y(cpl_imagelist_get(sourceMaskCube,0));
1823 inp=cpl_imagelist_get_size(sourceMaskCube);
1826 if ( lowLimit > 0. )
1831 if ( highLimit >= 1. || highLimit < 0. )
1837 retCube = cpl_imagelist_duplicate (sourceMaskCube) ;
1842 for ( z = 0 ; z < onp ; z++ )
1844 o_img=cpl_imagelist_get(retCube,0);
1845 podata=cpl_image_get_data_float(o_img);
1846 for ( n = 0 ; n < (int) olx*oly; n++ )
1848 if ( podata[n] == 0. )
1852 if ( podata[n] == 1. )
1856 if ( podata[n] >= lowLimit &&
1857 podata[n] <= highLimit )
1908 sinfo_new_interpol_cube ( cpl_imagelist * sourceCube,
1909 cpl_imagelist * maskCube,
1913 cpl_imagelist * returnCube ;
1916 int n_im, n_bad, n_bad1, n_bad2 ;
1917 int n_planes, specn, nspec1 ;
1918 int i, m, n, z, ni, kk, p ;
1919 int dis, dismin, dismax ;
1921 int xcordi, ycordi, xcordm, ycordm ;
1932 cpl_image* i_img=NULL;
1933 cpl_image* m_img=NULL;
1934 cpl_image* o_img=NULL;
1936 if ( NULL == sourceCube )
1943 ilx=cpl_image_get_size_x(cpl_imagelist_get(sourceCube,0));
1944 ily=cpl_image_get_size_y(cpl_imagelist_get(sourceCube,0));
1945 inp=cpl_imagelist_get_size(sourceCube);
1947 if ( NULL == maskCube )
1953 if ( n_neighbors <= 0 )
1956 "direction given!") ;
1960 if ( max_radius <= 0 )
1963 "an image plane given!") ;
1967 returnCube = cpl_imagelist_duplicate(sourceCube) ;
1972 spec1=cpl_calloc(300,
sizeof(
float)) ;
1973 spec=sinfo_new_2Dfloatarray(100,2*n_neighbors+1) ;
1976 for ( z = 0 ; z < n_planes ; z++ )
1978 m_img=cpl_imagelist_get(maskCube,z);
1979 pmdata=cpl_image_get_data_float(m_img);
1980 o_img=cpl_imagelist_get(returnCube,z);
1981 podata=cpl_image_get_data_float(o_img);
1988 if ( z < n_neighbors )
1992 else if ( n_planes - z <= n_neighbors)
1994 n = n_planes - z -1 ;
2001 for ( i = 0 ; i < n_im ; i ++ )
2004 if ( pmdata[i] != 0. )
2018 for ( ni = z-n ; ni <= z+n ; ni++ )
2020 if ( pmdata[i] == 0. )
2043 if ( (2*n+1 - n_bad) < 3 || (n - n_bad1) < 1 || (n - n_bad2) < 1 )
2050 for ( ni = z-n ; ni <= z+n ; ni++ )
2052 i_img=cpl_imagelist_get(sourceCube,ni);
2053 pidata=cpl_image_get_data_float(i_img);
2054 spec[1][kk] = pmdata[i] != 0. ? pidata[i] : ZERO ;
2066 for ( m = 0 ; m < n_im ; m++ )
2068 if ( pmdata[m] == 0. )
2086 dis = abs(xcordi-xcordm) + abs(ycordi-ycordm) ;
2087 if ( dis <= dismin || dis > dismax )
2109 for ( ni = z-n ; ni <= z+n ; ni++ )
2111 if ( pmdata[i] == 0. || pmdata[m] == 0. )
2116 if ( n_bad > 2*n-1 )
2125 for ( ni = z-n ; ni <= z+n ; ni++ )
2127 i_img=cpl_imagelist_get(sourceCube,ni);
2128 pidata=cpl_image_get_data_float(i_img);
2129 spec[specn][kk] = pmdata[m] != 0. ? pidata[m] : ZERO ;
2144 if ( dismax > max_radius )
2158 for ( kk = 0 ; kk < 2*n+1 ; kk++ )
2166 if ( isnan(spec[1][kk]) )
2168 for ( p = 2 ; p <= specn ; p++ )
2170 spec[p][kk] = ZERO ;
2175 for ( p = 2 ; p <= specn ; p++ )
2177 if ( !isnan(spec[p][kk]) && spec[p][kk] != 0. &&
2178 !isnan(spec[p][n]) )
2180 spec[p][kk] = spec[1][kk] /
2181 spec[p][kk] * spec[p][n] ;
2185 spec[p][kk] = ZERO ;
2200 for ( p = 2 ; p <= specn ; p++ )
2202 for ( kk = 0 ; kk < 2*n+1 ; kk++ )
2204 if ( !isnan(spec[p][kk]) && kk != n )
2206 spec1[nspec1] = spec[p][kk] ;
2219 podata[i] = sinfo_new_median(spec1, nspec1) ;
2223 sinfo_new_destroy_2Dfloatarray(&spec,2*n_neighbors+1) ;
2248 sinfo_new_fine_tune_cube( cpl_imagelist * cube,
2249 float * correct_diff_dist,
2252 cpl_imagelist * returnCube ;
2253 float* row_data=NULL ;
2254 float* corrected_row_data=NULL ;
2256 float sum, new_sum ;
2261 int imsize, n_points ;
2270 cpl_image* i_img=NULL;
2271 cpl_image* o_img=NULL;
2279 ilx=cpl_image_get_size_x(cpl_imagelist_get(cube,0));
2280 ily=cpl_image_get_size_y(cpl_imagelist_get(cube,0));
2281 inp=cpl_imagelist_get_size(cube);
2283 if ( NULL == correct_diff_dist )
2292 returnCube = cpl_imagelist_duplicate(cube);
2296 returnCube = cpl_imagelist_duplicate(cube);
2299 if ( imsize != N_SLITLETS )
2305 n_points = n_order + 1 ;
2306 if ( n_points % 2 == 0 )
2308 firstpos = (int)(n_points/2) - 1 ;
2312 firstpos = (int)(n_points/2) ;
2314 xnum=cpl_calloc(n_order+1,
sizeof(
float)) ;
2316 for ( i = 0 ; i < n_points ; i++ )
2321 row_data=cpl_calloc(ilx,
sizeof(
float)) ;
2322 corrected_row_data=cpl_calloc(ilx,
sizeof(
float)) ;
2324 for ( z = 0 ; z < inp ; z++ )
2326 i_img=cpl_imagelist_get(cube,z);
2327 pidata=cpl_image_get_data_float(i_img);
2328 o_img=cpl_imagelist_get(returnCube,z);
2329 podata=cpl_image_get_data_float(o_img);
2332 for ( row = 0 ; row < imsize ; row++ )
2334 for ( col = 0 ; col < ilx ; col++ )
2336 corrected_row_data[col] = 0. ;
2339 for ( col = 0 ; col < ilx ; col++ )
2341 row_data[col] = pidata[col+row*ilx] ;
2342 if ( isnan(row_data[col]) )
2344 row_data[col] = 0. ;
2345 for ( i = col - firstpos ;
2346 i < col -firstpos+n_points ; i++ )
2348 if ( i < 0 ) continue ;
2349 if ( i >= ilx) continue ;
2350 corrected_row_data[i] = ZERO ;
2353 if ( col != 0 && col != ilx - 1 )
2355 sum += row_data[col] ;
2361 for ( col = 0 ; col < ilx ; col++ )
2364 if ( isnan(corrected_row_data[col]) )
2368 if ( col - firstpos < 0 )
2370 imageptr = &row_data[0] ;
2371 eval = correct_diff_dist[row] + col ;
2373 else if ( col - firstpos + n_points >= ilx )
2375 imageptr = &row_data[ilx - n_points] ;
2376 eval = correct_diff_dist[row] + col + n_points - ilx ;
2380 imageptr = &row_data[col-firstpos] ;
2381 eval = correct_diff_dist[row] + firstpos ;
2386 corrected_row_data[col]=sinfo_new_nev_ille(xnum, imageptr,
2387 n_order, eval, &flag);
2390 if ( col != 0 && col != ilx - 1 )
2392 new_sum += corrected_row_data[col] ;
2395 for ( col = 0 ; col < ilx ; col++ )
2400 podata[col+row*ilx] = ZERO ;
2402 else if ( col == ilx - 1 )
2404 podata[col+row*ilx] = ZERO ;
2408 if ( isnan(corrected_row_data[col]) )
2410 podata[col+row*ilx] = ZERO ;
2414 if ( new_sum == 0. ) new_sum = 1. ;
2416 podata[col+row*ilx] = corrected_row_data[col] ;
2424 cpl_free(row_data) ;
2425 cpl_free(corrected_row_data) ;
2450 sinfo_new_fine_tune_cube_by_FFT( cpl_imagelist * cube,
2451 float * correct_diff_dist )
2453 cpl_imagelist * returnCube ;
2455 float* row_data=NULL ;
2456 dcomplex* data=NULL ;
2457 dcomplex* corrected_data=NULL ;
2466 int blank_indicator ;
2475 cpl_image* i_img=NULL;
2476 cpl_image* o_img=NULL;
2485 ilx=cpl_image_get_size_x(cpl_imagelist_get(cube,0));
2486 ily=cpl_image_get_size_y(cpl_imagelist_get(cube,0));
2487 inp=cpl_imagelist_get_size(cube);
2490 if ( NULL == correct_diff_dist )
2496 returnCube = cpl_imagelist_duplicate( cube ) ;
2499 if ( imsize != N_SLITLETS )
2505 data=cpl_calloc(ilx,
sizeof(dcomplex)) ;
2506 corrected_data=cpl_calloc(ilx,
sizeof(dcomplex)) ;
2508 row_data=cpl_calloc(ilx,
sizeof(
float)) ;
2510 for ( z = 0 ; z < inp ; z++ )
2512 i_img=cpl_imagelist_get(cube,z);
2513 pidata=cpl_image_get_data_float(i_img);
2514 o_img=cpl_imagelist_get(returnCube,z);
2515 podata=cpl_image_get_data_float(o_img);
2517 for ( row = 0 ; row < imsize ; row++ )
2519 blank_indicator = 1 ;
2520 for ( col = 0 ; col < ilx ; col++ )
2523 row_data[col] = pidata[col+row*ilx] ;
2524 data[col].x = row_data[col] ;
2527 if ( isnan(row_data[col]) )
2529 blank_indicator = 0 ;
2534 if ( blank_indicator == 0 )
2536 for ( col = 0 ; col < ilx ; col++ )
2538 podata[col+row*ilx] = ZERO ;
2544 sinfo_fftn( data, nn, 1, 1 ) ;
2547 phi = 2*PI_NUMB/(float)ilx * correct_diff_dist[row] ;
2548 for ( i = 0 ; i < ilx ; i++ )
2554 pphi = phi * (float)(i) ;
2556 coph = cos ( pphi ) ;
2557 siph = sin ( pphi ) ;
2562 pphi = phi * (float)(i - ilx/2) ;
2564 coph = cos ( pphi ) ;
2565 siph = sin ( pphi ) ;
2575 corrected_data[i].x = data[i].x * coph - data[i].y * siph ;
2577 corrected_data[i].y = data[i].x * siph + data[i].y * coph ;
2581 sinfo_fftn( corrected_data, nn, 1, -1 ) ;
2584 for ( i = 0 ; i < ilx ; i++ )
2586 corrected_data[i].x /= ilx ;
2587 corrected_data[i].y /= ilx ;
2592 for ( col = 0 ; col < ilx ; col++ )
2596 podata[col+row*ilx] = ZERO ;
2598 else if ( col == ilx - 1 )
2600 podata[col+row*ilx] = ZERO ;
2604 podata[col+row*ilx] = corrected_data[col].x ;
2611 cpl_free(corrected_data) ;
2644 cpl_imagelist * sinfo_new_fine_tune_cube_by_spline ( cpl_imagelist * cube,
2645 float * correct_diff_dist )
2647 cpl_imagelist * returnCube ;
2649 float* row_data=NULL ;
2650 float* corrected_row_data=NULL ;
2654 float sum, new_sum ;
2664 cpl_image* i_img=NULL;
2665 cpl_image* o_img=NULL;
2673 ilx=cpl_image_get_size_x(cpl_imagelist_get(cube,0));
2674 ily=cpl_image_get_size_y(cpl_imagelist_get(cube,0));
2675 inp=cpl_imagelist_get_size(cube);
2677 if ( NULL == correct_diff_dist )
2684 if ( imsize != N_SLITLETS )
2690 returnCube = cpl_imagelist_duplicate( cube ) ;
2692 row_data=cpl_calloc(ilx,
sizeof(
float)) ;
2693 corrected_row_data=cpl_calloc(ilx,
sizeof(
float)) ;
2694 xnum=cpl_calloc(ilx,
sizeof(
float)) ;
2695 eval=cpl_calloc(ilx,
sizeof(
float)) ;
2698 for ( i = 0 ; i < ilx ; i++ )
2704 for ( z = 0 ; z < inp ; z++ )
2706 i_img=cpl_imagelist_get(cube,z);
2707 pidata=cpl_image_get_data_float(i_img);
2708 o_img=cpl_imagelist_get(returnCube,z);
2709 podata=cpl_image_get_data_float(o_img);
2711 for ( row = 0 ; row < imsize ; row++ )
2713 for ( col = 0 ; col < ilx ; col++ )
2715 corrected_row_data[col] = 0. ;
2720 for ( col = 0 ; col < ilx ; col++ )
2722 eval[col] = correct_diff_dist[row] + (float)col ;
2723 row_data[col] = pidata[col+row*ilx] ;
2724 if (col != 0 && col != ilx - 1 && !isnan(row_data[col]) )
2726 sum += row_data[col] ;
2728 if (isnan(row_data[col]) )
2730 for ( i = col -1 ; i <= col+1 ; i++ )
2732 if ( i < 0 ) continue ;
2733 if ( i >= ilx ) continue ;
2734 corrected_row_data[i] = ZERO ;
2736 row_data[col] = 0. ;
2745 if ( -1 == sinfo_function1d_natural_spline(xnum,row_data, ilx,
2746 eval,corrected_row_data,
2750 cpl_imagelist_delete(returnCube) ;
2755 for ( col = 0 ; col < ilx ; col++ )
2757 if (isnan(corrected_row_data[col])) continue ;
2760 if ( col != 0 && col != ilx - 1 )
2762 new_sum += corrected_row_data[col] ;
2765 for ( col = 0 ; col < ilx ; col++ )
2774 podata[col+row*ilx] = ZERO ;
2776 else if ( col == ilx - 1 )
2778 podata[col+row*ilx] = ZERO ;
2782 if ( isnan(corrected_row_data[col]) )
2784 podata[col+row*ilx] = ZERO ;
2788 if (new_sum == 0.) new_sum = 1. ;
2793 podata[col+row*ilx] = corrected_row_data[col] ;
2800 cpl_free(row_data) ;
2801 cpl_free(corrected_row_data) ;
2830 sinfo_new_calibrate_ns_test( cpl_image * ns_image,
2835 float estimated_dist,
2840 int i, j, k, m, row, col, n, ni, na ;
2841 int position, counter, iters ;
2842 int xdim, ndat, its, numpar ;
2843 float sum, mean, maxval ;
2846 float * ret_distances ;
2848 float * xdat, * wdat ;
2851 pixelvalue* row_buf=NULL ;
2852 float** distances_buf=NULL ;
2853 float* x_position=NULL ;
2855 int* found_clean=NULL ;
2856 int* found_cleanit=NULL ;
2860 int foundit, begin, end ;
2868 if ( ns_image == NULL )
2873 if ( n_slitlets < 1 )
2878 if ( halfWidth < 0 || halfWidth >= estimated_dist )
2895 if (NULL==(distances=(
float *)cpl_calloc( n_slitlets ,
sizeof (
float) )))
2901 if (NULL == (ret_distances = (
float *) cpl_calloc ( n_slitlets ,
2908 ilx=cpl_image_get_size_x(ns_image);
2909 ily=cpl_image_get_size_y(ns_image);
2910 pidata=cpl_image_get_data_float(ns_image);
2912 row_buf=(pixelvalue*)cpl_calloc(ilx,
sizeof(pixelvalue)) ;
2913 x_position=cpl_calloc(n_slitlets,
sizeof(
float)) ;
2914 found=cpl_calloc(3*n_slitlets,
sizeof(
int));
2915 found_clean=cpl_calloc(3*n_slitlets,
sizeof(
int)) ;
2916 found_cleanit=cpl_calloc(3*n_slitlets,
sizeof(
int)) ;
2917 distances_buf=sinfo_new_2Dfloatarray(ily,n_slitlets) ;
2920 for ( row = 0 ; row < ily ; row++ )
2925 for ( i = 0 ; i < n_slitlets ; i++ )
2927 distances_buf[row][i] = ZERO ;
2931 for ( col = 0 ; col < ilx ; col++ )
2933 row_buf[col] = pidata[col + row*ilx] ;
2939 for ( i = 0 ; i < ilx ; i++ )
2941 if ( isnan(row_buf[i]) )
2948 mean = sum / (float)n ;
2952 for ( i = 0 ; i < ilx ; i++ )
2954 if (isnan(row_buf[i]))
2958 if ( row_buf[i] > mean + ESTIMATE )
2965 if ( n < n_slitlets )
2968 "found in row: %d, found number: %d", row, n) ;
2975 for ( i = 1 ; i < n ; i ++ )
2977 if ( found[i] - found[i-1] < halfWidth )
2979 begin = found[i] - halfWidth ;
2984 end = found[i] + halfWidth ;
2993 for ( j = begin ; j <= end ; j++ )
2996 if (isnan(row_buf[j]))
3000 if (row_buf[j] >= maxval )
3002 maxval = row_buf[j] ;
3006 if (maxval == -FLT_MAX)
3010 for ( k = 0 ; k < na ; k++ )
3012 if ( found_cleanit[k] >= begin &&
3013 found_cleanit[k] < foundit )
3018 for ( k = 0 ; k < n ; k++ )
3020 if ( found[k] == foundit)
3022 if ( found_cleanit[na-1] != found[k] )
3024 found_cleanit[na] = found[k] ;
3034 found_cleanit[na] = found[0] ;
3036 found_cleanit[na] = found[1] ;
3041 if ( found_cleanit[na-1] != found[i-1])
3043 found_cleanit[na] = found[i-1] ;
3046 if ( found_cleanit[na-1] != found[i])
3048 found_cleanit[na] = found[i] ;
3057 for ( i = 1 ; i < na ; i++ )
3059 if ( (
float)(found_cleanit[i] - found_cleanit[i-1]) <
3060 (estimated_dist - devtol) ||
3061 (
float)(found_cleanit[i] - found_cleanit[i-1]) >
3062 (estimated_dist + devtol) )
3068 found_clean[j-1] = found_cleanit[i-1] ;
3069 found_clean[j] = found_cleanit[i] ;
3074 if ( j > n_slitlets )
3078 for ( i = 1 ; i < j ; i++ )
3080 if ( (
float)(found_clean[i] - found_clean[i-1]) <
3081 (estimated_dist - devtol ) ||
3082 (
float)(found_clean[i] - found_clean[i-1]) >
3083 (estimated_dist + devtol ) )
3089 found_clean[ni-1] = found_clean[i-1] ;
3090 found_clean[ni] = found_clean[i] ;
3094 if ( ni != n_slitlets )
3097 "found in row: %d, found number: %d",
3106 else if ( j < n_slitlets )
3109 "in row: %d , found number: %d\n", row, j) ;
3114 for ( i = 0 ; i < j ; i++ )
3117 if ( NULL == (line = sinfo_new_vector (2*halfWidth + 1)) )
3120 cpl_free(distances) ;
3125 xdat = (
float *) cpl_calloc( line -> n_elements,
sizeof (
float) ) ;
3126 wdat = (
float *) cpl_calloc( line -> n_elements,
sizeof (
float) ) ;
3127 mpar = (
int *) cpl_calloc( MAXPAR,
sizeof (
int) ) ;
3128 par = sinfo_new_fit_params(1) ;
3131 for ( k = found_clean[i]-halfWidth ;
3132 k <= found_clean[i]+halfWidth ; k++ )
3138 else if ( k >= ilx )
3142 else if ( isnan(row_buf[k]) )
3149 line -> data[m] = row_buf[k] ;
3153 if ( zeroindicator == 1 )
3155 sinfo_new_destroy_vector(line) ;
3159 sinfo_new_destroy_fit_params(&par) ;
3168 position = -INT32_MAX ;
3169 for ( k = 0 ; k < m ; k++ )
3173 if ( line -> data[k] >= maxval )
3175 maxval = line -> data[k] ;
3182 ndat = line -> n_elements ;
3187 (*par) -> fit_par[1] = fwhm ;
3188 (*par) -> fit_par[2] = (float) position ;
3189 (*par) -> fit_par[3] = (float) (line -> data[0] +
3190 line -> data[line->n_elements - 1]) / 2.0 ;
3191 (*par) -> fit_par[0] = maxval - ((*par) -> fit_par[3]) ;
3195 if ( (*par) -> fit_par[0] < minDiff )
3198 "in row: %d in slitlet %d\n", row, i) ;
3199 sinfo_new_destroy_vector(line) ;
3203 sinfo_new_destroy_fit_params(&par) ;
3207 for ( k = 0 ; k < MAXPAR ; k++ )
3209 (*par) -> derv_par[k] = 0.0 ;
3213 if ( 0 > ( iters = sinfo_new_lsqfit_c(xdat, &xdim,
3215 &ndat, (*par) -> fit_par,
3216 (*par) -> derv_par, mpar,
3226 sinfo_new_destroy_vector(line) ;
3230 sinfo_new_destroy_fit_params(&par) ;
3235 if ( (*par) -> fit_par[0] <= 0. || (*par) -> fit_par[1] <= 0. ||
3236 (*par) -> fit_par[2] < 0. )
3239 "used! in row %d in slitlet %d", row, i) ;
3240 sinfo_new_destroy_vector(line) ;
3244 sinfo_new_destroy_fit_params(&par) ;
3250 (*par) -> fit_par[2] = (float) (found_clean[i] - halfWidth) +
3251 (*par) -> fit_par[2] ;
3252 x_position[counter] = (*par) -> fit_par[2] ;
3256 sinfo_new_destroy_fit_params(&par) ;
3257 sinfo_new_destroy_vector ( line ) ;
3262 if (zeroindicator == 1)
3268 if ( counter != n_slitlets )
3271 "in row: %d", row) ;
3275 for ( i = 0 ; i < n_slitlets ; i++ )
3277 distances_buf[row][i] = x_position[i] - (15.5 + 32.*(float)i) ;
3285 for ( i = 0 ; i < n_slitlets ; i++ )
3289 for ( row = bottom ; row < top ; row++ )
3291 if ( fabs( distances_buf[row][i] ) > devtol ||
3292 isnan(distances_buf[row][i]) )
3302 sum += distances_buf[row][i] ;
3308 " completely!, deviations of distances from"
3309 " devtol too big" ) ;
3310 cpl_free(distances) ;
3315 distances[i] = sum / (float)n ;
3321 for ( i = 0 ; i < n_slitlets ; i++ )
3323 if( (row_index=sinfo_sort_slitlets(i)) == -1) {
3325 cpl_free (distances) ;
3328 ret_distances[row_index] = distances[i] ;
3330 cpl_free(distances) ;
3333 cpl_free(x_position) ;
3335 cpl_free(found_clean) ;
3336 cpl_free(found_cleanit) ;
3337 sinfo_new_destroy_2Dfloatarray(&distances_buf,n_slitlets) ;
3340 return ret_distances ;
3367 sinfo_new_make_true_resamp(cpl_image * calibImage,
3368 cpl_image * wavemap)
3370 cpl_image * returnImage ;
3372 int imsize, kslit,i,j ;
3387 wlx=cpl_image_get_size_x(wavemap);
3389 pwdata=cpl_image_get_data_float(wavemap);
3393 for(i=0;i<wlx-1;i++)
3395 if((pwdata[i]-pwdata[i+1])>0.0025 || (pwdata[i]-pwdata[i+1])<-0.0025)
3404 clx=cpl_image_get_size_x(calibImage);
3405 cly=cpl_image_get_size_y(calibImage);
3406 pcdata=cpl_image_get_data_float(calibImage);
3408 imsize = clx / N_SLITLETS ;
3411 returnImage = cpl_image_new(clx,cly,CPL_TYPE_FLOAT);
3412 prdata=cpl_image_get_data_float(returnImage);
3413 for ( z = 0 ; z < cly ; z++ )
3415 for ( col = 0 ; col < clx ; col++ )
3416 prdata[col+z*clx]=ZERO;
3421 for ( z = 0 ; z < cly ; z++ )
3426 for ( col = 0 ; col < clx ; col++ )
3434 if(col>=sinfo_new_nint(edges[i]) &&
3435 col<sinfo_new_nint(edges[i+1]))
3439 if( (slit_index=sinfo_sort_slitlets(kslit)) == -1) {
3441 "spiffi image, there must be 32 "
3449 if((col-sinfo_new_nint(edges[kslit]))>0 &&
3450 (col-sinfo_new_nint(edges[kslit]))<imsize-1 )
3451 prdata[(col-sinfo_new_nint(edges[kslit]))+
3452 slit_index*imsize+z*clx] =
3455 prdata[(col-sinfo_new_nint(edges[kslit]))+
3456 slit_index*imsize+z*clx] = ZERO;
3461 return returnImage ;