40 #include "sinfo_vltPort.h"
50 #include "sinfo_image_ops.h"
51 #include "sinfo_error.h"
52 #include "sinfo_resampling.h"
53 #include "sinfo_local_types.h"
54 #include "sinfo_utils_wrappers.h"
64 sinfo_gen_lowpass(
const int xs,
67 const double sigma_y);
70 static void quicksort_int(
int* data,
int left,
int right);
91 sinfo_image_line_corr(
const int width,
100 cpl_image* ima_backpix=NULL;
101 cpl_image* ima_backpos=NULL;
102 cpl_image* ima_ybackpix=NULL;
103 cpl_image* ima_diffbackpix=NULL;
104 cpl_image* ima_filt=NULL;
105 cpl_image* ima = NULL;
107 cpl_matrix* filter=NULL;
109 cpl_mask* bpm_bad=NULL;
125 cpl_binary* pbin=NULL;
136 check_nomsg(sx=cpl_image_get_size_x(ima_in));
137 check_nomsg(sy=cpl_image_get_size_y(ima_in));
138 check_nomsg(*ima_out=cpl_image_duplicate(ima_in));
140 check_nomsg(mask=cpl_image_new(sx,sy,CPL_TYPE_FLOAT));
141 check_nomsg(pmsk=cpl_image_get_data_float(mask));
143 for(i=0;i<width;i++) {
144 for(j=width;j<sy-width;j++) {
149 for(i=sx-width;i<sx;i++) {
150 for(j=width;j<sy-width;j++) {
154 sinfo_free_image(&mask);
157 nrow=2*width*(sy-2*width);
158 check_nomsg(ima_backpix=cpl_image_new(nrow,1,CPL_TYPE_FLOAT));
159 check_nomsg(ima_backpos=cpl_image_new(nrow,1,CPL_TYPE_INT));
161 check_nomsg(pima=cpl_image_get_data_float(ima_in));
162 check_nomsg(ppix=cpl_image_get_data_float(ima_backpix));
163 check_nomsg(ppos=cpl_image_get_data_int(ima_backpos));
166 for(i=0;i<width;i++) {
167 for(j=width;j<sy-width;j++) {
168 ppix[k]=pima[j*sx+i];
174 for(i=sx-width;i<sx;i++) {
175 for(j=width;j<sy-width;j++) {
176 ppix[k]=pima[j*sx+i];
182 check_nomsg(ima_ybackpix=cpl_image_duplicate(ima_backpos));
183 sinfo_free_image(&ima_backpos);
185 check_nomsg(pbackpix=cpl_image_get_data_int(ima_ybackpix));
187 check_nomsg(cpl_image_divide_scalar(ima_ybackpix,sx));
188 check_nomsg(pbackpix=cpl_image_get_data_int(ima_ybackpix));
191 check_nomsg(med_back=cpl_image_get_median(ima_backpix));
192 check_nomsg(ima_diffbackpix=cpl_image_duplicate(ima_backpix));
194 check_nomsg(cpl_image_subtract_scalar(ima_diffbackpix,med_back));
198 check_nomsg(filter=cpl_matrix_new(1,filt_rad));
199 check_nomsg(cpl_matrix_fill(filter,1.));
200 check_nomsg(ima_filt=sinfo_image_filter_median(ima_diffbackpix,filter));
201 sinfoni_free_matrix(&filter);
206 check_nomsg(sigma_back=cpl_image_get_stdev(ima_filt));
207 sinfo_free_image(&ima_filt);
209 check_nomsg(ima=cpl_image_duplicate(ima_diffbackpix));
210 sinfo_free_image(&ima_diffbackpix);
212 check_nomsg(cpl_image_abs(ima));
216 check_nomsg(bpm_bad=cpl_mask_threshold_image_create(ima,kappa*sigma_back,
222 check_nomsg(cpl_image_reject_from_mask(ima_backpix,bpm_bad));
223 check_nomsg(medvalue=cpl_image_get_median(ima_backpix));
225 check_nomsg(nbad=cpl_mask_count(bpm_bad));
227 check_nomsg(cpl_image_reject_from_mask(ima_backpix,bpm_bad));
228 sinfo_free_image(&ima_backpix);
232 check_nomsg(pbin=cpl_mask_get_data(bpm_bad));
233 check_nomsg(pbackpix=cpl_image_get_data_int(ima_ybackpix));
234 cpl_msg_debug(cpl_func,
"%d lines detected", nbad);
238 ybad = cpl_calloc(nbad,
sizeof(
int));
241 for(i=0;i<nrow;i++) {
242 if(pbin[i] == CPL_BINARY_1) {
243 ybad[k]=pbackpix[i] + 1;
247 sinfo_free_mask(&bpm_bad);
248 sinfo_free_image(&ima_ybackpix);
250 quicksort_int(&(ybad[0]), 0, nbad-1);
252 for(k=0;k<nbad;k++) {
260 check_nomsg(tot=cpl_image_get_flux_window(ima_in,1,yval,width,yval));
261 check_nomsg(tot+=cpl_image_get_flux_window(ima_in,sx-width+1,
263 mean=tot/(2. * width);
264 check_nomsg(pima=cpl_image_get_data_float(*ima_out));
265 for(i=width;i<sx-width;i++) {
266 pima[i+(yval-1)*sx]+=(
float)(mean-medvalue);
276 sinfo_free_image(&mask);
277 sinfo_free_image(&ima_backpos);
278 sinfoni_free_matrix(&filter);
279 sinfo_free_image(&ima_filt);
280 sinfo_free_image(&ima_diffbackpix);
282 sinfo_free_image(&ima_backpix);
283 sinfo_free_mask(&bpm_bad);
284 sinfo_free_image(&ima_ybackpix);
285 cpl_image_delete(ima);
287 return cpl_error_get_code();
300 double sinfo_new_my_median_image(cpl_image* im)
312 ilx=cpl_image_get_size_x(im);
313 ily=cpl_image_get_size_y(im);
314 pidata=cpl_image_get_data_float(im);
316 for ( i = 0 ; i < (int) ilx*ily ; i++ )
318 if ( isnan(pidata[i]) )
325 pv = cpl_calloc(n,
sizeof(pixelvalue));
327 for ( i = 0 ; i < (int) ilx*ily ; i++ )
329 if ( isnan(pidata[i]) )
337 if(pv == NULL || n == 0) {
340 m=sinfo_new_median(pv,n);
358 Vector * sinfo_new_mean_of_columns( cpl_image *im )
372 ilx=cpl_image_get_size_x(im);
373 ily=cpl_image_get_size_y(im);
374 pidata=cpl_image_get_data_float(im);
377 if ( NULL == (row = sinfo_new_vector (ilx)) )
383 for ( i = 0 ; i < ilx ; i++ )
385 for ( j = 0 ; j < ily ; j++ )
387 if (!isnan(pidata[i+j*ilx]))
389 row->data[i] += pidata[i + j*(ilx)] ;
393 row->data[i] /= ily ;
409 cpl_image * sinfo_new_clean_mean_of_columns( cpl_image *im,
413 cpl_image * row=NULL ;
414 pixelvalue* buffer=NULL ;
431 ilx=cpl_image_get_size_x(im);
432 ily=cpl_image_get_size_y(im);
433 pidata=cpl_image_get_data_float(im);
435 if ((lo_reject + hi_reject) > 0.9)
438 lo_reject, hi_reject) ;
440 "0.90 aborting average") ;
444 lo_n = (int) (ily * lo_reject + 0.5) ;
445 hi_n = (int) (ily * hi_reject + 0.5) ;
446 if (lo_n + hi_n >= ily)
453 if ( NULL == (row = cpl_image_new (ilx, 1,CPL_TYPE_FLOAT)) )
458 podata=cpl_image_get_data_float(row);
460 buffer=(pixelvalue*) cpl_calloc(ily,
sizeof(pixelvalue)) ;
462 for ( i = 0 ; i < ilx ; i++ )
464 for ( j = 0 ; j < ily ; j++ )
466 buffer[j] = pidata[i + j*(ilx)] ;
468 sinfo_pixel_qsort (buffer, ily) ;
471 for (k = lo_n ; k < ily - hi_n ; k ++)
473 if ( !isnan(buffer[k]) )
475 podata[i] += buffer[k] ;
497 cpl_image * sinfo_new_div_image_by_row( cpl_image *im, Vector *row )
499 cpl_image *image=NULL ;
507 if ( im == NULL || row == NULL )
512 ilx=cpl_image_get_size_x(im);
513 ily=cpl_image_get_size_y(im);
514 pidata=cpl_image_get_data_float(im);
516 if ( ilx != row -> n_elements )
522 if ( NULL == (image = cpl_image_duplicate (im)) )
527 podata=cpl_image_get_data_float(image);
529 for (i = 0 ; i < ilx ; i++ )
531 for (j = 0 ; j < ily ; j++)
533 if ( !isnan(pidata[i + j*(ilx)]) )
535 podata[i + j*(ilx)] = pidata[i + j*(ilx)] / row -> data[i] ;
553 cpl_image * sinfo_new_mult_row_to_image( cpl_image *im, Vector *row )
555 cpl_image *image=NULL;
566 if ( im == NULL || row == NULL )
571 ilx=cpl_image_get_size_x(im);
572 ily=cpl_image_get_size_y(im);
573 pidata=cpl_image_get_data_float(im);
575 if ( ilx != row -> n_elements )
581 if ( NULL == (image = cpl_image_duplicate (im)) )
586 podata=cpl_image_get_data_float(image);
588 for (i = 0 ; i < ilx ; i++ )
590 for (j = 0 ; j < ily ; j++)
592 if ( !isnan(pidata[i + j*(ilx)]) )
594 podata[i + j*(ilx)] = pidata[i + j*(ilx)] * row -> data[i] ;
631 cpl_image * sinfo_new_col_tilt ( cpl_image * image,
float sigmaFactor )
634 float * column=NULL ;
638 float sinfo_median=0;
655 float* p_in_data=NULL;
656 float* p_ou_data=NULL;
665 if ( sigmaFactor <= 0. )
670 lx = cpl_image_get_size_x(image);
671 ly = cpl_image_get_size_y(image);
675 if ( NULL == (im = cpl_image_new (lx,ly,CPL_TYPE_FLOAT )) )
682 p_in_data = cpl_image_get_data_float(image);
683 p_ou_data = cpl_image_get_data_float(im);
684 for ( i = 0 ; i < lx ; i ++ )
688 column = (
float *) cpl_calloc ( ly ,
sizeof (
float *) ) ;
689 float* sig = (
float *) cpl_calloc ( ly ,
sizeof (
float *) ) ;
690 float* dat = (
float *) cpl_calloc ( ly ,
sizeof (
float *) ) ;
693 for ( j = 0 ; j < ly ; j++ )
695 if ( !isnan(p_in_data[i + j*lx]) )
697 column[j] = p_in_data[i + j*lx] ;
705 for ( j = 0 ; j < ly ; j++ )
707 p_ou_data[i + j*lx] = ZERO;
723 sinfo_pixel_qsort (column, colnum) ;
729 for ( j = 0.1*colnum + 1 ; j <= 0.9*colnum ; j++ )
732 sum2 += column[j] * column[j] ;
738 noise = sigmaFactor * 1000.;
742 mean = sum/(float)npix ;
743 noise = sqrt( (sum2 - sum*mean)/(
double)(npix -1) ) ;
744 noise *= sigmaFactor ;
753 if ( colnum % 2 == 1 )
755 sinfo_median = column[colnum/2] ;
759 sinfo_median = (column[colnum/2 - 1] + column[colnum/2])/2. ;
765 for ( j = 0; j < ly ; j ++ )
767 if ( !isnan(p_in_data[i+j*lx]) &&
768 fabs ( (p_in_data[i+j*lx]) - sinfo_median) <= noise )
770 column[colnum] = p_in_data[i+j*lx] ;
771 dat[colnum] = (float) j ;
793 sinfo_my_fit ( dat, column, colnum, sig, mwt, &a,
794 &b, &siga, &sigb, &chi2, &q ) ;
796 if ( fabs(b) >= SLOPE || fabs(a) >= SATURATION ||
797 isnan(b) || isnan(a))
800 " saturation level is reached: %f in column"
801 " number %d ", b, a , i+1) ;
805 for ( j = 0; j < ly; j++ )
807 if ( !isnan(p_in_data[i+j*lx]) &&
808 fabs(b) < SLOPE && fabs(a) < SATURATION )
810 p_ou_data[i+j*lx] = p_in_data[i+j*lx] - (a + b * (float)j) ;
812 else if ( isnan(p_in_data[i+j*lx]) )
814 p_ou_data[i+j*lx] = ZERO ;
816 else if ( (fabs(b) >= SLOPE ||
817 fabs(a) >= SATURATION || isnan(a) || isnan(b)) &&
818 !isnan(p_in_data[i+j*lx]) )
820 p_ou_data[i+j*lx] -= sinfo_median ;
868 cpl_image * sinfo_new_median_image( cpl_image * im,
float fmedian )
870 cpl_image * image=NULL ;
871 pixelvalue * value=NULL ;
872 pixelvalue sinfo_median=0 ;
873 int * position=NULL ;
880 float* p_in_data=NULL;
881 float* p_ou_data=NULL;
889 image = cpl_image_duplicate ( im ) ;
890 lx=cpl_image_get_size_x(im);
891 ly=cpl_image_get_size_y(im);
893 p_in_data=cpl_image_get_data_float(im);
894 p_ou_data=cpl_image_get_data_float(image);
900 for ( i = 0 ; i < im_size ; i++ )
903 if ( isnan(p_in_data[i]) )
909 value = (pixelvalue * )cpl_calloc ( 8,
sizeof ( pixelvalue * ) ) ;
910 position = (
int * ) cpl_calloc ( 8,
sizeof (
int * ) ) ;
916 position[0] = i + lx - 1 ;
917 position[1] = i + lx ;
918 position[2] = i + lx + 1 ;
919 position[3] = i + 1 ;
920 position[4] = i - lx + 1 ;
921 position[5] = i - lx ;
922 position[6] = i - lx - 1 ;
923 position[7] = i - 1 ;
931 if ( i >= 0 && i < lx )
933 position[4] += 2 * lx ;
934 position[5] += 2 * lx ;
935 position[6] += 2 * lx ;
937 else if ( i >= ((
int) lx*ly - lx ) && i < (
int) lx*ly )
939 position[0] -= 2 * lx ;
940 position[1] -= 2 * lx ;
941 position[2] -= 2 * lx ;
943 else if ( i % lx == 0 )
949 else if ( i % lx == lx - 1 )
963 for ( j = 0 ; j < nposition ; j ++ )
965 if((position[j] >-1 ) && (position[j]<im_size)) {
966 if ( !isnan(p_in_data[position[j]]) )
968 value[n] = p_in_data[position[j]] ;
975 if ( nposition <= 1 )
977 p_ou_data[i] = ZERO ;
985 sinfo_pixel_qsort ( value, nposition ) ;
986 if ( nposition % 2 == 1 )
988 sinfo_median = value [ nposition/2 ] ;
992 sinfo_median = ( value [nposition/2 - 1] +
993 value [nposition/2] ) / 2. ;
1012 p_ou_data[i] = sinfo_median ;
1014 else if ( fmedian < 0 &&
1015 fabs ( sinfo_median - p_in_data[i] ) >= -fmedian )
1017 p_ou_data[i] = sinfo_median ;
1019 else if ( fmedian > 0 &&
1020 fabs ( sinfo_median - p_in_data[i] ) >= fmedian *
1021 sqrt(fabs(sinfo_median)) )
1023 p_ou_data[i] = sinfo_median ;
1028 cpl_free (position) ;
1033 cpl_free (position) ;
1053 sinfo_new_compare_images(cpl_image * im1,cpl_image * im2,cpl_image * origim )
1055 cpl_image * image=NULL ;
1061 float* p_in1_data=NULL;
1062 float* p_in2_data=NULL;
1063 float* p_ou_data=NULL;
1064 float* p_org_data=NULL;
1067 if ( im1 == NULL || im2 == NULL || origim == NULL )
1072 lx1=cpl_image_get_size_x(im1);
1073 ly1=cpl_image_get_size_y(im1);
1075 lx2=cpl_image_get_size_x(im2);
1076 ly2=cpl_image_get_size_y(im2);
1078 p_in1_data=cpl_image_get_data_float(im1);
1079 p_in2_data=cpl_image_get_data_float(im2);
1080 p_org_data=cpl_image_get_data_float(origim);
1081 if ( lx1 != lx2 || ly1 != ly2 )
1088 if ( NULL == (image = cpl_image_new ( lx1, ly1, CPL_TYPE_FLOAT )) )
1093 p_ou_data=cpl_image_get_data_float(image);
1094 for ( i = 0 ; i < (int) lx1*ly1 ; i ++ )
1096 if ( isnan(p_in1_data[i]) && isnan(p_in2_data[i]) )
1098 p_ou_data[i] = ZERO ;
1102 if ( p_in1_data[i] == p_in2_data[i] )
1104 p_ou_data[i] = p_org_data[i] ;
1108 p_ou_data[i] = ZERO ;
1130 sinfo_new_promote_image_to_mask (cpl_image * im,
int * n_badpixels )
1132 cpl_image * reImage=NULL ;
1136 float* p_in_data=NULL;
1137 float* p_ou_data=NULL;
1144 lx=cpl_image_get_size_x(im);
1145 ly=cpl_image_get_size_y(im);
1146 p_in_data=cpl_image_get_data_float(im);
1149 if ( NULL == (reImage = cpl_image_new (lx,ly,CPL_TYPE_FLOAT )) )
1154 p_ou_data=cpl_image_get_data_float(reImage);
1157 for ( i = 0 ; i < (int) lx*ly ; i ++ )
1159 if ( isnan(p_in_data[i]) )
1184 cpl_image * sinfo_new_mult_image_by_mask (cpl_image * im,cpl_image * mask )
1186 cpl_image * reImage=NULL ;
1207 ix=cpl_image_get_size_x(im);
1208 iy=cpl_image_get_size_y(im);
1209 mx=cpl_image_get_size_x(mask);
1210 my=cpl_image_get_size_y(mask);
1212 if ( ix != mx || iy != my)
1218 reImage = cpl_image_duplicate( im ) ;
1219 podata=cpl_image_get_data_float(reImage);
1220 pmdata=cpl_image_get_data_float(mask);
1222 for ( i = 0 ; i < (int) ix*iy ; i ++ )
1224 if ( pmdata[i] == 0. )
1246 sinfo_new_thresh_image (cpl_image * im,
float lo_cut,
float hi_cut )
1248 cpl_image * image=NULL ;
1249 float* p_inp_data=NULL;
1250 float* p_out_data=NULL;
1261 lx=cpl_image_get_size_x(im);
1262 ly=cpl_image_get_size_y(im);
1264 image = cpl_image_duplicate(im) ;
1265 p_inp_data=cpl_image_get_data(im);
1266 p_out_data=cpl_image_get_data(image);
1267 for ( i = 0 ; i < (int) lx*ly ; i ++ )
1269 if ( p_inp_data[i] > (pixelvalue) hi_cut ||
1270 p_inp_data[i] < (pixelvalue) lo_cut )
1272 p_out_data[i] = ZERO ;
1306 cpl_image * sinfo_new_interpol_image ( cpl_image * im,
1311 cpl_image * returnImage=NULL ;
1312 float* neighbors=NULL ;
1336 ilx=cpl_image_get_size_x(im);
1337 ily=cpl_image_get_size_y(im);
1338 pidata=cpl_image_get_data_float(im);
1346 mlx=cpl_image_get_size_x(mask);
1347 mly=cpl_image_get_size_y(mask);
1348 pmdata=cpl_image_get_data_float(mask);
1350 if ( mlx != ilx || mly != ily )
1356 if ( max_radius <= 0 )
1359 "search radius given!") ;
1363 if ( n_pixels <= 2 )
1366 "for interpolation given!") ;
1370 returnImage = cpl_image_duplicate ( im ) ;
1371 podata=cpl_image_get_data_float(returnImage);
1374 neighbors=cpl_calloc(4*max_radius*max_radius,
sizeof(
float)) ;
1376 for ( col = 0 ; col < ilx ; col++ )
1378 for ( row = 0 ; row < ily ; row++ )
1381 if ( isnan(pmdata[col+row*ilx]) || pmdata[col+row*ilx] == 0. )
1386 for ( j = 1 ; j <= max_radius ; j++ )
1390 for ( k = -j ; k < j ; k++ )
1392 if ( col-j >= 0 && row+k < ily && row+k >= 0 )
1394 if ( !isnan(pmdata[col-j+(row+k)*mlx]) ||
1395 pmdata[col-j+(row+k)*mlx] != 0 )
1397 neighbors[n_valid]=pidata[col-j+(row+k)*ilx] ;
1404 for ( k = -j ; k < j ; k++ )
1406 if ( col+k < ilx && col+k >= 0 && row+j < ily )
1408 if ( !isnan(pmdata[col+k+(row+j)*mlx]) ||
1409 pmdata[col+k+(row+j)*mlx] != 0. )
1411 neighbors[n_valid]=pidata[col+k+(row+j)*ilx] ;
1418 for ( k = -j ; k < j ; k++ )
1420 if ( col+j < ilx && row-k >= 0 && row-k < ily )
1422 if ( !isnan(pmdata[col+j+(row-k)*mlx]) ||
1423 pmdata[col+j+(row-k)*mlx] != 0. )
1425 neighbors[n_valid]=pidata[col+j+(row-k)*ilx] ;
1432 for ( k = -j ; k < j ; k++ )
1434 if ( col-k >= 0 && col-k < ilx && row-j < ily )
1436 if ( !isnan(pmdata[col-k+(row-j)*mlx]) ||
1437 pmdata[col-k+(row-j)*mlx] != 0. )
1439 neighbors[n_valid]=pidata[col-k+(row-j)*ilx] ;
1446 if ( n_valid >= n_pixels )
1452 if ( j == 1 && n_valid >= 2 )
1458 if ( n_valid < n_pixels && agreed == 0 )
1461 "interpolate bad pixel in col: "
1462 "%d, row: %d", col, row ) ;
1476 for ( i = 0 ; i < n_valid ; i++ )
1478 sum += neighbors[i] ;
1480 mean = sum / n_valid ;
1482 podata[col+row*ilx] = mean ;
1486 podata[col+row*ilx]=sinfo_new_median(neighbors,n_valid);
1492 cpl_free(neighbors);
1493 return returnImage ;
1520 cpl_image * sinfo_interpol_source_image ( cpl_image * im,
1523 float ** slit_edges )
1525 cpl_image * returnImage=NULL ;
1526 float validpixel[6] ;
1550 ilx=cpl_image_get_size_x(im);
1551 ily=cpl_image_get_size_y(im);
1552 pidata=cpl_image_get_data_float(im);
1559 mlx=cpl_image_get_size_x(mask);
1560 mly=cpl_image_get_size_y(mask);
1561 pmdata=cpl_image_get_data_float(mask);
1563 if ( mlx != ilx || mly != ily )
1575 if ( slit_edges == NULL )
1582 n_slitlets = N_SLITLETS ;
1585 returnImage = cpl_image_duplicate( im ) ;
1586 podata=cpl_image_get_data_float(returnImage);
1590 for ( row = 0 ; row < ily ; row++ )
1592 for ( col = 0 ; col < ilx ; col++ )
1595 if ( isnan(pmdata[col + row*mlx]) ||
1596 pmdata[col + row*mlx] == 0. ||
1597 isnan(pidata[col + row*mlx]) )
1601 for ( k = 0 ; k < n_slitlets ; k++ )
1603 if ( sinfo_new_nint(slit_edges[k][0]) <= col &&
1604 sinfo_new_nint(slit_edges[k][1]) >= col )
1616 for ( i = 0 ; i < 6 ; i++ )
1618 validpixel[i] = 0. ;
1622 for ( i = 1 ; i <= max_rad ; i++ )
1626 if ( !isnan(pmdata[col + (row+i) * mlx])
1627 && pmdata[col + (row+i) * mlx] != 0. &&
1628 !isnan(pidata[col + (row+i) * ilx]) )
1630 validpixel[n] = pidata[col + (row+i) * ilx] ;
1636 if ( !isnan(pmdata[col + (row-i) * mlx])
1637 && pmdata[col + (row-i) * mlx] != 0. &&
1638 !isnan(pidata[col + (row-i) * ilx]) )
1640 validpixel[n] = pidata[col + (row-i) * ilx] ;
1647 if ( col + i < ilx )
1649 if ( slitlet != -1000 )
1651 if (col+i <= sinfo_new_nint(slit_edges[slitlet][1]) &&
1652 !isnan(pmdata[col + i + row * mlx]) &&
1653 pmdata[col + i + row * mlx] != 0. &&
1654 !isnan(pidata[col + i + row * ilx]) )
1656 validpixel[n] = pidata[col + i + row * ilx] ;
1663 if ( slitlet != -1000 )
1665 if (col-i >= sinfo_new_nint(slit_edges[slitlet][0]) &&
1666 !isnan(pmdata[col - i + row * mlx]) &&
1667 pmdata[col - i + row * mlx] != 0. &&
1668 !isnan(pidata[col - i + row * ilx]) )
1670 validpixel[n] = pidata[col - i + row * ilx] ;
1676 if ( i == 1 && n > 1 )
1688 podata[col + row*ilx] = ZERO ;
1699 for ( i = 0 ; i < n ; i++ )
1701 sum += validpixel[i] ;
1703 podata[col + row*ilx] = sum/n ;
1709 return returnImage ;
1721 cpl_image * sinfo_new_stack_row_to_image ( Vector * row,
int ly )
1723 cpl_image * image=NULL;
1728 if ( row == NullVector )
1740 if (NULL == (image = cpl_image_new(row->n_elements ,ly,CPL_TYPE_FLOAT )) )
1745 podata=cpl_image_get_data_float(image);
1747 for ( col = 0 ; col < row -> n_elements ; col++ )
1749 for ( ro = 0 ; ro < ly ; ro++ )
1751 podata[col + ro*ly] = row -> data[col] ;
1773 Stats * sinfo_new_image_stats_on_rectangle ( cpl_image * im,
1781 Stats * retstats=NULL;
1791 float * pix_array=NULL;
1801 if ( loReject+hiReject >= 100. )
1806 if ( loReject < 0. || loReject >= 100. ||
1807 hiReject < 0. || hiReject >= 100. )
1813 im_lx=cpl_image_get_size_x(im);
1814 im_ly=cpl_image_get_size_y(im);
1816 if ( llx < 0 || lly < 0 || urx < 0 || ury < 0 ||
1817 llx >= im_lx || lly >= im_ly || urx >= im_lx ||
1818 ury >= im_ly || ury <= lly || urx <= llx )
1825 retstats = (Stats*) cpl_calloc(1,
sizeof(Stats)) ;
1826 npix = (urx - llx + 1) * (ury - lly + 1) ;
1827 pix_array = (
float*) cpl_calloc ( npix,
sizeof(
float) ) ;
1833 pim = cpl_image_get_data_float(im);
1834 for ( row = lly ; row <= ury ; row++ )
1836 for ( col = llx ; col <= urx ; col++ )
1838 if ( !isnan(pim[col + row*im_lx]) )
1840 pix_array[n] = pim[col + row*im_lx] ;
1857 if ( FLT_MAX == (retstats->cleanmean = sinfo_new_clean_mean(pix_array,
1858 npix, loReject, hiReject)) )
1861 cpl_free(retstats) ;
1862 cpl_free(pix_array) ;
1868 lo_n = (int) (loReject / 100. * (
float)npix) ;
1869 hi_n = (int) (hiReject / 100. * (
float)npix) ;
1873 for ( i = lo_n ; i <= npix - hi_n ; i++ )
1875 pix_sum += (double)pix_array[i] ;
1876 sqr_sum += ((double)pix_array[i] * (
double)pix_array[i]) ;
1883 cpl_free(retstats) ;
1884 cpl_free(pix_array) ;
1887 retstats -> npix = n ;
1888 pix_sum /= (double) n ;
1889 sqr_sum /= (double) n ;
1890 retstats -> cleanstdev = (float)sqrt(sqr_sum - pix_sum * pix_sum) ;
1891 cpl_free (pix_array) ;
1906 cpl_image * sinfo_new_normalize_to_central_pixel ( cpl_image * image )
1914 cpl_image * retImage=NULL;
1920 if ( image == NULL )
1925 ilx=cpl_image_get_size_x(image);
1926 ily=cpl_image_get_size_y(image);
1927 pidata=cpl_image_get_data_float(image);
1929 retImage = cpl_image_duplicate(image) ;
1930 podata=cpl_image_get_data_float(retImage);
1935 array=cpl_calloc(2*ilx,
sizeof(
float)) ;
1937 for ( row = ily/2 ; row < ily/2+1 ; row++ )
1939 for ( col = 0 ; col < ilx ; col++ )
1941 if ( !isnan(pidata[col+ilx*row]) )
1943 array[n] = pidata[col+ilx*row] ;
1950 if ( isnan(divisor = sinfo_new_median(array, n) ) )
1961 for ( i = 0 ; i < (int) ilx*ily ; i++ )
1963 if ( isnan(pidata[i]) )
1969 podata[i] = pidata[i]/divisor ;
2008 sinfo_new_mpe_shift_image(
2009 cpl_image * image_in,
2012 double * interp_kernel)
2014 cpl_image * shifted=NULL ;
2015 pixelvalue * first_pass=NULL ;
2016 pixelvalue * second_pass=NULL ;
2017 int samples = KERNEL_SAMPLES ;
2025 register pixelvalue * pix ;
2026 register pixelvalue * pixint ;
2030 int freeKernel = 1 ;
2039 if (image_in==NULL)
return NULL ;
2042 if ((fabs(shift_x)<1e-2) && (fabs(shift_y)<1e-2))
2043 return cpl_image_duplicate(image_in) ;
2044 ilx=cpl_image_get_size_x(image_in);
2045 ily=cpl_image_get_size_y(image_in);
2046 pidata=cpl_image_get_data_float(image_in);
2050 if (interp_kernel == NULL) {
2051 ker = sinfo_generate_interpolation_kernel(
"default") ;
2057 ker = interp_kernel ;
2061 mid = (int)samples/(
int)2 ;
2062 first_pass = cpl_calloc(ilx, ily*
sizeof(pixelvalue)) ;
2063 shifted = cpl_image_new(ilx, ily,CPL_TYPE_FLOAT) ;
2064 psdata=cpl_image_get_data_float(shifted);
2066 second_pass = psdata ;
2071 for (j=0 ; j<ily ; j++)
2073 for (i=0 ; i<ilx ; i++) {
2074 double fx = (double)i-shift_x ;
2076 double rx = fx - (double)px ;
2077 pos = px + j * ilx ;
2079 if ((px>1) && (px<(ilx-2)))
2081 int tabx = (int)(fabs((
double)mid * rx)) ;
2083 if (isnan(pix[pos]))
2089 if (isnan(pix[pos-1]))
2093 if (isnan(pix[pos+1]))
2097 if (isnan(pix[pos+2]))
2106 value = (double)pix[pos-1] * ker[mid+tabx] +
2107 (
double)pix[pos] * ker[tabx] +
2108 (double)pix[pos+1] * ker[mid-tabx] +
2109 (
double)pix[pos+2] * ker[samples-tabx-1] ;
2114 norm = (
double)ker[mid+tabx] +
2116 (
double)ker[mid-tabx] +
2117 (
double)ker[samples-tabx-1] ;
2118 if (fabs(norm) > 1e-4) {
2131 first_pass[i+j*ilx] = ZERO ;
2135 first_pass[i+j*ilx] = (pixelvalue)value ;
2142 memcpy(first_pass,pix,ily*
sizeof(pixelvalue));
2145 pixint = first_pass ;
2146 for (i=0 ; i<ilx ; i++) {
2147 for (j=0 ; j<ily ; j++) {
2148 double fy = (double)j - shift_y ;
2150 ry = fy - (double)py ;
2151 pos = i + py * ilx ;
2153 taby = (int)(fabs((
double)mid * ry)) ;
2155 if ((py>(
int)1) && (py<(ily-2))) {
2157 if (isnan(pixint[pos]) && ilx != 1 )
2163 if (isnan(pixint[pos-ilx]))
2165 pixint[pos-ilx] = 0. ;
2167 if (isnan(pixint[pos+ilx]))
2169 pixint[pos+ilx] = 0. ;
2171 if (isnan(pixint[pos+2*ilx]))
2173 pixint[pos+2*ilx] = 0. ;
2179 value = (double)pixint[pos-ilx] * ker[mid+taby] +
2180 (
double)pixint[pos] * ker[taby] +
2181 (double)pixint[pos+ilx] * ker[mid-taby] +
2182 (
double)pixint[pos+2*ilx]*ker[samples-taby-1];
2187 norm = (
double)ker[mid+taby] +
2189 (
double)ker[mid-taby] +
2190 (
double)ker[samples-taby-1] ;
2192 if (fabs(norm) > 1e-4) {
2201 second_pass[i+j*ilx] = ZERO ;
2205 second_pass[i+j*ilx] = (pixelvalue)value ;
2210 cpl_free(first_pass) ;
2251 sinfo_new_shift_image_in_cube(
2252 cpl_image * image_in,
2255 double * interp_kernel,
2256 cpl_image * shifted,
2257 pixelvalue * first_pass)
2259 pixelvalue * second_pass=NULL ;
2260 int samples = KERNEL_SAMPLES ;
2265 int tabx=0, taby=0 ;
2268 register pixelvalue * pix ;
2272 int freeKernel = 1 ;
2282 if (image_in==NULL) shifted = NULL ;
2283 pidata=cpl_image_get_data_float(image_in);
2284 ilx=cpl_image_get_size_x(image_in);
2285 ily=cpl_image_get_size_y(image_in);
2287 shifted=cpl_image_new(ilx,ily,CPL_TYPE_FLOAT);
2291 psdata=cpl_image_get_data_float(shifted);
2294 if ((fabs(shift_x)<1e-2) && (fabs(shift_y)<1e-2))
2295 memcpy(psdata,pidata, (
size_t) slx*sly *
sizeof(pixelvalue)) ;
2298 if (interp_kernel == NULL) {
2299 ker = sinfo_generate_interpolation_kernel(
"default") ;
2305 ker = interp_kernel ;
2309 mid = (int)samples/(
int)2 ;
2310 second_pass = psdata ;
2313 for (j=0 ; j<ily ; j++) {
2314 for (i=1 ; i<ilx-2 ; i++) {
2315 fx = (double)i-shift_x ;
2317 rx = fx - (double)px ;
2319 pos = px + j * ilx ;
2321 if ((px>1) && (px<(ilx-2))) {
2322 tabx = (int)(fabs((
double)mid * rx)) ;
2324 if (isnan(pix[pos]))
2330 if (isnan(pix[pos-1]))
2334 if (isnan(pix[pos+1]))
2338 if (isnan(pix[pos+2]))
2347 value = (double)pix[pos-1] * ker[mid+tabx] +
2348 (
double)pix[pos] * ker[tabx] +
2349 (double)pix[pos+1] * ker[mid-tabx] +
2350 (
double)pix[pos+2] * ker[samples-tabx-1] ;
2355 norm = (
double)ker[mid+tabx] +
2357 (
double)ker[mid-tabx] +
2358 (
double)ker[samples-tabx-1] ;
2359 if (fabs(norm) > 1e-4) {
2372 first_pass[i+j*ilx] = ZERO ;
2376 first_pass[i+j*ilx] = (pixelvalue)value ;
2380 register pixelvalue* pixint = first_pass ;
2381 for (i=0 ; i< ilx ; i++) {
2382 for (j=1 ; j< ily-2 ; j++) {
2383 fy = (double)j - shift_y ;
2385 ry = fy - (double)py ;
2386 pos = i + py * ilx ;
2388 taby = (int)(fabs((
double)mid * ry)) ;
2390 if ((py>(
int)1) && (py<(ily-2))) {
2392 if (isnan(pixint[pos]))
2398 if (isnan(pixint[pos-ilx]))
2400 pixint[pos-ilx] = 0. ;
2402 if (isnan(pixint[pos+ilx]))
2404 pixint[pos+ilx] = 0. ;
2406 if (isnan(pixint[pos+2*ilx]))
2408 pixint[pos+2*ilx] = 0. ;
2414 value = (double)pixint[pos-ilx] * ker[mid+taby] +
2415 (
double)pixint[pos] * ker[taby] +
2416 (double)pixint[pos+ilx] * ker[mid-taby] +
2417 (
double)pixint[pos+2*ilx]*ker[samples-taby-1];
2422 norm = (
double)ker[mid+taby] +
2424 (
double)ker[mid-taby] +
2425 (
double)ker[samples-taby-1] ;
2427 if (fabs(norm) > 1e-4) {
2436 second_pass[i+j*ilx] = ZERO ;
2440 second_pass[i+j*ilx] = (pixelvalue)value ;
2450 void sinfo_new_del_Stats( Stats * st)
2463 sinfo_new_combine_masks ( cpl_image * firstMask, cpl_image * secondMask )
2465 cpl_image * retMask=NULL ;
2471 float* pm2data=NULL;
2473 if ( firstMask == NULL || secondMask == NULL )
2478 retMask = cpl_image_duplicate (firstMask) ;
2479 podata = cpl_image_get_data_float(retMask);
2481 pm2data = cpl_image_get_data_float(secondMask);
2482 olx=cpl_image_get_size_x(retMask);
2483 oly=cpl_image_get_size_y(retMask);
2485 for ( n = 0 ; n < (int) olx*oly ; n++ )
2487 if ( podata[n] == 0. || pm2data[n] == 0. )
2508 cpl_image * sinfo_new_slice_cube (cpl_imagelist * cube,
int x,
int y )
2510 cpl_image * retImage=NULL ;
2515 cpl_image* img=NULL;
2524 if ( x > 31 || y > 31 )
2529 img=cpl_imagelist_get(cube,0);
2530 ilx=cpl_image_get_size_x(img);
2531 ily=cpl_image_get_size_y(img);
2532 inp=cpl_imagelist_get_size(cube);
2537 if ( NULL == (retImage = cpl_image_new(ilx, inp, CPL_TYPE_FLOAT)) )
2542 podata=cpl_image_get_data_float(retImage);
2543 for ( z = 0 ; z < inp ; z++ )
2546 pidata=cpl_image_get_data_float(cpl_imagelist_get(cube,z));
2548 for ( col = 0 ; col < ilx ; col++ )
2550 podata[col+z*ilx] = pidata[col+y*ilx] ;
2557 if ( NULL == (retImage = cpl_image_new(ily, inp,CPL_TYPE_FLOAT)) )
2562 podata=cpl_image_get_data_float(retImage);
2564 for ( z = 0 ; z < inp ; z++ )
2566 pidata=cpl_image_get_data_float(cpl_imagelist_get(cube,z));
2568 for ( row = 0 ; row < ily ; row++ )
2570 podata[row+z*ily] = pidata[x+row*ily] ;
2593 cpl_image * sinfo_new_div_images_robust ( cpl_image * im1, cpl_image * im2 )
2595 cpl_image * retIm=NULL ;
2607 if ( im1 == NULL || im2 == NULL )
2612 lx1=cpl_image_get_size_x(im1);
2613 ly1=cpl_image_get_size_y(im1);
2614 lx2=cpl_image_get_size_x(im2);
2615 ly2=cpl_image_get_size_y(im2);
2616 p1data=cpl_image_get_data_float(im1);
2617 p2data=cpl_image_get_data_float(im2);
2619 if ( lx1 != lx2 || ly1 != ly2 )
2624 if ( NULL == (retIm = cpl_image_new(lx1, ly1, CPL_TYPE_FLOAT)) )
2629 podata=cpl_image_get_data_float(retIm);
2631 for ( i = 0 ; i < (int) lx2*ly2 ; i++ )
2633 if ( !isnan(p2data[i]) )
2635 help = 1./p2data[i] ;
2636 if (fabs( help )> THRESH )
2645 if ( isnan(help) || isnan(p1data[i]) )
2651 podata[i] = p1data[i] * help ;
2657 cpl_image * sinfo_new_null_edges ( cpl_image * image)
2659 cpl_image *
new=NULL ;
2671 if ( image == NULL )
2678 new = cpl_image_duplicate (image) ;
2683 olx=cpl_image_get_size_x(
new);
2684 oly=cpl_image_get_size_y(
new);
2686 podata=cpl_image_get_data_float(
new);
2688 for ( i = 0 ; i < olx ; i++ )
2690 for ( j = 0 ; j < 4 ; j++)
2693 podata[i+(oly-j-1)*olx]=0;
2696 for ( i = 0 ; i < oly ; i++ )
2698 for ( j = 0 ; j < 4 ; j++)
2701 podata[(olx-j-1)+i*olx]=0;
2708 void sinfo_new_used_cor_map( cpl_image *im, cpl_image *map)
2710 int i=0,j=0,loc_index=0;
2711 float temp_array[2048];
2712 int lx=cpl_image_get_size_x(im);
2713 int ly=cpl_image_get_size_y(im);
2714 float* pidata=cpl_image_get_data_float(im);
2715 float* pmdata=cpl_image_get_data_float(map);
2717 for( j=0; j<ly; j++)
2721 loc_index = (int)pmdata[i+j*lx];
2722 temp_array[i] = pidata[loc_index+j*lx];
2726 pidata[i+j*lx]= temp_array[i];
2767 sinfo_new_shift_image(
2768 cpl_image * image_in,
2771 double * interp_kernel)
2773 cpl_image * shifted=NULL ;
2776 int samples = KERNEL_SAMPLES ;
2778 int freeKernel = 1 ;
2783 if (image_in==NULL)
return NULL ;
2786 if ((fabs(shift_x)<1e-2) && (fabs(shift_y)<1e-2))
2787 return cpl_image_duplicate(image_in) ;
2790 if (interp_kernel == NULL) {
2791 ker = sinfo_generate_interpolation_kernel(
"default") ;
2797 ker = interp_kernel ;
2801 ilx=cpl_image_get_size_x(image_in);
2802 ily=cpl_image_get_size_y(image_in);
2805 register float* pix = cpl_image_get_data_float(image_in);
2806 float* first_pass=NULL;
2811 int mid = (int)samples/(
int)2 ;
2812 first_pass = cpl_calloc(ilx, ily*
sizeof(
float)) ;
2813 shifted = cpl_image_new(ilx, ily,CPL_TYPE_FLOAT) ;
2814 float* second_pass = cpl_image_get_data_float(shifted);
2818 for (j=0 ; j<ily ; j++) {
2819 for (i=1 ; i<ilx-2 ; i++) {
2820 double fx = (double)i-shift_x ;
2822 double rx = fx - (double)px ;
2824 pos = px + j * ilx ;
2826 if ((px>1) && (px<(ilx-3))) {
2827 int tabx = (int)(fabs((
double)mid * rx)) ;
2832 value = (double)pix[pos-1] * ker[mid+tabx] +
2833 (
double)pix[pos] * ker[tabx] +
2834 (double)pix[pos+1] * ker[mid-tabx] +
2835 (
double)pix[pos+2] * ker[samples-tabx-1] ;
2840 norm = (
double)ker[mid+tabx] +
2842 (
double)ker[mid-tabx] +
2843 (
double)ker[samples-tabx-1] ;
2844 if (fabs(norm) > 1e-4) {
2854 first_pass[i+j*ilx] = (float)value ;
2857 register float* pixint = first_pass ;
2858 for (i=0 ; i<ilx ; i++) {
2859 for (j=1 ; j<ily-3 ; j++) {
2860 double fy = (double)j - shift_y ;
2862 double ry = fy - (double)py ;
2863 pos = i + py * ilx ;
2865 int taby = (int)(fabs((
double)mid * ry)) ;
2867 if ((py>(
int)1) && (py<(ily-2))) {
2872 value = (double)pixint[pos-ilx] * ker[mid+taby] +
2873 (
double)pixint[pos] * ker[taby] +
2874 (double)pixint[pos+ilx] * ker[mid-taby] +
2875 (
double)pixint[pos+2*ilx]*ker[samples-taby-1];
2880 norm = (
double)ker[mid+taby] +
2882 (
double)ker[mid-taby] +
2883 (
double)ker[samples-taby-1] ;
2885 if (fabs(norm) > 1e-4) {
2891 second_pass[i+j*ilx] = (float)value ;
2897 cpl_msg_warning(cpl_func,
"cannot get a data from an image");
2899 cpl_free(first_pass) ;
2923 sinfo_image_hermite_interpol(cpl_image * inp)
2946 cpl_image* out=NULL;
2948 cknull(inp,
"Null in put image, exit");
2949 check_nomsg(out=cpl_image_duplicate(inp));
2950 check_nomsg(sx=cpl_image_get_size_x(inp));
2951 check_nomsg(sy=cpl_image_get_size_y(inp));
2952 check_nomsg(pinp=cpl_image_get_data_float(inp));
2953 check_nomsg(pout=cpl_image_get_data_float(out));
2954 for(j=r;j<sy-r;j++) {
2957 pout[j*sx+i]+=pinp[(j+k)*sx+i];
2965 if(cpl_error_get_code() != CPL_ERROR_NONE) {
2993 sinfo_image_smooth_y(cpl_image * inp,
const int r)
3012 cpl_image* out=NULL;
3014 cknull(inp,
"Null in put image, exit");
3015 check_nomsg(out=cpl_image_duplicate(inp));
3016 check_nomsg(sx=cpl_image_get_size_x(inp));
3017 check_nomsg(sy=cpl_image_get_size_y(inp));
3018 check_nomsg(pinp=cpl_image_get_data_float(inp));
3019 check_nomsg(pout=cpl_image_get_data_float(out));
3020 for(j=r;j<sy-r;j++) {
3023 pout[j*sx+i]+=pinp[(j+k)*sx+i];
3031 if(cpl_error_get_code() != CPL_ERROR_NONE) {
3058 sinfo_image_smooth_mean_y(cpl_image * inp,
const int r)
3077 cpl_image* out=NULL;
3079 cknull(inp,
"Null in put image, exit");
3080 check_nomsg(out=cpl_image_duplicate(inp));
3081 check_nomsg(sx=cpl_image_get_size_x(inp));
3082 check_nomsg(sy=cpl_image_get_size_y(inp));
3083 check_nomsg(pinp=cpl_image_get_data_float(inp));
3084 check_nomsg(pout=cpl_image_get_data_float(out));
3085 for(j=r;j<sy-r;j++) {
3088 pout[j*sx+i]+=pinp[(j+k)*sx+i];
3096 if(cpl_error_get_code() != CPL_ERROR_NONE) {
3123 sinfo_image_smooth_median_y(cpl_image * inp,
const int r)
3140 cpl_image* out=NULL;
3143 cknull(inp,
"Null in put image, exit");
3144 check_nomsg(out=cpl_image_duplicate(inp));
3145 check_nomsg(sx=cpl_image_get_size_x(inp));
3146 check_nomsg(sy=cpl_image_get_size_y(inp));
3147 check_nomsg(pout=cpl_image_get_data_float(out));
3149 for(j=r+1;j<sy-r;j++) {
3151 pout[j*sx+i]=(float)cpl_image_get_median_window(inp,i,j,i,j+r);
3157 if(cpl_error_get_code() != CPL_ERROR_NONE) {
3182 sinfo_image_smooth_fft(cpl_image * inp,
const int fy)
3188 cpl_image* out=NULL;
3189 cpl_image* im_re=NULL;
3190 cpl_image* im_im=NULL;
3191 cpl_image* ifft_re=NULL;
3192 cpl_image* ifft_im=NULL;
3193 cpl_image* filter=NULL;
3198 cknull(inp,
"Null in put image, exit");
3199 check_nomsg(im_re = cpl_image_cast(inp, CPL_TYPE_DOUBLE));
3200 check_nomsg(im_im = cpl_image_cast(inp, CPL_TYPE_DOUBLE));
3203 check_nomsg(cpl_image_fft(im_re,im_im,CPL_FFT_DEFAULT));
3205 check_nomsg(sx=cpl_image_get_size_x(inp));
3206 check_nomsg(sy=cpl_image_get_size_y(inp));
3210 check_nomsg(filter = sinfo_gen_lowpass(sx,sy,sigma_x,sigma_y));
3213 cpl_image_multiply(im_re,filter);
3214 cpl_image_multiply(im_im,filter);
3216 sinfo_free_image(&filter);
3218 check_nomsg(ifft_re = cpl_image_duplicate(im_re));
3219 check_nomsg(ifft_im = cpl_image_duplicate(im_im));
3221 sinfo_free_image(&im_re);
3222 sinfo_free_image(&im_im);
3225 check_nomsg(cpl_image_fft(ifft_re,ifft_im,CPL_FFT_INVERSE));
3226 check_nomsg(out = cpl_image_cast(ifft_re, CPL_TYPE_FLOAT));
3230 sinfo_free_image(&ifft_re);
3231 sinfo_free_image(&ifft_im);
3232 sinfo_free_image(&filter);
3233 sinfo_free_image(&im_re);
3234 sinfo_free_image(&im_im);
3236 if(cpl_error_get_code() != CPL_ERROR_NONE) {
3264 sinfo_gen_lowpass(
const int xs,
3266 const double sigma_x,
3267 const double sigma_y)
3276 double gaussval= 0.0;
3277 double inv_sigma_x=1./sigma_x;
3278 double inv_sigma_y=1./sigma_y;
3282 cpl_image *lowpass_image=NULL;
3285 lowpass_image = cpl_image_new (xs, ys, CPL_TYPE_FLOAT);
3286 if (lowpass_image == NULL) {
3288 cpl_error_get_message());
3295 data = cpl_image_get_data_float(lowpass_image);
3311 for (i=1 ; i<=hlx ; i++) {
3312 x = i * inv_sigma_x;
3313 gaussval = exp(-0.5*x*x);
3315 data[xs-i] = gaussval;
3318 for (j=1; j<=hly ; j++) {
3319 double y = j * inv_sigma_y;
3321 data[j*xs] = exp(-0.5*y*y);
3322 data[(ys-j)*xs] = exp(-0.5*y*y);
3324 for (i=1 ; i<=hlx ; i++) {
3326 x = i * inv_sigma_x;
3327 gaussval = exp (-0.5*(x*x+y*y));
3328 data[j*xs+i] = gaussval;
3329 data[(j+1)*xs-i] = gaussval;
3330 data[(ys-j)*xs+i] = gaussval;
3331 data[(ys+1-j)*xs-i] = gaussval;
3343 return lowpass_image;
3346 static void quicksort_int(
int* data,
int left,
int right)
3350 int pivot = (i + j) / 2;
3351 double index_value = data[pivot];
3354 while(data[i] < index_value) i++;
3355 while(data[j] > index_value) j--;
3371 quicksort_int(data, i, right);
3375 quicksort_int(data, left, j);
#define sinfo_msg_debug(...)
Print a debug message.
#define sinfo_msg_error(...)
Print an error message.
#define sinfo_msg_warning(...)
Print an warning message.