202 #include "sinfo_vltPort.h"
212 #include "sinfo_image_ops.h"
213 #include "sinfo_error.h"
214 #include "sinfo_resampling.h"
215 #include "sinfo_local_types.h"
216 #include "sinfo_utils_wrappers.h"
226 sinfo_gen_lowpass(
const int xs,
228 const double sigma_x,
229 const double sigma_y);
232 static void quicksort_int(
int* data,
int left,
int right);
253 sinfo_image_line_corr(
const int width,
260 cpl_image* mask=NULL;
262 cpl_image* ima_backpix=NULL;
263 cpl_image* ima_backpos=NULL;
264 cpl_image* ima_ybackpix=NULL;
265 cpl_image* ima_diffbackpix=NULL;
266 cpl_image* ima_filt=NULL;
267 cpl_image* ima = NULL;
269 cpl_matrix* filter=NULL;
271 cpl_mask* bpm_bad=NULL;
287 cpl_binary* pbin=NULL;
298 check_nomsg(sx=cpl_image_get_size_x(ima_in));
299 check_nomsg(sy=cpl_image_get_size_y(ima_in));
300 check_nomsg(*ima_out=cpl_image_duplicate(ima_in));
302 check_nomsg(mask=cpl_image_new(sx,sy,CPL_TYPE_FLOAT));
303 check_nomsg(pmsk=cpl_image_get_data_float(mask));
305 for(i=0;i<width;i++) {
306 for(j=width;j<sy-width;j++) {
311 for(i=sx-width;i<sx;i++) {
312 for(j=width;j<sy-width;j++) {
316 sinfo_free_image(&mask);
319 nrow=2*width*(sy-2*width);
320 check_nomsg(ima_backpix=cpl_image_new(nrow,1,CPL_TYPE_FLOAT));
321 check_nomsg(ima_backpos=cpl_image_new(nrow,1,CPL_TYPE_INT));
323 check_nomsg(pima=cpl_image_get_data_float(ima_in));
324 check_nomsg(ppix=cpl_image_get_data_float(ima_backpix));
325 check_nomsg(ppos=cpl_image_get_data_int(ima_backpos));
328 for(i=0;i<width;i++) {
329 for(j=width;j<sy-width;j++) {
330 ppix[k]=pima[j*sx+i];
336 for(i=sx-width;i<sx;i++) {
337 for(j=width;j<sy-width;j++) {
338 ppix[k]=pima[j*sx+i];
344 check_nomsg(ima_ybackpix=cpl_image_duplicate(ima_backpos));
345 sinfo_free_image(&ima_backpos);
347 check_nomsg(pbackpix=cpl_image_get_data_int(ima_ybackpix));
349 check_nomsg(cpl_image_divide_scalar(ima_ybackpix,sx));
350 check_nomsg(pbackpix=cpl_image_get_data_int(ima_ybackpix));
353 check_nomsg(med_back=cpl_image_get_median(ima_backpix));
354 check_nomsg(ima_diffbackpix=cpl_image_duplicate(ima_backpix));
356 check_nomsg(cpl_image_subtract_scalar(ima_diffbackpix,med_back));
360 check_nomsg(filter=cpl_matrix_new(1,filt_rad));
361 check_nomsg(cpl_matrix_fill(filter,1.));
362 check_nomsg(ima_filt=sinfo_image_filter_median(ima_diffbackpix,filter));
363 sinfoni_free_matrix(&filter);
368 check_nomsg(sigma_back=cpl_image_get_stdev(ima_filt));
369 sinfo_free_image(&ima_filt);
371 check_nomsg(ima=cpl_image_duplicate(ima_diffbackpix));
372 sinfo_free_image(&ima_diffbackpix);
374 check_nomsg(cpl_image_abs(ima));
378 check_nomsg(bpm_bad=cpl_mask_threshold_image_create(ima,kappa*sigma_back,
384 check_nomsg(cpl_image_reject_from_mask(ima_backpix,bpm_bad));
385 check_nomsg(medvalue=cpl_image_get_median(ima_backpix));
387 check_nomsg(nbad=cpl_mask_count(bpm_bad));
389 check_nomsg(cpl_image_reject_from_mask(ima_backpix,bpm_bad));
390 sinfo_free_image(&ima_backpix);
394 check_nomsg(pbin=cpl_mask_get_data(bpm_bad));
395 check_nomsg(pbackpix=cpl_image_get_data_int(ima_ybackpix));
396 cpl_msg_debug(cpl_func,
"%d lines detected", nbad);
400 ybad = cpl_calloc(nbad,
sizeof(
int));
403 for(i=0;i<nrow;i++) {
404 if(pbin[i] == CPL_BINARY_1) {
405 ybad[k]=pbackpix[i] + 1;
409 sinfo_free_mask(&bpm_bad);
410 sinfo_free_image(&ima_ybackpix);
412 quicksort_int(&(ybad[0]), 0, nbad-1);
414 for(k=0;k<nbad;k++) {
422 check_nomsg(tot=cpl_image_get_flux_window(ima_in,1,yval,width,yval));
423 check_nomsg(tot+=cpl_image_get_flux_window(ima_in,sx-width+1,
425 mean=tot/(2. * width);
426 check_nomsg(pima=cpl_image_get_data_float(*ima_out));
427 for(i=width;i<sx-width;i++) {
428 pima[i+(yval-1)*sx]+=(
float)(mean-medvalue);
438 sinfo_free_image(&mask);
439 sinfo_free_image(&ima_backpos);
440 sinfoni_free_matrix(&filter);
441 sinfo_free_image(&ima_filt);
442 sinfo_free_image(&ima_diffbackpix);
444 sinfo_free_image(&ima_backpix);
445 sinfo_free_mask(&bpm_bad);
446 sinfo_free_image(&ima_ybackpix);
447 cpl_image_delete(ima);
449 return cpl_error_get_code();
462 double sinfo_new_my_median_image(cpl_image* im)
474 ilx=cpl_image_get_size_x(im);
475 ily=cpl_image_get_size_y(im);
476 pidata=cpl_image_get_data_float(im);
478 for ( i = 0 ; i < (int) ilx*ily ; i++ )
480 if ( isnan(pidata[i]) )
487 pv = cpl_calloc(n,
sizeof(pixelvalue));
489 for ( i = 0 ; i < (int) ilx*ily ; i++ )
491 if ( isnan(pidata[i]) )
499 if(pv == NULL || n == 0) {
502 m=sinfo_new_median(pv,n);
519 Vector * sinfo_new_mean_of_columns( cpl_image *im )
533 ilx=cpl_image_get_size_x(im);
534 ily=cpl_image_get_size_y(im);
535 pidata=cpl_image_get_data_float(im);
538 if ( NULL == (row = sinfo_new_vector (ilx)) )
544 for ( i = 0 ; i < ilx ; i++ )
546 for ( j = 0 ; j < ily ; j++ )
548 if (!isnan(pidata[i+j*ilx]))
550 row->data[i] += pidata[i + j*(ilx)] ;
554 row->data[i] /= ily ;
569 cpl_image * sinfo_new_clean_mean_of_columns( cpl_image *im,
573 cpl_image * row=NULL ;
574 pixelvalue* buffer=NULL ;
591 ilx=cpl_image_get_size_x(im);
592 ily=cpl_image_get_size_y(im);
593 pidata=cpl_image_get_data_float(im);
595 if ((lo_reject + hi_reject) > 0.9)
598 lo_reject, hi_reject) ;
600 "0.90 aborting average") ;
604 lo_n = (int) (ily * lo_reject + 0.5) ;
605 hi_n = (int) (ily * hi_reject + 0.5) ;
606 if (lo_n + hi_n >= ily)
613 if ( NULL == (row = cpl_image_new (ilx, 1,CPL_TYPE_FLOAT)) )
618 podata=cpl_image_get_data_float(row);
620 buffer=(pixelvalue*) cpl_calloc(ily,
sizeof(pixelvalue)) ;
622 for ( i = 0 ; i < ilx ; i++ )
624 for ( j = 0 ; j < ily ; j++ )
626 buffer[j] = pidata[i + j*(ilx)] ;
628 sinfo_pixel_qsort (buffer, ily) ;
631 for (k = lo_n ; k < ily - hi_n ; k ++)
633 if ( !isnan(buffer[k]) )
635 podata[i] += buffer[k] ;
656 cpl_image * sinfo_new_div_image_by_row( cpl_image *im, Vector *row )
658 cpl_image *image=NULL ;
666 if ( im == NULL || row == NULL )
671 ilx=cpl_image_get_size_x(im);
672 ily=cpl_image_get_size_y(im);
673 pidata=cpl_image_get_data_float(im);
675 if ( ilx != row -> n_elements )
681 if ( NULL == (image = cpl_image_duplicate (im)) )
686 podata=cpl_image_get_data_float(image);
688 for (i = 0 ; i < ilx ; i++ )
690 for (j = 0 ; j < ily ; j++)
692 if ( !isnan(pidata[i + j*(ilx)]) )
694 podata[i + j*(ilx)] = pidata[i + j*(ilx)] / row -> data[i] ;
711 cpl_image * sinfo_new_mult_row_to_image( cpl_image *im, Vector *row )
713 cpl_image *image=NULL;
724 if ( im == NULL || row == NULL )
729 ilx=cpl_image_get_size_x(im);
730 ily=cpl_image_get_size_y(im);
731 pidata=cpl_image_get_data_float(im);
733 if ( ilx != row -> n_elements )
739 if ( NULL == (image = cpl_image_duplicate (im)) )
744 podata=cpl_image_get_data_float(image);
746 for (i = 0 ; i < ilx ; i++ )
748 for (j = 0 ; j < ily ; j++)
750 if ( !isnan(pidata[i + j*(ilx)]) )
752 podata[i + j*(ilx)] = pidata[i + j*(ilx)] * row -> data[i] ;
787 cpl_image * sinfo_new_col_tilt ( cpl_image * image,
float sigmaFactor )
790 float * column=NULL ;
794 float sinfo_median=0;
811 float* p_in_data=NULL;
812 float* p_ou_data=NULL;
821 if ( sigmaFactor <= 0. )
826 lx = cpl_image_get_size_x(image);
827 ly = cpl_image_get_size_y(image);
831 if ( NULL == (im = cpl_image_new (lx,ly,CPL_TYPE_FLOAT )) )
838 p_in_data = cpl_image_get_data_float(image);
839 p_ou_data = cpl_image_get_data_float(im);
840 for ( i = 0 ; i < lx ; i ++ )
844 column = (
float *) cpl_calloc ( ly ,
sizeof (
float *) ) ;
845 sig = (
float *) cpl_calloc ( ly ,
sizeof (
float *) ) ;
846 dat = (
float *) cpl_calloc ( ly ,
sizeof (
float *) ) ;
849 for ( j = 0 ; j < ly ; j++ )
851 if ( !isnan(p_in_data[i + j*lx]) )
853 column[j] = p_in_data[i + j*lx] ;
861 for ( j = 0 ; j < ly ; j++ )
863 p_ou_data[i + j*lx] = ZERO;
879 sinfo_pixel_qsort (column, colnum) ;
885 for ( j = 0.1*colnum + 1 ; j <= 0.9*colnum ; j++ )
888 sum2 += column[j] * column[j] ;
894 noise = sigmaFactor * 1000.;
898 mean = sum/(float)npix ;
899 noise = sqrt( (sum2 - sum*mean)/(
double)(npix -1) ) ;
900 noise *= sigmaFactor ;
909 if ( colnum % 2 == 1 )
911 sinfo_median = column[colnum/2] ;
915 sinfo_median = (column[colnum/2 - 1] + column[colnum/2])/2. ;
921 for ( j = 0; j < ly ; j ++ )
923 if ( !isnan(p_in_data[i+j*lx]) &&
924 fabs ( (p_in_data[i+j*lx]) - sinfo_median) <= noise )
926 column[colnum] = p_in_data[i+j*lx] ;
927 dat[colnum] = (float) j ;
949 sinfo_my_fit ( dat, column, colnum, sig, mwt, &a,
950 &b, &siga, &sigb, &chi2, &q ) ;
952 if ( fabs(b) >= SLOPE || fabs(a) >= SATURATION ||
953 isnan(b) || isnan(a))
956 " saturation level is reached: %f in column"
957 " number %d ", b, a , i+1) ;
961 for ( j = 0; j < ly; j++ )
963 if ( !isnan(p_in_data[i+j*lx]) &&
964 fabs(b) < SLOPE && fabs(a) < SATURATION )
966 p_ou_data[i+j*lx] = p_in_data[i+j*lx] - (a + b * (float)j) ;
968 else if ( isnan(p_in_data[i+j*lx]) )
970 p_ou_data[i+j*lx] = ZERO ;
972 else if ( (fabs(b) >= SLOPE ||
973 fabs(a) >= SATURATION || isnan(a) || isnan(b)) &&
974 !isnan(p_in_data[i+j*lx]) )
976 p_ou_data[i+j*lx] -= sinfo_median ;
1023 cpl_image * sinfo_new_median_image( cpl_image * im,
float fmedian )
1025 cpl_image * image=NULL ;
1026 pixelvalue * value=NULL ;
1027 pixelvalue sinfo_median=0 ;
1028 int * position=NULL ;
1035 float* p_in_data=NULL;
1036 float* p_ou_data=NULL;
1044 image = cpl_image_duplicate ( im ) ;
1045 lx=cpl_image_get_size_x(im);
1046 ly=cpl_image_get_size_y(im);
1048 p_in_data=cpl_image_get_data_float(im);
1049 p_ou_data=cpl_image_get_data_float(image);
1055 for ( i = 0 ; i < im_size ; i++ )
1058 if ( isnan(p_in_data[i]) )
1064 value = (pixelvalue * )cpl_calloc ( 8,
sizeof ( pixelvalue * ) ) ;
1065 position = (
int * ) cpl_calloc ( 8,
sizeof (
int * ) ) ;
1071 position[0] = i + lx - 1 ;
1072 position[1] = i + lx ;
1073 position[2] = i + lx + 1 ;
1074 position[3] = i + 1 ;
1075 position[4] = i - lx + 1 ;
1076 position[5] = i - lx ;
1077 position[6] = i - lx - 1 ;
1078 position[7] = i - 1 ;
1086 if ( i >= 0 && i < lx )
1088 position[4] += 2 * lx ;
1089 position[5] += 2 * lx ;
1090 position[6] += 2 * lx ;
1092 else if ( i >= ((
int) lx*ly - lx ) && i < (
int) lx*ly )
1094 position[0] -= 2 * lx ;
1095 position[1] -= 2 * lx ;
1096 position[2] -= 2 * lx ;
1098 else if ( i % lx == 0 )
1104 else if ( i % lx == lx - 1 )
1118 for ( j = 0 ; j < nposition ; j ++ )
1120 if((position[j] >-1 ) && (position[j]<im_size)) {
1121 if ( !isnan(p_in_data[position[j]]) )
1123 value[n] = p_in_data[position[j]] ;
1130 if ( nposition <= 1 )
1132 p_ou_data[i] = ZERO ;
1134 cpl_free(position) ;
1140 sinfo_pixel_qsort ( value, nposition ) ;
1141 if ( nposition % 2 == 1 )
1143 sinfo_median = value [ nposition/2 ] ;
1147 sinfo_median = ( value [nposition/2 - 1] +
1148 value [nposition/2] ) / 2. ;
1167 p_ou_data[i] = sinfo_median ;
1169 else if ( fmedian < 0 &&
1170 fabs ( sinfo_median - p_in_data[i] ) >= -fmedian )
1172 p_ou_data[i] = sinfo_median ;
1174 else if ( fmedian > 0 &&
1175 fabs ( sinfo_median - p_in_data[i] ) >= fmedian *
1176 sqrt(fabs(sinfo_median)) )
1178 p_ou_data[i] = sinfo_median ;
1183 cpl_free (position) ;
1188 cpl_free (position) ;
1207 sinfo_new_compare_images(cpl_image * im1,cpl_image * im2,cpl_image * origim )
1209 cpl_image * image=NULL ;
1215 float* p_in1_data=NULL;
1216 float* p_in2_data=NULL;
1217 float* p_ou_data=NULL;
1218 float* p_org_data=NULL;
1221 if ( im1 == NULL || im2 == NULL || origim == NULL )
1226 lx1=cpl_image_get_size_x(im1);
1227 ly1=cpl_image_get_size_y(im1);
1229 lx2=cpl_image_get_size_x(im2);
1230 ly2=cpl_image_get_size_y(im2);
1232 p_in1_data=cpl_image_get_data_float(im1);
1233 p_in2_data=cpl_image_get_data_float(im2);
1234 p_org_data=cpl_image_get_data_float(origim);
1235 if ( lx1 != lx2 || ly1 != ly2 )
1242 if ( NULL == (image = cpl_image_new ( lx1, ly1, CPL_TYPE_FLOAT )) )
1247 p_ou_data=cpl_image_get_data_float(image);
1248 for ( i = 0 ; i < (int) lx1*ly1 ; i ++ )
1250 if ( isnan(p_in1_data[i]) && isnan(p_in2_data[i]) )
1252 p_ou_data[i] = ZERO ;
1256 if ( p_in1_data[i] == p_in2_data[i] )
1258 p_ou_data[i] = p_org_data[i] ;
1262 p_ou_data[i] = ZERO ;
1283 sinfo_new_promote_image_to_mask (cpl_image * im,
int * n_badpixels )
1285 cpl_image * reImage=NULL ;
1289 float* p_in_data=NULL;
1290 float* p_ou_data=NULL;
1297 lx=cpl_image_get_size_x(im);
1298 ly=cpl_image_get_size_y(im);
1299 p_in_data=cpl_image_get_data_float(im);
1302 if ( NULL == (reImage = cpl_image_new (lx,ly,CPL_TYPE_FLOAT )) )
1307 p_ou_data=cpl_image_get_data_float(reImage);
1310 for ( i = 0 ; i < (int) lx*ly ; i ++ )
1312 if ( isnan(p_in_data[i]) )
1336 cpl_image * sinfo_new_mult_image_by_mask (cpl_image * im,cpl_image * mask )
1338 cpl_image * reImage=NULL ;
1359 ix=cpl_image_get_size_x(im);
1360 iy=cpl_image_get_size_y(im);
1361 mx=cpl_image_get_size_x(mask);
1362 my=cpl_image_get_size_y(mask);
1364 if ( ix != mx || iy != my)
1370 reImage = cpl_image_duplicate( im ) ;
1371 podata=cpl_image_get_data_float(reImage);
1372 pmdata=cpl_image_get_data_float(mask);
1374 for ( i = 0 ; i < (int) ix*iy ; i ++ )
1376 if ( pmdata[i] == 0. )
1397 sinfo_new_thresh_image (cpl_image * im,
float lo_cut,
float hi_cut )
1399 cpl_image * image=NULL ;
1400 float* p_inp_data=NULL;
1401 float* p_out_data=NULL;
1412 lx=cpl_image_get_size_x(im);
1413 ly=cpl_image_get_size_y(im);
1415 image = cpl_image_duplicate(im) ;
1416 p_inp_data=cpl_image_get_data(im);
1417 p_out_data=cpl_image_get_data(image);
1418 for ( i = 0 ; i < (int) lx*ly ; i ++ )
1420 if ( p_inp_data[i] > (pixelvalue) hi_cut ||
1421 p_inp_data[i] < (pixelvalue) lo_cut )
1423 p_out_data[i] = ZERO ;
1456 cpl_image * sinfo_new_interpol_image ( cpl_image * im,
1461 cpl_image * returnImage=NULL ;
1462 float* neighbors=NULL ;
1486 ilx=cpl_image_get_size_x(im);
1487 ily=cpl_image_get_size_y(im);
1488 pidata=cpl_image_get_data_float(im);
1496 mlx=cpl_image_get_size_x(mask);
1497 mly=cpl_image_get_size_y(mask);
1498 pmdata=cpl_image_get_data_float(mask);
1500 if ( mlx != ilx || mly != ily )
1506 if ( max_radius <= 0 )
1509 "search radius given!") ;
1513 if ( n_pixels <= 2 )
1516 "for interpolation given!") ;
1520 returnImage = cpl_image_duplicate ( im ) ;
1521 podata=cpl_image_get_data_float(returnImage);
1524 neighbors=cpl_calloc(4*max_radius*max_radius,
sizeof(
float)) ;
1526 for ( col = 0 ; col < ilx ; col++ )
1528 for ( row = 0 ; row < ily ; row++ )
1531 if ( isnan(pmdata[col+row*ilx]) || pmdata[col+row*ilx] == 0. )
1536 for ( j = 1 ; j <= max_radius ; j++ )
1540 for ( k = -j ; k < j ; k++ )
1542 if ( col-j >= 0 && row+k < ily && row+k >= 0 )
1544 if ( !isnan(pmdata[col-j+(row+k)*mlx]) ||
1545 pmdata[col-j+(row+k)*mlx] != 0 )
1547 neighbors[n_valid]=pidata[col-j+(row+k)*ilx] ;
1554 for ( k = -j ; k < j ; k++ )
1556 if ( col+k < ilx && col+k >= 0 && row+j < ily )
1558 if ( !isnan(pmdata[col+k+(row+j)*mlx]) ||
1559 pmdata[col+k+(row+j)*mlx] != 0. )
1561 neighbors[n_valid]=pidata[col+k+(row+j)*ilx] ;
1568 for ( k = -j ; k < j ; k++ )
1570 if ( col+j < ilx && row-k >= 0 && row-k < ily )
1572 if ( !isnan(pmdata[col+j+(row-k)*mlx]) ||
1573 pmdata[col+j+(row-k)*mlx] != 0. )
1575 neighbors[n_valid]=pidata[col+j+(row-k)*ilx] ;
1582 for ( k = -j ; k < j ; k++ )
1584 if ( col-k >= 0 && col-k < ilx && row-j < ily )
1586 if ( !isnan(pmdata[col-k+(row-j)*mlx]) ||
1587 pmdata[col-k+(row-j)*mlx] != 0. )
1589 neighbors[n_valid]=pidata[col-k+(row-j)*ilx] ;
1596 if ( n_valid >= n_pixels )
1602 if ( j == 1 && n_valid >= 2 )
1608 if ( n_valid < n_pixels && agreed == 0 )
1611 "interpolate bad pixel in col: "
1612 "%d, row: %d", col, row ) ;
1626 for ( i = 0 ; i < n_valid ; i++ )
1628 sum += neighbors[i] ;
1630 mean = sum / n_valid ;
1632 podata[col+row*ilx] = mean ;
1636 podata[col+row*ilx]=sinfo_new_median(neighbors,n_valid);
1642 cpl_free(neighbors);
1643 return returnImage ;
1669 cpl_image * sinfo_interpol_source_image ( cpl_image * im,
1672 float ** slit_edges )
1674 cpl_image * returnImage=NULL ;
1675 float validpixel[6] ;
1699 ilx=cpl_image_get_size_x(im);
1700 ily=cpl_image_get_size_y(im);
1701 pidata=cpl_image_get_data_float(im);
1708 mlx=cpl_image_get_size_x(mask);
1709 mly=cpl_image_get_size_y(mask);
1710 pmdata=cpl_image_get_data_float(mask);
1712 if ( mlx != ilx || mly != ily )
1724 if ( slit_edges == NULL )
1731 n_slitlets = N_SLITLETS ;
1734 returnImage = cpl_image_duplicate( im ) ;
1735 podata=cpl_image_get_data_float(returnImage);
1739 for ( row = 0 ; row < ily ; row++ )
1741 for ( col = 0 ; col < ilx ; col++ )
1744 if ( isnan(pmdata[col + row*mlx]) ||
1745 pmdata[col + row*mlx] == 0. ||
1746 isnan(pidata[col + row*mlx]) )
1750 for ( k = 0 ; k < n_slitlets ; k++ )
1752 if ( sinfo_new_nint(slit_edges[k][0]) <= col &&
1753 sinfo_new_nint(slit_edges[k][1]) >= col )
1765 for ( i = 0 ; i < 6 ; i++ )
1767 validpixel[i] = 0. ;
1771 for ( i = 1 ; i <= max_rad ; i++ )
1775 if ( !isnan(pmdata[col + (row+i) * mlx])
1776 && pmdata[col + (row+i) * mlx] != 0. &&
1777 !isnan(pidata[col + (row+i) * ilx]) )
1779 validpixel[n] = pidata[col + (row+i) * ilx] ;
1785 if ( !isnan(pmdata[col + (row-i) * mlx])
1786 && pmdata[col + (row-i) * mlx] != 0. &&
1787 !isnan(pidata[col + (row-i) * ilx]) )
1789 validpixel[n] = pidata[col + (row-i) * ilx] ;
1796 if ( col + i < ilx )
1798 if ( slitlet != -1000 )
1800 if (col+i <= sinfo_new_nint(slit_edges[slitlet][1]) &&
1801 !isnan(pmdata[col + i + row * mlx]) &&
1802 pmdata[col + i + row * mlx] != 0. &&
1803 !isnan(pidata[col + i + row * ilx]) )
1805 validpixel[n] = pidata[col + i + row * ilx] ;
1812 if ( slitlet != -1000 )
1814 if (col-i >= sinfo_new_nint(slit_edges[slitlet][0]) &&
1815 !isnan(pmdata[col - i + row * mlx]) &&
1816 pmdata[col - i + row * mlx] != 0. &&
1817 !isnan(pidata[col - i + row * ilx]) )
1819 validpixel[n] = pidata[col - i + row * ilx] ;
1825 if ( i == 1 && n > 1 )
1837 podata[col + row*ilx] = ZERO ;
1848 for ( i = 0 ; i < n ; i++ )
1850 sum += validpixel[i] ;
1852 podata[col + row*ilx] = sum/n ;
1858 return returnImage ;
1870 cpl_image * sinfo_new_stack_row_to_image ( Vector * row,
int ly )
1872 cpl_image * image=NULL;
1877 if ( row == NullVector )
1889 if (NULL == (image = cpl_image_new(row->n_elements ,ly,CPL_TYPE_FLOAT )) )
1894 podata=cpl_image_get_data_float(image);
1896 for ( col = 0 ; col < row -> n_elements ; col++ )
1898 for ( ro = 0 ; ro < ly ; ro++ )
1900 podata[col + ro*ly] = row -> data[col] ;
1921 Stats * sinfo_new_image_stats_on_rectangle ( cpl_image * im,
1929 Stats * retstats=NULL;
1939 float * pix_array=NULL;
1949 if ( loReject+hiReject >= 100. )
1954 if ( loReject < 0. || loReject >= 100. ||
1955 hiReject < 0. || hiReject >= 100. )
1961 im_lx=cpl_image_get_size_x(im);
1962 im_ly=cpl_image_get_size_y(im);
1964 if ( llx < 0 || lly < 0 || urx < 0 || ury < 0 ||
1965 llx >= im_lx || lly >= im_ly || urx >= im_lx ||
1966 ury >= im_ly || ury <= lly || urx <= llx )
1973 retstats = (Stats*) cpl_calloc(1,
sizeof(Stats)) ;
1974 npix = (urx - llx + 1) * (ury - lly + 1) ;
1975 pix_array = (
float*) cpl_calloc ( npix,
sizeof(
float) ) ;
1981 pim = cpl_image_get_data_float(im);
1982 for ( row = lly ; row <= ury ; row++ )
1984 for ( col = llx ; col <= urx ; col++ )
1986 if ( !isnan(pim[col + row*im_lx]) )
1988 pix_array[n] = pim[col + row*im_lx] ;
2005 if ( FLT_MAX == (retstats->cleanmean = sinfo_new_clean_mean(pix_array,
2006 npix, loReject, hiReject)) )
2009 cpl_free(retstats) ;
2010 cpl_free(pix_array) ;
2016 lo_n = (int) (loReject / 100. * (
float)npix) ;
2017 hi_n = (int) (hiReject / 100. * (
float)npix) ;
2021 for ( i = lo_n ; i <= npix - hi_n ; i++ )
2023 pix_sum += (double)pix_array[i] ;
2024 sqr_sum += ((double)pix_array[i] * (
double)pix_array[i]) ;
2031 cpl_free(retstats) ;
2032 cpl_free(pix_array) ;
2035 retstats -> npix = n ;
2036 pix_sum /= (double) n ;
2037 sqr_sum /= (double) n ;
2038 retstats -> cleanstdev = (float)sqrt(sqr_sum - pix_sum * pix_sum) ;
2039 cpl_free (pix_array) ;
2053 cpl_image * sinfo_new_normalize_to_central_pixel ( cpl_image * image )
2061 cpl_image * retImage=NULL;
2067 if ( image == NULL )
2072 ilx=cpl_image_get_size_x(image);
2073 ily=cpl_image_get_size_y(image);
2074 pidata=cpl_image_get_data_float(image);
2076 retImage = cpl_image_duplicate(image) ;
2077 podata=cpl_image_get_data_float(retImage);
2082 array=cpl_calloc(2*ilx,
sizeof(
float)) ;
2084 for ( row = ily/2 ; row < ily/2+1 ; row++ )
2086 for ( col = 0 ; col < ilx ; col++ )
2088 if ( !isnan(pidata[col+ilx*row]) )
2090 array[n] = pidata[col+ilx*row] ;
2097 if ( isnan(divisor = sinfo_new_median(array, n) ) )
2108 for ( i = 0 ; i < (int) ilx*ily ; i++ )
2110 if ( isnan(pidata[i]) )
2116 podata[i] = pidata[i]/divisor ;
2155 sinfo_new_mpe_shift_image(
2156 cpl_image * image_in,
2159 double * interp_kernel)
2161 cpl_image * shifted=NULL ;
2162 pixelvalue * first_pass=NULL ;
2163 pixelvalue * second_pass=NULL ;
2164 int samples = KERNEL_SAMPLES ;
2169 int tabx=0, taby=0 ;
2172 register pixelvalue * pix ;
2173 register pixelvalue * pixint ;
2177 int freeKernel = 1 ;
2186 if (image_in==NULL)
return NULL ;
2189 if ((fabs(shift_x)<1e-2) && (fabs(shift_y)<1e-2))
2190 return cpl_image_duplicate(image_in) ;
2191 ilx=cpl_image_get_size_x(image_in);
2192 ily=cpl_image_get_size_y(image_in);
2193 pidata=cpl_image_get_data_float(image_in);
2197 if (interp_kernel == NULL) {
2198 ker = sinfo_generate_interpolation_kernel(
"default") ;
2204 ker = interp_kernel ;
2208 mid = (int)samples/(
int)2 ;
2209 first_pass = cpl_calloc(ilx, ily*
sizeof(pixelvalue)) ;
2210 shifted = cpl_image_new(ilx, ily,CPL_TYPE_FLOAT) ;
2211 psdata=cpl_image_get_data_float(shifted);
2213 second_pass = psdata ;
2218 for (j=0 ; j<ily ; j++)
2220 for (i=0 ; i<ilx ; i++) {
2221 fx = (double)i-shift_x ;
2223 rx = fx - (double)px ;
2224 pos = px + j * ilx ;
2226 if ((px>1) && (px<(ilx-2)))
2228 tabx = (int)(fabs((
double)mid * rx)) ;
2230 if (isnan(pix[pos]))
2236 if (isnan(pix[pos-1]))
2240 if (isnan(pix[pos+1]))
2244 if (isnan(pix[pos+2]))
2253 value = (double)pix[pos-1] * ker[mid+tabx] +
2254 (
double)pix[pos] * ker[tabx] +
2255 (double)pix[pos+1] * ker[mid-tabx] +
2256 (
double)pix[pos+2] * ker[samples-tabx-1] ;
2261 norm = (
double)ker[mid+tabx] +
2263 (
double)ker[mid-tabx] +
2264 (
double)ker[samples-tabx-1] ;
2265 if (fabs(norm) > 1e-4) {
2278 first_pass[i+j*ilx] = ZERO ;
2282 first_pass[i+j*ilx] = (pixelvalue)value ;
2289 memcpy(first_pass,pix,ily*
sizeof(pixelvalue));
2292 pixint = first_pass ;
2293 for (i=0 ; i<ilx ; i++) {
2294 for (j=0 ; j<ily ; j++) {
2295 fy = (double)j - shift_y ;
2297 ry = fy - (double)py ;
2298 pos = i + py * ilx ;
2300 taby = (int)(fabs((
double)mid * ry)) ;
2302 if ((py>(
int)1) && (py<(ily-2))) {
2304 if (isnan(pixint[pos]) && ilx != 1 )
2310 if (isnan(pixint[pos-ilx]))
2312 pixint[pos-ilx] = 0. ;
2314 if (isnan(pixint[pos+ilx]))
2316 pixint[pos+ilx] = 0. ;
2318 if (isnan(pixint[pos+2*ilx]))
2320 pixint[pos+2*ilx] = 0. ;
2326 value = (double)pixint[pos-ilx] * ker[mid+taby] +
2327 (
double)pixint[pos] * ker[taby] +
2328 (double)pixint[pos+ilx] * ker[mid-taby] +
2329 (
double)pixint[pos+2*ilx]*ker[samples-taby-1];
2334 norm = (
double)ker[mid+taby] +
2336 (
double)ker[mid-taby] +
2337 (
double)ker[samples-taby-1] ;
2339 if (fabs(norm) > 1e-4) {
2348 second_pass[i+j*ilx] = ZERO ;
2352 second_pass[i+j*ilx] = (pixelvalue)value ;
2357 cpl_free(first_pass) ;
2398 sinfo_new_shift_image_in_cube(
2399 cpl_image * image_in,
2402 double * interp_kernel,
2403 cpl_image * shifted,
2404 pixelvalue * first_pass)
2406 pixelvalue * second_pass=NULL ;
2407 int samples = KERNEL_SAMPLES ;
2412 int tabx=0, taby=0 ;
2415 register pixelvalue * pix ;
2416 register pixelvalue * pixint ;
2420 int freeKernel = 1 ;
2430 if (image_in==NULL) shifted = NULL ;
2431 pidata=cpl_image_get_data_float(image_in);
2432 ilx=cpl_image_get_size_x(image_in);
2433 ily=cpl_image_get_size_y(image_in);
2435 shifted=cpl_image_new(ilx,ily,CPL_TYPE_FLOAT);
2439 psdata=cpl_image_get_data_float(shifted);
2442 if ((fabs(shift_x)<1e-2) && (fabs(shift_y)<1e-2))
2443 memcpy(psdata,pidata, (
size_t) slx*sly *
sizeof(pixelvalue)) ;
2446 if (interp_kernel == NULL) {
2447 ker = sinfo_generate_interpolation_kernel(
"default") ;
2453 ker = interp_kernel ;
2457 mid = (int)samples/(
int)2 ;
2458 second_pass = psdata ;
2461 for (j=0 ; j<ily ; j++) {
2462 for (i=1 ; i<ilx-2 ; i++) {
2463 fx = (double)i-shift_x ;
2465 rx = fx - (double)px ;
2467 pos = px + j * ilx ;
2469 if ((px>1) && (px<(ilx-2))) {
2470 tabx = (int)(fabs((
double)mid * rx)) ;
2472 if (isnan(pix[pos]))
2478 if (isnan(pix[pos-1]))
2482 if (isnan(pix[pos+1]))
2486 if (isnan(pix[pos+2]))
2495 value = (double)pix[pos-1] * ker[mid+tabx] +
2496 (
double)pix[pos] * ker[tabx] +
2497 (double)pix[pos+1] * ker[mid-tabx] +
2498 (
double)pix[pos+2] * ker[samples-tabx-1] ;
2503 norm = (
double)ker[mid+tabx] +
2505 (
double)ker[mid-tabx] +
2506 (
double)ker[samples-tabx-1] ;
2507 if (fabs(norm) > 1e-4) {
2520 first_pass[i+j*ilx] = ZERO ;
2524 first_pass[i+j*ilx] = (pixelvalue)value ;
2528 pixint = first_pass ;
2529 for (i=0 ; i< ilx ; i++) {
2530 for (j=1 ; j< ily-2 ; j++) {
2531 fy = (double)j - shift_y ;
2533 ry = fy - (double)py ;
2534 pos = i + py * ilx ;
2536 taby = (int)(fabs((
double)mid * ry)) ;
2538 if ((py>(
int)1) && (py<(ily-2))) {
2540 if (isnan(pixint[pos]))
2546 if (isnan(pixint[pos-ilx]))
2548 pixint[pos-ilx] = 0. ;
2550 if (isnan(pixint[pos+ilx]))
2552 pixint[pos+ilx] = 0. ;
2554 if (isnan(pixint[pos+2*ilx]))
2556 pixint[pos+2*ilx] = 0. ;
2562 value = (double)pixint[pos-ilx] * ker[mid+taby] +
2563 (
double)pixint[pos] * ker[taby] +
2564 (double)pixint[pos+ilx] * ker[mid-taby] +
2565 (
double)pixint[pos+2*ilx]*ker[samples-taby-1];
2570 norm = (
double)ker[mid+taby] +
2572 (
double)ker[mid-taby] +
2573 (
double)ker[samples-taby-1] ;
2575 if (fabs(norm) > 1e-4) {
2584 second_pass[i+j*ilx] = ZERO ;
2588 second_pass[i+j*ilx] = (pixelvalue)value ;
2598 void sinfo_new_del_Stats( Stats * st)
2610 sinfo_new_combine_masks ( cpl_image * firstMask, cpl_image * secondMask )
2612 cpl_image * retMask=NULL ;
2618 float* pm2data=NULL;
2620 if ( firstMask == NULL || secondMask == NULL )
2625 retMask = cpl_image_duplicate (firstMask) ;
2626 podata = cpl_image_get_data_float(retMask);
2628 pm2data = cpl_image_get_data_float(secondMask);
2629 olx=cpl_image_get_size_x(retMask);
2630 oly=cpl_image_get_size_y(retMask);
2632 for ( n = 0 ; n < (int) olx*oly ; n++ )
2634 if ( podata[n] == 0. || pm2data[n] == 0. )
2654 cpl_image * sinfo_new_slice_cube (cpl_imagelist * cube,
int x,
int y )
2656 cpl_image * retImage=NULL ;
2657 int col=0, row=0, z=0 ;
2661 cpl_image* img=NULL;
2670 if ( x > 31 || y > 31 )
2675 img=cpl_imagelist_get(cube,0);
2676 ilx=cpl_image_get_size_x(img);
2677 ily=cpl_image_get_size_y(img);
2678 inp=cpl_imagelist_get_size(cube);
2682 if ( NULL == (retImage = cpl_image_new(ilx, inp, CPL_TYPE_FLOAT)) )
2687 podata=cpl_image_get_data_float(retImage);
2688 for ( z = 0 ; z < inp ; z++ )
2691 pidata=cpl_image_get_data_float(cpl_imagelist_get(cube,z));
2692 for ( col = 0 ; col < ilx ; col++ )
2694 podata[col+z*ilx] = pidata[col+y*ilx] ;
2701 if ( NULL == (retImage = cpl_image_new(ily, inp,CPL_TYPE_FLOAT)) )
2706 podata=cpl_image_get_data_float(retImage);
2708 for ( z = 0 ; z < inp ; z++ )
2710 pidata=cpl_image_get_data_float(cpl_imagelist_get(cube,z));
2711 for ( row = 0 ; row < ily ; row++ )
2713 podata[row+z*ily] = pidata[x+row*ily] ;
2736 cpl_image * sinfo_new_div_images_robust ( cpl_image * im1, cpl_image * im2 )
2738 cpl_image * retIm=NULL ;
2750 if ( im1 == NULL || im2 == NULL )
2755 lx1=cpl_image_get_size_x(im1);
2756 ly1=cpl_image_get_size_y(im1);
2757 lx2=cpl_image_get_size_x(im2);
2758 ly2=cpl_image_get_size_y(im2);
2759 p1data=cpl_image_get_data_float(im1);
2760 p2data=cpl_image_get_data_float(im2);
2762 if ( lx1 != lx2 || ly1 != ly2 )
2767 if ( NULL == (retIm = cpl_image_new(lx1, ly1, CPL_TYPE_FLOAT)) )
2772 podata=cpl_image_get_data_float(retIm);
2774 for ( i = 0 ; i < (int) lx2*ly2 ; i++ )
2776 if ( !isnan(p2data[i]) )
2778 help = 1./p2data[i] ;
2779 if (fabs( help )> THRESH )
2788 if ( isnan(help) || isnan(p1data[i]) )
2794 podata[i] = p1data[i] * help ;
2800 cpl_image * sinfo_new_null_edges ( cpl_image * image)
2802 cpl_image *
new=NULL ;
2814 if ( image == NULL )
2821 new = cpl_image_duplicate (image) ;
2826 olx=cpl_image_get_size_x(
new);
2827 oly=cpl_image_get_size_y(
new);
2829 podata=cpl_image_get_data_float(
new);
2831 for ( i = 0 ; i < olx ; i++ )
2833 for ( j = 0 ; j < 4 ; j++)
2836 podata[i+(oly-j-1)*olx]=0;
2839 for ( i = 0 ; i < oly ; i++ )
2841 for ( j = 0 ; j < 4 ; j++)
2844 podata[(olx-j-1)+i*olx]=0;
2851 void sinfo_new_used_cor_map( cpl_image *im, cpl_image *map)
2853 int i=0,j=0,loc_index=0;
2854 float temp_array[2048];
2855 int lx=cpl_image_get_size_x(im);
2856 int ly=cpl_image_get_size_y(im);
2857 float* pidata=cpl_image_get_data_float(im);
2858 float* pmdata=cpl_image_get_data_float(map);
2860 for( j=0; j<ly; j++)
2864 loc_index = (int)pmdata[i+j*lx];
2865 temp_array[i] = pidata[loc_index+j*lx];
2869 pidata[i+j*lx]= temp_array[i];
2903 sinfo_new_shift_image(
2904 cpl_image * image_in,
2907 double * interp_kernel)
2909 cpl_image * shifted=NULL ;
2910 float * first_pass=NULL ;
2911 float * second_pass=NULL ;
2912 int samples = KERNEL_SAMPLES ;
2917 int tabx=0, taby=0 ;
2920 register float * pix=NULL ;
2921 register float * pixint=NULL ;
2925 int freeKernel = 1 ;
2930 if (image_in==NULL)
return NULL ;
2933 if ((fabs(shift_x)<1e-2) && (fabs(shift_y)<1e-2))
2934 return cpl_image_duplicate(image_in) ;
2937 if (interp_kernel == NULL) {
2938 ker = sinfo_generate_interpolation_kernel(
"default") ;
2944 ker = interp_kernel ;
2948 ilx=cpl_image_get_size_x(image_in);
2949 ily=cpl_image_get_size_y(image_in);
2952 pix = cpl_image_get_data_float(image_in);
2955 mid = (int)samples/(
int)2 ;
2956 first_pass = cpl_calloc(ilx, ily*
sizeof(
float)) ;
2957 shifted = cpl_image_new(ilx, ily,CPL_TYPE_FLOAT) ;
2958 second_pass = cpl_image_get_data_float(shifted);
2959 for (j=0 ; j<ily ; j++) {
2960 for (i=1 ; i<ilx-2 ; i++) {
2961 fx = (double)i-shift_x ;
2963 rx = fx - (double)px ;
2965 pos = px + j * ilx ;
2967 if ((px>1) && (px<(ilx-3))) {
2968 tabx = (int)(fabs((
double)mid * rx)) ;
2973 value = (double)pix[pos-1] * ker[mid+tabx] +
2974 (
double)pix[pos] * ker[tabx] +
2975 (double)pix[pos+1] * ker[mid-tabx] +
2976 (
double)pix[pos+2] * ker[samples-tabx-1] ;
2981 norm = (
double)ker[mid+tabx] +
2983 (
double)ker[mid-tabx] +
2984 (
double)ker[samples-tabx-1] ;
2985 if (fabs(norm) > 1e-4) {
2995 first_pass[i+j*ilx] = (float)value ;
2998 pixint = first_pass ;
2999 for (i=0 ; i<ilx ; i++) {
3000 for (j=1 ; j<ily-3 ; j++) {
3001 fy = (double)j - shift_y ;
3003 ry = fy - (double)py ;
3004 pos = i + py * ilx ;
3006 taby = (int)(fabs((
double)mid * ry)) ;
3008 if ((py>(
int)1) && (py<(ily-2))) {
3013 value = (double)pixint[pos-ilx] * ker[mid+taby] +
3014 (
double)pixint[pos] * ker[taby] +
3015 (double)pixint[pos+ilx] * ker[mid-taby] +
3016 (
double)pixint[pos+2*ilx]*ker[samples-taby-1];
3021 norm = (
double)ker[mid+taby] +
3023 (
double)ker[mid-taby] +
3024 (
double)ker[samples-taby-1] ;
3026 if (fabs(norm) > 1e-4) {
3032 second_pass[i+j*ilx] = (float)value ;
3038 cpl_msg_warning(cpl_func,
"cannot get a data from an image");
3040 cpl_free(first_pass) ;
3064 sinfo_image_hermite_interpol(cpl_image * inp)
3087 cpl_image* out=NULL;
3089 cknull(inp,
"Null in put image, exit");
3090 check_nomsg(out=cpl_image_duplicate(inp));
3091 check_nomsg(sx=cpl_image_get_size_x(inp));
3092 check_nomsg(sy=cpl_image_get_size_y(inp));
3093 check_nomsg(pinp=cpl_image_get_data_float(inp));
3094 check_nomsg(pout=cpl_image_get_data_float(out));
3095 for(j=r;j<sy-r;j++) {
3098 pout[j*sx+i]+=pinp[(j+k)*sx+i];
3106 if(cpl_error_get_code() != CPL_ERROR_NONE) {
3134 sinfo_image_smooth_y(cpl_image * inp,
const int r)
3153 cpl_image* out=NULL;
3155 cknull(inp,
"Null in put image, exit");
3156 check_nomsg(out=cpl_image_duplicate(inp));
3157 check_nomsg(sx=cpl_image_get_size_x(inp));
3158 check_nomsg(sy=cpl_image_get_size_y(inp));
3159 check_nomsg(pinp=cpl_image_get_data_float(inp));
3160 check_nomsg(pout=cpl_image_get_data_float(out));
3161 for(j=r;j<sy-r;j++) {
3164 pout[j*sx+i]+=pinp[(j+k)*sx+i];
3172 if(cpl_error_get_code() != CPL_ERROR_NONE) {
3199 sinfo_image_smooth_mean_y(cpl_image * inp,
const int r)
3218 cpl_image* out=NULL;
3220 cknull(inp,
"Null in put image, exit");
3221 check_nomsg(out=cpl_image_duplicate(inp));
3222 check_nomsg(sx=cpl_image_get_size_x(inp));
3223 check_nomsg(sy=cpl_image_get_size_y(inp));
3224 check_nomsg(pinp=cpl_image_get_data_float(inp));
3225 check_nomsg(pout=cpl_image_get_data_float(out));
3226 for(j=r;j<sy-r;j++) {
3229 pout[j*sx+i]+=pinp[(j+k)*sx+i];
3237 if(cpl_error_get_code() != CPL_ERROR_NONE) {
3264 sinfo_image_smooth_median_y(cpl_image * inp,
const int r)
3281 cpl_image* out=NULL;
3284 cknull(inp,
"Null in put image, exit");
3285 check_nomsg(out=cpl_image_duplicate(inp));
3286 check_nomsg(sx=cpl_image_get_size_x(inp));
3287 check_nomsg(sy=cpl_image_get_size_y(inp));
3288 check_nomsg(pout=cpl_image_get_data_float(out));
3290 for(j=r+1;j<sy-r;j++) {
3292 pout[j*sx+i]=(float)cpl_image_get_median_window(inp,i,j,i,j+r);
3298 if(cpl_error_get_code() != CPL_ERROR_NONE) {
3323 sinfo_image_smooth_fft(cpl_image * inp,
const int fy)
3329 cpl_image* out=NULL;
3330 cpl_image* im_re=NULL;
3331 cpl_image* im_im=NULL;
3332 cpl_image* ifft_re=NULL;
3333 cpl_image* ifft_im=NULL;
3334 cpl_image* filter=NULL;
3339 cknull(inp,
"Null in put image, exit");
3340 check_nomsg(im_re = cpl_image_cast(inp, CPL_TYPE_DOUBLE));
3341 check_nomsg(im_im = cpl_image_cast(inp, CPL_TYPE_DOUBLE));
3344 check_nomsg(cpl_image_fft(im_re,im_im,CPL_FFT_DEFAULT));
3346 check_nomsg(sx=cpl_image_get_size_x(inp));
3347 check_nomsg(sy=cpl_image_get_size_y(inp));
3351 check_nomsg(filter = sinfo_gen_lowpass(sx,sy,sigma_x,sigma_y));
3354 cpl_image_multiply(im_re,filter);
3355 cpl_image_multiply(im_im,filter);
3357 sinfo_free_image(&filter);
3359 check_nomsg(ifft_re = cpl_image_duplicate(im_re));
3360 check_nomsg(ifft_im = cpl_image_duplicate(im_im));
3362 sinfo_free_image(&im_re);
3363 sinfo_free_image(&im_im);
3366 check_nomsg(cpl_image_fft(ifft_re,ifft_im,CPL_FFT_INVERSE));
3367 check_nomsg(out = cpl_image_cast(ifft_re, CPL_TYPE_FLOAT));
3371 sinfo_free_image(&ifft_re);
3372 sinfo_free_image(&ifft_im);
3373 sinfo_free_image(&filter);
3374 sinfo_free_image(&im_re);
3375 sinfo_free_image(&im_im);
3377 if(cpl_error_get_code() != CPL_ERROR_NONE) {
3405 sinfo_gen_lowpass(
const int xs,
3407 const double sigma_x,
3408 const double sigma_y)
3417 double gaussval= 0.0;
3418 double inv_sigma_x=1./sigma_x;
3419 double inv_sigma_y=1./sigma_y;
3423 cpl_image *lowpass_image=NULL;
3426 lowpass_image = cpl_image_new (xs, ys, CPL_TYPE_FLOAT);
3427 if (lowpass_image == NULL) {
3429 cpl_error_get_message());
3436 data = cpl_image_get_data_float(lowpass_image);
3451 for (i=1 ; i<=hlx ; i++) {
3452 x = i * inv_sigma_x;
3453 gaussval = exp(-0.5*x*x);
3455 data[xs-i] = gaussval;
3458 for (j=1; j<=hly ; j++) {
3459 y = j * inv_sigma_y;
3461 data[j*xs] = exp(-0.5*y*y);
3462 data[(ys-j)*xs] = exp(-0.5*y*y);
3464 for (i=1 ; i<=hlx ; i++) {
3466 x = i * inv_sigma_x;
3467 gaussval = exp (-0.5*(x*x+y*y));
3468 data[j*xs+i] = gaussval;
3469 data[(j+1)*xs-i] = gaussval;
3470 data[(ys-j)*xs+i] = gaussval;
3471 data[(ys+1-j)*xs-i] = gaussval;
3483 return lowpass_image;
3486 static void quicksort_int(
int* data,
int left,
int right)
3490 int pivot = (i + j) / 2;
3491 double index_value = data[pivot];
3494 while(data[i] < index_value) i++;
3495 while(data[j] > index_value) j--;
3511 quicksort_int(data, i, right);
3515 quicksort_int(data, left, j);