153 #include "sinfo_vltPort.h"
163 #include "sinfo_absolute.h"
164 #include "sinfo_recipes.h"
175 #define LABMAXA 1.0e+10
176 #define LABMINA 1.0e-10
185 static double labda ;
186 static double vec[NPAR] ;
187 static double matrix1[NPAR][NPAR] ;
188 static double matrix2[NPAR][NPAR] ;
190 static int parptr[NPAR] ;
196 static int sinfo_new_inv_mat (
void) ;
198 static void sinfo_new_get_mat (
float * xdat,
207 static int sinfo_new_get_vec (
float * xdat,
251 (parlist[0] - parlist[1]) / (1 + exp(( xdat[0] - parlist[2] ) /
252 parlist[3])) + parlist[1] ;
254 return return_value ;
282 subst = (xdat[0] - parlist[2]) / parlist[3] ;
284 dervs[0] = 1. / ( 1. + exp(subst) ) ;
286 dervs[1] = -1. / ( 1. + exp(subst) ) + 1. ;
288 dervs[2] = ( (parlist[0] - parlist[1]) / parlist[3] * exp(subst) ) /
289 ( (1. + exp(subst)) * (1. + exp(subst)) ) ;
291 dervs[3] = ( (parlist[0] - parlist[1]) * (xdat[0] - parlist[2]) /
292 (parlist[3]*parlist[3]) * exp(subst) ) /
293 ( (1. + exp(subst)) * (1. + exp(subst)) ) ;
306 static int sinfo_new_inv_mat (
void)
317 for ( i = 0 ; i < nfree ; i++ )
322 for ( j = 0 ; j < nfree ; j++ )
325 rowmax = fabs ( matrix2[j][j] ) ;
328 for ( i = j + 1 ; i < nfree ; i++ )
330 if ( fabs ( matrix2[i][j] ) > rowmax )
332 rowmax = fabs( matrix2[i][j] ) ;
338 if ( matrix2[row][j] == 0.0 )
346 for ( k = 0 ; k < nfree ; k++ )
348 even = matrix2[j][k] ;
349 matrix2[j][k] = matrix2[row][k] ;
350 matrix2[row][k] = even ;
359 even = 1.0 / matrix2[j][j] ;
360 for ( i = 0 ; i < nfree ; i++ )
362 matrix2[i][j] *= even ;
364 matrix2[j][j] = even ;
366 for ( k = 0 ; k < j ; k++ )
368 mjk = matrix2[j][k] ;
369 for ( i = 0 ; i < j ; i++ )
371 matrix2[i][k] -= matrix2[i][j] * mjk ;
373 for ( i = j + 1 ; i < nfree ; i++ )
375 matrix2[i][k] -= matrix2[i][j] * mjk ;
377 matrix2[j][k] = -even * mjk ;
380 for ( k = j + 1 ; k < nfree ; k++ )
382 mjk = matrix2[j][k] ;
383 for ( i = 0 ; i < j ; i++ )
385 matrix2[i][k] -= matrix2[i][j] * mjk ;
387 for ( i = j + 1 ; i < nfree ; i++ )
389 matrix2[i][k] -= matrix2[i][j] * mjk ;
391 matrix2[j][k] = -even * mjk ;
396 for ( i = 0 ; i < nfree ; i++ )
398 for ( k = 0 ; k < nfree ; k++ )
400 hv[per[k]] = matrix2[i][k] ;
402 for ( k = 0 ; k < nfree ; k++ )
404 matrix2[i][k] = hv[k] ;
426 static void sinfo_new_get_mat (
float * xdat,
440 for ( j = 0 ; j < nfree ; j++ )
443 for ( i = 0 ; i<= j ; i++ )
446 matrix1[j][i] = 0.0 ;
452 for ( n = 0 ; n < (*ndat) ; n++ )
459 chi2 += yd * yd * wn ;
460 for ( j = 0 ; j < nfree ; j++ )
462 wd = epar[parptr[j]] * wn ;
464 for ( i = 0 ; i <= j ; i++ )
466 matrix1[j][i] += epar[parptr[i]] * wd ;
495 static int sinfo_new_get_vec (
float * xdat,
513 for ( j = 0 ; j < nfree ; j++ )
515 mjj = matrix1[j][j] ;
521 for ( i = 0 ; i < j ; i++ )
523 mji = matrix1[j][i] / mjj / sqrt( matrix1[i][i] ) ;
524 matrix2[i][j] = matrix2[j][i] = mji ;
526 matrix2[j][j] = 1.0 + labda ;
529 if ( (r = sinfo_new_inv_mat()) )
534 for ( i = 0 ; i < (*npar) ; i ++ )
540 for ( j = 0 ; j < nfree ; j++ )
543 mjj = matrix1[j][j] ;
549 for ( i = 0 ; i < nfree ; i++ )
551 mii = matrix1[i][i] ;
557 dj += vec[i] * matrix2[j][i] / mjj / mii ;
559 epar[parptr[j]] += dj ;
564 for ( n = 0 ; n < (*ndat) ; n++ )
570 chi1 += wdat[n] * dy * dy ;
651 if ( *tol < (FLT_EPSILON * 10.0 ) )
653 tolerance = FLT_EPSILON * 10.0 ;
660 labda = fabs( *lab ) * LABFACA ;
661 for ( i = 0 ; i < (*npar) ; i++ )
669 parptr[nfree++] = i ;
678 for ( n = 0 ; n < (*ndat) ; n++ )
693 for ( i = 0 ; i < nfree ; fpar[parptr[i++]] = 0.0 ) ;
694 sinfo_new_get_mat(xdat,xdim,ydat,wdat,ndat,fpar,epar ) ;
695 r = sinfo_new_get_vec(xdat,xdim,ydat,wdat,ndat,fpar,epar,npar) ;
700 for ( i = 0 ; i < (*npar) ; i++ )
705 chi1 = sqrt( chi1 / (
double) (nuse - nfree) ) ;
706 for ( i = 0 ; i < nfree ; i++ )
708 if ( (matrix1[i][i] <= 0.0 ) || (matrix2[i][i] <= 0.0) )
712 epar[parptr[i]] = chi1 * sqrt( matrix2[i][i] ) /
713 sqrt( matrix1[i][i] ) ;
735 if ( itc++ == (*its) )
739 sinfo_new_get_mat(xdat,xdim,ydat,wdat,ndat,fpar,epar) ;
745 if ( labda > LABMINA )
747 labda = labda / LABFACA ;
749 r = sinfo_new_get_vec ( xdat, xdim, ydat, wdat,
750 ndat, fpar, epar, npar ) ;
757 while ( chi1 >= chi2 )
765 if ( labda > LABMAXA )
769 labda = labda * LABFACA ;
770 r = sinfo_new_get_vec ( xdat, xdim, ydat, wdat,
771 ndat, fpar, epar, npar ) ;
779 if ( labda <= LABMAXA )
781 for ( i = 0 ; i < *npar ; i++ )
786 if ( (fabs( chi2 - chi1 ) <= (tolerance * chi1)) ||
796 sinfo_new_get_mat(xdat,xdim,ydat,wdat,ndat,fpar,epar);
797 r = sinfo_new_get_vec(xdat,xdim,ydat,wdat,ndat,fpar,epar,npar);
803 for ( i = 0 ; i < (*npar) ; i++ )
807 chi2 = sqrt ( chi2 / (
double) (nuse - nfree) ) ;
809 for ( i = 0 ; i < nfree ; i++ )
811 if ( (matrix1[i][i] <= 0.0) || (matrix2[i][i] <= 0.0) )
815 epar[parptr[i]] = chi2 * sqrt( matrix2[i][i] ) /
816 sqrt( matrix1[i][i] ) ;
872 float* position=NULL ;
873 int * sinfo_edge, * edgeclean ;
875 int * pos_row, * pos_rowclean ;
876 Vector * box_buffer ;
877 Vector * half_buffer ;
879 float max_intensity ;
882 int i, j, k, m, n, ed ;
885 int nel, n_right, left_right ;
886 int n_buf, edge_ind, shift ;
892 int iters, xdim, ndat ;
895 float * xdat, * wdat ;
898 float dervpar[NPAR] ;
899 float minval, maxval ;
901 float pos, last_pos ;
909 slit_length = SLITLENGTH ;
910 if ( NULL == lineImage )
922 if ( NULL == slit_pos )
928 if ( box_length < 4 ||
929 box_length > 2*slit_length )
935 if ( y_box <= 0. || y_box > 6. )
948 sinfo_edge = (
int*) cpl_calloc( 3*slit_length,
sizeof(
int) ) ;
949 dummyedge = (
int*) cpl_calloc( 3*slit_length,
sizeof(
int) ) ;
950 edgeclean = (
int*) cpl_calloc( slit_length-1,
sizeof(
int) ) ;
951 pos_row = (
int*) cpl_calloc( 3*slit_length,
sizeof(
int) ) ;
952 pos_rowclean = (
int*) cpl_calloc( slit_length,
sizeof(
int) ) ;
961 while( agreed == -1 )
964 max_intensity = -FLT_MAX ;
965 for ( col = 0 ; col < slit_length ; col++ )
967 for ( i = 0 ; i < par[0]->n_params ; i++ )
969 if ( par[i]->column == col && par[i]->line != bad_line )
971 if ( par[i]->fit_par[0] > max_intensity )
973 if ( par[i]->fit_par[1] >= 1. &&
974 par[i]->fit_par[2] > 0. )
976 max_intensity = par[i]->fit_par[0] ;
988 line = par[found]->line ;
989 column = par[found]->column ;
990 row_pos = par[found]->fit_par[2] ;
991 if ( found >= 0 && max_intensity > 0. )
993 for ( i = 0 ; i < par[0]->n_params ; i++ )
995 if ( par[i]->line == line-1 &&
996 par[i]->column == column + slit_length )
998 if ( par[i]->fit_par[2] <= (row_pos + y_box) &&
999 par[i]->fit_par[2] >= (row_pos - y_box) )
1005 if ( bad_line != line )
1013 sinfo_msg_error(
"no emission line found in the first image columns") ;
1014 cpl_free( sinfo_edge ) ;
1015 cpl_free( pos_row ) ;
1016 cpl_free( edgeclean ) ;
1017 cpl_free( dummyedge ) ;
1018 cpl_free( pos_rowclean ) ;
1027 sinfo_msg_error(
" no emission line found in the first image columns") ;
1028 cpl_free( sinfo_edge ) ;
1029 cpl_free( pos_row ) ;
1030 cpl_free( edgeclean ) ;
1031 cpl_free( dummyedge ) ;
1032 cpl_free( pos_rowclean ) ;
1036 ilx=cpl_image_get_size_x(lineImage);
1037 ily=cpl_image_get_size_y(lineImage);
1038 pidata=cpl_image_get_data_float(lineImage);
1043 position=cpl_calloc(ilx,
sizeof(
float)) ;
1046 for ( col = slit_length/2 ; col < ilx - slit_length/2 ; col++ )
1048 for ( i = 0 ; i < par[0]->n_params ; i++ )
1054 if ( par[i]->column == col && par[i]->line == line )
1056 if ( par[i]->fit_par[0] > 0. &&
1057 par[i]->fit_par[1] >= 1. &&
1058 par[i]->fit_par[2] > 0. )
1060 position[n] = par[i]->fit_par[2] ;
1061 old_pos=position[n];
1063 fabs(position[n] - position[n-1]) > y_box &&
1064 (col-old_col) > (slit_length-SLIT_POS_ERR) )
1068 sinfo_edge[ed] = col ;
1069 pos_row[ed] = sinfo_new_nint( position[n-1] ) ;
1073 if ( col >= ilx - slit_length - SLIT_POS_ERR ) {
1074 pos_row[ed] = sinfo_new_nint( position[n] ) ;
1076 }
else if ( ((col-old_col) >
1077 (slit_length+SLIT_POS_ERR)) &&
1080 sinfo_edge[ed] = col ;
1081 pos_row[ed] = sinfo_new_nint( position[n-1] ) ;
1083 ed,sinfo_edge[ed],pos_row[ed]);
1085 if ( col >= ilx - slit_length - SLIT_POS_ERR ) {
1086 pos_row[ed] = sinfo_new_nint( position[n] ) ;
1091 }
else if ( ((col-old_col) > (slit_length+SLIT_POS_ERR)) &&
1097 position[n] = old_pos ;
1099 old_col+=slit_length;
1100 sinfo_edge[ed] = old_col; ;
1101 pos_row[ed] = sinfo_new_nint( position[n-1] ) ;
1105 ed,sinfo_edge[ed],pos_row[ed]);
1107 if ( old_col >= ilx - slit_length - SLIT_POS_ERR ) {
1108 pos_row[ed] = old_pos ;
1116 if ( ed < (N_SLITLETS - 1) )
1119 cpl_free( sinfo_edge ) ;
1120 cpl_free( pos_row ) ;
1121 cpl_free( edgeclean ) ;
1122 cpl_free( dummyedge ) ;
1123 cpl_free( pos_rowclean ) ;
1129 for ( i = 1 ; i <= ed ; i ++ )
1133 if ( (sinfo_edge[i-1] - sinfo_edge[i-2]) <
1134 slit_length - SLIT_LEN_ERR ||
1135 (sinfo_edge[i-1] - sinfo_edge[i-2]) >
1136 slit_length + SLIT_LEN_ERR )
1140 dummyedge[i-1] = -1 ;
1143 if (dummyedge[i-1] != -1)
1145 dummyedge[i-1] = sinfo_edge[i-1] ;
1153 if ( (sinfo_edge[i] - sinfo_edge[i-1]) <
1154 slit_length - SLIT_LEN_ERR ||
1155 (sinfo_edge[i] - sinfo_edge[i-1]) >
1156 slit_length + SLIT_LEN_ERR )
1162 if ( i+1 < ed && dummyedge[i] != -1 )
1164 if ( (sinfo_edge[i+1] - sinfo_edge[i]) <
1165 slit_length - SLIT_LEN_ERR ||
1166 (sinfo_edge[i+1] - sinfo_edge[i]) >
1167 slit_length + SLIT_LEN_ERR )
1170 dummyedge[i+1] = -1 ;
1176 for ( i = 0 ; i < ed ; i++ )
1178 if ( dummyedge[i] != -1 && dummyedge[i] != 0 )
1180 edgeclean[k] = dummyedge[i] ;
1181 pos_rowclean[k] = pos_row[i] ;
1183 if( edgeclean[k-1] > (ilx - slit_length -2*SLIT_LEN_ERR ) )
1185 pos_rowclean[k] = pos_row[ed] ;
1195 if ( k != N_SLITLETS - 1 )
1198 cpl_free( sinfo_edge ) ;
1199 cpl_free( pos_row ) ;
1200 cpl_free( edgeclean ) ;
1201 cpl_free( dummyedge ) ;
1202 cpl_free( pos_rowclean ) ;
1207 margin = box_length / 2 ;
1215 ( (pos_rowclean[0]-sinfo_new_nint(y_box)) < 0 ) ||
1216 ( (pos_rowclean[0]+sinfo_new_nint(y_box)) >ily )
1220 cpl_free( sinfo_edge ) ;
1221 cpl_free( pos_row ) ;
1222 cpl_free( edgeclean ) ;
1223 cpl_free( dummyedge ) ;
1224 cpl_free( pos_rowclean ) ;
1229 for ( j = 0 ; j <= k ; j++ )
1234 box_buffer = sinfo_new_vector( edgeclean[0] + margin ) ;
1235 for( col = 0 ; col < edgeclean[0] + margin ; col++ )
1238 for ( row = pos_rowclean[0] - sinfo_new_nint(y_box) ;
1239 row <= pos_rowclean[0] + sinfo_new_nint(y_box) ; row++ )
1241 if ( maxval < pidata[col + ilx*row] )
1243 maxval = pidata[col + ilx*row] ;
1246 box_buffer->data[m] = maxval ;
1252 box_buffer = sinfo_new_vector( edgeclean[j] -
1253 edgeclean[j-1] + 2*margin ) ;
1254 for ( col = edgeclean[j - 1] - margin ;
1255 col < edgeclean[j] + margin ; col++ )
1258 for ( row = pos_rowclean[j] - sinfo_new_nint(y_box) ;
1259 row <= pos_rowclean[j] + sinfo_new_nint(y_box) ; row++ )
1261 if ( maxval < pidata[col + ilx*row] )
1263 maxval = pidata[col + ilx*row] ;
1266 box_buffer->data[m] = maxval ;
1272 box_buffer = sinfo_new_vector( ilx - edgeclean[k-1] + margin ) ;
1273 for ( col = edgeclean[k - 1] - margin ; col < ilx ; col++ )
1276 for ( row = pos_rowclean[k-2] - sinfo_new_nint(y_box) ;
1277 row <= pos_rowclean[k-2] + sinfo_new_nint(y_box) ; row++ )
1279 if ( maxval < pidata[col + ilx*row] )
1281 maxval = pidata[col + ilx*row] ;
1284 if(maxval>0) box_buffer->data[m] = maxval ;
1285 else box_buffer->data[m] = 0;
1293 for ( i = 0 ; i < box_buffer->n_elements ; i++ )
1295 if ( box_buffer -> data[i] < min )
1297 min = box_buffer -> data[i] ;
1301 for ( left_right = 0 ; left_right <= 1 ; left_right++ )
1304 if ( left_right == 0 )
1306 nel = box_buffer -> n_elements / 2 ;
1310 if ( box_buffer -> n_elements % 2 == 0 )
1312 nel = box_buffer -> n_elements / 2 ;
1316 nel = box_buffer -> n_elements / 2 + 1 ;
1322 half_buffer = sinfo_new_vector( nel ) ;
1323 if ( left_right == 0 )
1325 for ( i = 0 ; i < nel ; i++ )
1327 half_buffer -> data[i] = box_buffer -> data[i] ;
1333 for ( i = box_buffer -> n_elements - 1 ;
1334 i >= box_buffer -> n_elements - nel ; i-- )
1336 half_buffer -> data[n_right] = box_buffer -> data[i] ;
1341 xdat = (
float *) cpl_calloc( nel,
sizeof (
float) ) ;
1342 wdat = (
float *) cpl_calloc( nel,
sizeof (
float) ) ;
1343 mpar = (
int *) cpl_calloc( NPAR,
sizeof (
int) ) ;
1348 for ( i = 0 ; i < nel ; i++ )
1352 if ( half_buffer -> data[i] < minval )
1354 minval = half_buffer -> data[i] ;
1356 if ( half_buffer -> data[i] > maxval )
1358 maxval = half_buffer -> data[i] ;
1362 fitpar[0] = minval ;
1363 fitpar[1] = maxval ;
1368 for ( i = 0 ; i < nel ; i++ )
1370 if ( half_buffer -> data[i] >= ( maxval + minval ) / 2. )
1386 n_buf = half_buffer->n_elements + margin ;
1387 in_buffer = sinfo_new_vector( n_buf ) ;
1388 for ( i = 0 ; i < margin ; i++ )
1390 in_buffer -> data[i] = min ;
1393 for ( i = margin ; i < n_buf ; i++ )
1395 in_buffer -> data[i] = half_buffer -> data[shift] ;
1398 sinfo_new_destroy_vector ( half_buffer ) ;
1399 half_buffer = sinfo_new_vector ( n_buf ) ;
1400 for ( i = 0 ; i < n_buf ; i++ )
1402 half_buffer -> data[i] = in_buffer -> data[i] ;
1406 sinfo_new_destroy_vector ( in_buffer ) ;
1412 fitpar[2] = (float)init1 ;
1416 for ( i = 0 ; i < NPAR ; i++ )
1431 half_buffer -> data,
1432 wdat, &ndat, fitpar,
1433 dervpar, mpar, &numpar,
1434 &tol, &its, &lab )) )
1438 " error no.: %d in slitlet: %d", iters, j) ;
1439 fitpar[2] = (float)init1 ;
1443 if ( edge_ind == 1 )
1445 pos -= (float)margin ;
1455 if ( left_right == 0 )
1461 if ( fabs(pos - ((
float)edgeclean[0] - 1. -
1462 (
float)slit_length)) < diff_tol )
1464 slit_pos[0][0] = pos ;
1469 "left position of slitlet 0") ;
1470 if ( (
float) edgeclean[0] - 1. -
1471 (
float)slit_length < 0. )
1473 slit_pos[0][0] = 0. ;
1477 slit_pos[0][0] = (float)edgeclean[0] - 1. -
1478 (
float)slit_length ;
1484 if ( fabs( pos - (
float)margin ) < diff_tol )
1486 slit_pos[j][0] = pos + (float)edgeclean[j-1] -
1492 "left position of slitlet %d", j) ;
1493 slit_pos[j][0] = (float)edgeclean[j-1] - 1. ;
1498 if ( fabs( pos - (
float)margin ) < diff_tol )
1500 slit_pos[k][0] = pos + (float)edgeclean[k-1] -
1506 "left position of slitlet %d", j) ;
1507 slit_pos[k][0] = (float)edgeclean[k-1] - 1. ;
1517 if ( fabs( (
float)box_buffer->n_elements - pos -
1518 (
float)edgeclean[0] ) < diff_tol )
1520 slit_pos[0][1] = (float)(box_buffer->n_elements - 1) -
1526 "right position of slitlet 0") ;
1527 slit_pos[0][1] = (float)edgeclean[0] - 1. ;
1532 if ( fabs( (
float)box_buffer->n_elements - pos
1533 + (
float)edgeclean[j-1] - (
float)margin -
1534 (
float)edgeclean[j] ) < diff_tol )
1536 slit_pos[j][1] = (float)(box_buffer->n_elements - 1) -
1538 + (float)edgeclean[j-1] - (
float)margin ;
1543 "right position of slitlet %d", j) ;
1544 slit_pos[j][1] = (float)edgeclean[j] - 1. ;
1549 if ( edgeclean[k-1] + slit_length > ilx )
1551 last_pos = (float)(ilx - 1) ;
1555 last_pos = (float)(edgeclean[k-1] - 1 + slit_length) ;
1557 if ( fabs( (
float)(box_buffer->n_elements - 1) - pos
1558 + (
float)edgeclean[k-1] - (float)margin -
1559 last_pos ) < diff_tol )
1561 slit_pos[k][1] = (float)(box_buffer->n_elements - 1) -
1563 + (float)edgeclean[k-1] - (
float)margin ;
1568 "right position of slitlet %d", j) ;
1569 slit_pos[k][1] = last_pos ;
1574 sinfo_new_destroy_vector ( half_buffer ) ;
1579 sinfo_new_destroy_vector ( box_buffer ) ;
1583 cpl_free( sinfo_edge ) ;
1584 cpl_free( pos_row ) ;
1585 cpl_free( edgeclean ) ;
1586 cpl_free( dummyedge ) ;
1587 cpl_free( pos_rowclean ) ;
1588 cpl_free( position);
1627 int* position=NULL ;
1628 int * sinfo_edge, * edgeclean ;
1630 int * pos_row, * pos_rowclean ;
1631 Vector * box_buffer ;
1632 Vector * half_buffer ;
1633 Vector * in_buffer ;
1636 int i, j, k, m, ed ;
1638 int nel, n_right, left_right ;
1639 int n_buf, edge_ind, shift ;
1642 int iters, xdim, ndat ;
1645 float * xdat, * wdat ;
1647 float fitpar[NPAR] ;
1648 float dervpar[NPAR] ;
1649 float minval, maxval ;
1657 slit_length = SLITLENGTH ;
1659 if ( NULL == lineImage )
1665 if ( NULL == slit_pos )
1671 if ( box_length < 4 ||
1672 box_length > 2*slit_length )
1678 if ( y_box <= 0. || y_box > 6. )
1684 ilx=cpl_image_get_size_x(lineImage);
1686 pidata=cpl_image_get_data_float(lineImage);
1688 if ( low_pos >= high_pos || low_pos < 0 ||
1689 high_pos <= 0 || high_pos >= ilx )
1696 sinfo_edge = (
int*) cpl_calloc( ilx/2,
sizeof(
int) ) ;
1697 dummyedge = (
int*) cpl_calloc( ilx/2,
sizeof(
int) ) ;
1698 edgeclean = (
int*) cpl_calloc( ilx/2,
sizeof(
int) ) ;
1699 pos_row = (
int*) cpl_calloc( ilx/2,
sizeof(
int) ) ;
1700 pos_rowclean = (
int*) cpl_calloc( ilx/2,
sizeof(
int) ) ;
1703 position=cpl_calloc(ilx,
sizeof(
int)); ;
1705 for ( col = 0 ; col < ilx ; col++ )
1709 for ( row = low_pos ; row <= high_pos ; row++ )
1711 if ( maxval < pidata[col+row*ilx] )
1713 maxval = pidata[col+row*ilx] ;
1717 if ( maxval > -FLT_MAX && found_row > low_pos )
1719 position[col] = found_row ;
1729 for ( col = 0 ; col < (ilx) - 1 ; col++ )
1731 if ( position[col] > 0 && position[col+1] > 0 &&
1732 abs(position[col+1] - position[col]) > 10 )
1734 sinfo_edge[ed] = col ;
1735 pos_row[ed] = position[col] ;
1743 cpl_free( sinfo_edge ) ;
1744 cpl_free( pos_row ) ;
1745 cpl_free( edgeclean ) ;
1746 cpl_free( dummyedge ) ;
1747 cpl_free( pos_rowclean ) ;
1752 for ( i = 1 ; i <= ed ; i ++ )
1756 if ( (sinfo_edge[i-1] - sinfo_edge[i-2]) <
1757 slit_length - SLIT_LEN_ERR ||
1758 (sinfo_edge[i-1] - sinfo_edge[i-2]) >
1759 slit_length + SLIT_LEN_ERR )
1761 dummyedge[i-1] = -1 ;
1764 if (dummyedge[i-1] != -1)
1766 dummyedge[i-1] = sinfo_edge[i-1] ;
1774 if ( (sinfo_edge[i] - sinfo_edge[i-1]) <
1775 slit_length - SLIT_LEN_ERR ||
1776 (sinfo_edge[i] - sinfo_edge[i-1]) >
1777 slit_length + SLIT_LEN_ERR )
1782 if ( i+1 < ed && dummyedge[i] != -1 )
1784 if ( (sinfo_edge[i+1] - sinfo_edge[i]) <
1785 slit_length - SLIT_LEN_ERR ||
1786 (sinfo_edge[i+1] - sinfo_edge[i]) >
1787 slit_length + SLIT_LEN_ERR )
1789 dummyedge[i+1] = -1 ;
1795 for ( i = 0 ; i < ed ; i++ )
1797 if ( dummyedge[i] != -1 && dummyedge[i] != 0 )
1799 edgeclean[k] = dummyedge[i] ;
1800 pos_rowclean[k] = pos_row[i] ;
1802 if( edgeclean[k-1] > (ilx - slit_length - 2*SLIT_LEN_ERR ) )
1804 pos_rowclean[k] = pos_row[ed] ;
1810 margin = box_length / 2 ;
1817 for ( j = 0 ; j <= k ; j++ )
1822 box_buffer = sinfo_new_vector( edgeclean[0] + margin ) ;
1823 for( col = 0 ; col < edgeclean[0] + margin ; col++ )
1826 for ( row = pos_rowclean[0] - sinfo_new_nint(y_box) ;
1827 row <= pos_rowclean[0] + sinfo_new_nint(y_box) ; row++ )
1829 if ( maxval < pidata[col + ilx*row] )
1831 maxval = pidata[col + ilx*row] ;
1834 box_buffer->data[m] = maxval ;
1840 box_buffer = sinfo_new_vector( edgeclean[j] -
1841 edgeclean[j-1] + 2*margin ) ;
1842 for ( col = edgeclean[j - 1] - margin ;
1843 col < edgeclean[j] + margin ; col++ )
1846 for ( row = pos_rowclean[j] - sinfo_new_nint(y_box) ;
1847 row <= pos_rowclean[j] + sinfo_new_nint(y_box) ; row++ )
1849 if ( maxval < pidata[col + ilx*row] )
1851 maxval = pidata[col + ilx*row] ;
1854 box_buffer->data[m] = maxval ;
1860 box_buffer = sinfo_new_vector( ilx - edgeclean[k-1] + margin ) ;
1861 for ( col = edgeclean[k - 1] - margin ; col < ilx ; col++ )
1869 for ( row = pos_rowclean[k] - sinfo_new_nint(y_box) ;
1870 row <= pos_rowclean[k] + sinfo_new_nint(y_box) ; row++ )
1876 if ( maxval < pidata[col + row * ilx] )
1878 maxval = pidata[col + row * ilx] ;
1881 box_buffer->data[m] = maxval ;
1889 for ( i = 0 ; i < box_buffer->n_elements ; i++ )
1891 if ( box_buffer -> data[i] < min )
1893 min = box_buffer -> data[i] ;
1897 for ( left_right = 0 ; left_right <= 1 ; left_right++ )
1900 if ( left_right == 0 )
1902 nel = box_buffer -> n_elements / 2 ;
1906 if ( box_buffer -> n_elements % 2 == 0 )
1908 nel = box_buffer -> n_elements / 2 ;
1912 nel = box_buffer -> n_elements / 2 + 1 ;
1918 half_buffer = sinfo_new_vector( nel ) ;
1919 if ( left_right == 0 )
1921 for ( i = 0 ; i < nel ; i++ )
1923 half_buffer -> data[i] = box_buffer -> data[i] ;
1929 for ( i = box_buffer -> n_elements - 1 ;
1930 i >= box_buffer -> n_elements - nel ; i-- )
1932 half_buffer -> data[n_right] = box_buffer -> data[i] ;
1937 xdat = (
float *) cpl_calloc( nel,
sizeof (
float) ) ;
1938 wdat = (
float *) cpl_calloc( nel,
sizeof (
float) ) ;
1939 mpar = (
int *) cpl_calloc( NPAR,
sizeof (
int) ) ;
1944 for ( i = 0 ; i < nel ; i++ )
1948 if ( half_buffer -> data[i] < minval )
1950 minval = half_buffer -> data[i] ;
1952 if ( half_buffer -> data[i] > maxval )
1954 maxval = half_buffer -> data[i] ;
1957 fitpar[0] = minval ;
1958 fitpar[1] = maxval ;
1963 for ( i = 0 ; i < nel ; i++ )
1965 if ( half_buffer -> data[i] >= ( maxval + minval ) / 2. )
1981 n_buf = half_buffer->n_elements + margin ;
1982 in_buffer = sinfo_new_vector( n_buf ) ;
1983 for ( i = 0 ; i < margin ; i++ )
1985 in_buffer -> data[i] = min ;
1988 for ( i = margin ; i < n_buf ; i++ )
1990 in_buffer -> data[i] = half_buffer -> data[shift] ;
1993 sinfo_new_destroy_vector ( half_buffer ) ;
1994 half_buffer = sinfo_new_vector ( n_buf ) ;
1995 for ( i = 0 ; i < n_buf ; i++ )
1997 half_buffer -> data[i] = in_buffer -> data[i] ;
2001 sinfo_new_destroy_vector ( in_buffer ) ;
2007 fitpar[2] = (float)init1 ;
2011 for ( i = 0 ; i < NPAR ; i++ )
2026 half_buffer -> data,
2027 wdat, &ndat, fitpar,
2028 dervpar, mpar, &numpar,
2029 &tol, &its, &lab )) )
2032 "no.: %d in slitlet: %d", iters, j) ;
2035 if ( fitpar[3] <=0. )
2038 " of boltzmann function in slitlet: %d", j) ;
2043 if ( edge_ind == 1 )
2045 pos -= (float)margin ;
2055 if ( left_right == 0 )
2061 slit_pos[0][0] = pos ;
2062 if ( slit_pos[0][0] - (
int) slit_pos[0][0] == 0.)
2064 slit_pos[0][0] = 0. ;
2069 slit_pos[j][0] = pos + (float)edgeclean[j-1] -
2071 if ( slit_pos[j][0] - (
int) slit_pos[j][0] == 0.)
2073 slit_pos[j][0] = 0. ;
2078 slit_pos[k][0] = pos + (float)edgeclean[k-1] -
2080 if ( slit_pos[k][0] - (
int) slit_pos[k][0] == 0.)
2082 slit_pos[k][0] = 0. ;
2092 slit_pos[0][1] = (float)(box_buffer->n_elements - 1) - pos;
2093 if ( slit_pos[0][1] - (
int) slit_pos[0][1] == 0.)
2095 slit_pos[0][1] = 0. ;
2100 slit_pos[j][1] = (float)(box_buffer->n_elements - 1) - pos
2101 + (float)edgeclean[j-1] - (
float)margin ;
2102 if ( slit_pos[j][1] - (
int) slit_pos[j][1] == 0.)
2104 slit_pos[j][1] = 0. ;
2110 slit_pos[k][1] = (float)(box_buffer->n_elements - 1) - pos
2111 + (float)edgeclean[k-1] - (
float)margin ;
2112 if ( slit_pos[k][1] - (
int) slit_pos[k][1] == 0.)
2114 slit_pos[k][1] = 0. ;
2119 sinfo_new_destroy_vector ( half_buffer ) ;
2124 sinfo_new_destroy_vector ( box_buffer ) ;
2127 cpl_free( sinfo_edge ) ;
2128 cpl_free( pos_row ) ;
2129 cpl_free( edgeclean ) ;
2130 cpl_free( dummyedge ) ;
2131 cpl_free( pos_rowclean ) ;
2132 cpl_free( position );
2173 int* position=NULL ;
2174 Vector * box_buffer ;
2175 Vector * in_buffer ;
2178 int col_first, col_last ;
2179 int row_first, row_last ;
2185 int iters, xdim, ndat ;
2188 float * xdat, * wdat ;
2190 float fitpar[NPAR] ;
2191 float dervpar[NPAR] ;
2192 float minval, maxval ;
2195 int slitposition[SLITLENGTH] ;
2196 pixelvalue rowpos[SLITLENGTH] ;
2202 slit_length = SLITLENGTH ;
2203 slit_length = N_SLITLETS ;
2205 if ( NULL == lineImage )
2211 if ( NULL == slit_pos )
2217 if ( box_length < 4 ||
2218 box_length > 2*slit_length )
2224 if ( y_box <= 0. || y_box > 6. )
2229 if ( diff_tol <= 0. )
2235 ilx=cpl_image_get_size_x(lineImage);
2236 ily=cpl_image_get_size_y(lineImage);
2237 pidata=cpl_image_get_data_float(lineImage);
2239 if ( low_pos >= high_pos || low_pos < 0 ||
2240 high_pos <= 0 || high_pos > ily )
2247 position=cpl_calloc(ilx,
sizeof(
int)) ;
2248 for ( col = 0 ; col < ilx ; col++ )
2252 for ( row = low_pos ; row <= high_pos ; row++ )
2254 if ( maxval < pidata[col+row*ilx] )
2256 maxval = pidata[col+row*ilx] ;
2260 if ( maxval > -FLT_MAX && found_row > low_pos )
2262 position[col] = found_row ;
2275 for ( j = 0 ; j < slit_length ; j++ )
2282 for ( col = sinfo_new_nint(slit_pos[j][0])+ 1 ;
2283 col < sinfo_new_nint(slit_pos[j][1]) -1 ; col++ )
2285 rowpos[n] = (pixelvalue)position[col] ;
2289 slitposition[j] = (int)sinfo_new_median(rowpos, n) ;
2290 for ( left_right = 0 ; left_right <= 1 ; left_right++ )
2293 col_first = sinfo_new_nint( slit_pos[j][left_right] ) -
2295 col_last = sinfo_new_nint( slit_pos[j][left_right] ) +
2297 if ( col_first < 0 )
2302 if ( col_last > ilx )
2307 if ( col_last - col_first <= 0 )
2312 box_buffer = sinfo_new_vector( col_last - col_first ) ;
2316 if ( left_right == 0 )
2318 for( col = col_first ; col < col_last ; col++ )
2320 row_first = slitposition[j] - sinfo_new_nint(y_box) ;
2321 row_last = slitposition[j] + sinfo_new_nint(y_box) ;
2322 if ( row_first < 0 )
2326 if ( row_last >= ily )
2328 row_last = ily - 1 ;
2331 for ( row = row_first ; row <= row_last ; row++ )
2333 if ( maxval < pidata[col + ilx*row] )
2335 maxval = pidata[col + ilx*row] ;
2338 box_buffer->data[m] = maxval ;
2346 for( col = col_last-1 ; col >= col_first ; col-- )
2348 row_first = slitposition[j] - sinfo_new_nint(y_box) ;
2349 row_last = slitposition[j] + sinfo_new_nint(y_box) ;
2350 if ( row_first < 0 )
2354 if ( row_last >= ily )
2356 row_last = ily - 1 ;
2359 for ( row = row_first ; row <= row_last ; row++ )
2361 if ( maxval < pidata[col + ilx*row] )
2363 maxval = pidata[col + ilx*row] ;
2366 box_buffer->data[m] = maxval ;
2372 xdat=(
float *) cpl_calloc(box_buffer->n_elements, sizeof (
float) );
2373 wdat=(
float *) cpl_calloc(box_buffer->n_elements, sizeof (
float) );
2374 mpar=(
int *) cpl_calloc(NPAR,
sizeof (
int) ) ;
2380 for ( i = 0 ; i < box_buffer->n_elements ; i++ )
2384 if ( box_buffer -> data[i] < minval )
2386 minval = box_buffer -> data[i] ;
2388 if ( box_buffer -> data[i] > maxval )
2390 maxval = box_buffer -> data[i] ;
2393 fitpar[0] = minval ;
2394 fitpar[1] = maxval ;
2405 n_buf = box_buffer->n_elements + box_length/2 ;
2406 in_buffer = sinfo_new_vector( n_buf ) ;
2407 for ( i = 0 ; i < box_length/2 ; i++ )
2409 in_buffer -> data[i] = minval ;
2412 for ( i = box_length/2 ; i < n_buf ; i++ )
2414 in_buffer -> data[i] = box_buffer -> data[shift] ;
2417 sinfo_new_destroy_vector ( box_buffer ) ;
2418 box_buffer = sinfo_new_vector ( n_buf ) ;
2419 for ( i = 0 ; i < n_buf ; i++ )
2421 box_buffer -> data[i] = in_buffer -> data[i] ;
2423 sinfo_new_destroy_vector ( in_buffer ) ;
2427 fitpar[2] = (float)box_buffer->n_elements/2. ;
2430 for ( i = 0 ; i < NPAR ; i++ )
2437 ndat = box_buffer->n_elements ;
2446 wdat, &ndat, fitpar,
2447 dervpar, mpar, &numpar,
2448 &tol, &its, &lab )) )
2451 "no.: %d in slitlet: %d\n", iters, j) ;
2452 sinfo_new_destroy_vector(box_buffer) ;
2459 if ( fitpar[3] <=0. )
2462 "boltzmann function in slitlet: %d\n", j) ;
2463 sinfo_new_destroy_vector(box_buffer) ;
2472 pos -= (float)box_length/2. ;
2482 if ( left_right == 0 )
2484 new_pos = (float)col_first + pos ;
2488 new_pos = (float)col_last-1 - pos ;
2490 if ( fabs(new_pos - slit_pos[j][left_right]) < diff_tol )
2492 slit_pos[j][left_right] = new_pos ;
2497 " take the estimated slitlet position "
2498 " in slitlet: %d\n", j) ;
2505 sinfo_new_destroy_vector ( box_buffer ) ;