00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #ifdef HAVE_CONFIG_H
00028 #include <config.h>
00029 #endif
00030
00031
00036
00037
00041
00042
00043
00044 #include <string.h>
00045 #include <stdio.h>
00046 #include <xsh_data_pre.h>
00047 #include <xsh_dump.h>
00048 #include <xsh_utils.h>
00049 #include <xsh_error.h>
00050 #include <xsh_msg.h>
00051 #include <xsh_pfits.h>
00052 #include <xsh_dfs.h>
00053 #include <math.h>
00054 #include <time.h>
00055 #include <cpl.h>
00056
00057
00058
00059
00060 static cpl_error_code
00061 xsh_preoverscan_corr(cpl_frame* raw,
00062 const int corr_mode,double* cor_val)
00063 {
00064
00065 const char* fname=NULL;
00066 cpl_image* raw_ima=NULL;
00067 cpl_image* tmp_ima=NULL;
00068
00069 cpl_propertylist* header=NULL;
00070 int ovscx=0;
00071 int ovscy=0;
00072 int prscx=0;
00073 int prscy=0;
00074 int naxis1=0;
00075 int naxis2=0;
00076 double tmp_val=0;
00077
00078
00079 float* ptmp=NULL;
00080 int i=0;
00081 int j=0;
00082 char cor_fname[256];
00083 xsh_msg("Apply pre-overscan correction");
00084 fname=cpl_frame_get_filename(raw);
00085 sprintf(cor_fname,"PREOVER_COR_%s",xsh_get_basename(fname));
00086
00087 header=cpl_propertylist_load(fname,0);
00088
00089 check(raw_ima=cpl_image_load(fname,XSH_PRE_DATA_TYPE, 0, 0));
00090
00091 prscx=xsh_pfits_get_prscx(header);
00092 prscy=xsh_pfits_get_prscy(header);
00093
00094 ovscx=xsh_pfits_get_ovscx(header);
00095 ovscy=xsh_pfits_get_ovscy(header);
00096 naxis1=xsh_pfits_get_naxis1(header);
00097 naxis2=xsh_pfits_get_naxis2(header);
00098 tmp_ima=cpl_image_new(naxis1,naxis2,XSH_PRE_DATA_TYPE);
00099
00100 ptmp=cpl_image_get_data_float(tmp_ima);
00101
00102 switch(corr_mode) {
00103
00104 case 0:
00105 {
00106 *cor_val=0;
00107 break;
00108 }
00109 case 1:
00110 {
00111
00112 *cor_val=cpl_image_get_median_window(raw_ima,
00113 naxis1-ovscx,1,naxis1,naxis2);
00114 xsh_msg("cor_val=%g",*cor_val);
00115 break;
00116 }
00117 case 2:
00118 {
00119
00120 *cor_val=cpl_image_get_median_window(raw_ima,
00121 1,1,ovscx,naxis2);
00122
00123 break;
00124 }
00125 case 3:
00126 {
00127
00128 *cor_val=cpl_image_get_median_window(raw_ima,
00129 naxis1-ovscx,1,naxis1,naxis2);
00130 *cor_val+=cpl_image_get_median_window(raw_ima,
00131 1,1,ovscx,naxis2);
00132 *cor_val*=0.5;
00133
00134 break;
00135 }
00136 case 4:
00137 {
00138
00139
00140
00141
00142
00143
00144
00145 for(j=0;j<naxis2;j++) {
00146 tmp_val=cpl_image_get_median_window(raw_ima,
00147 naxis1-ovscx,j+1,naxis1,j+1);
00148 for(i=0;i<naxis1;i++) {
00149 ptmp[j*naxis1+i]=tmp_val;
00150 }
00151 }
00152 break;
00153 }
00154 case 5:
00155 {
00156
00157 for(j=0;j<naxis2;j++) {
00158 tmp_val=cpl_image_get_median_window(raw_ima,
00159 naxis1-ovscx,j+1,naxis1,j+1);
00160 for(i=0;i<naxis1;i++) {
00161 ptmp[j*naxis1+i]=tmp_val;
00162 }
00163 }
00164 break;
00165 }
00166 case 6:
00167 {
00168
00169
00170
00171 for(j=0;j<naxis2;j++) {
00172 tmp_val=cpl_image_get_median_window(raw_ima,
00173 1,j+1,ovscx,j+1);
00174
00175 tmp_val+=cpl_image_get_median_window(raw_ima,
00176 1,j+1,ovscx,j+1);
00177 for(i=0;i<naxis1;i++) {
00178 ptmp[j*naxis1+i]=tmp_val;
00179 }
00180 }
00181 break;
00182 }
00183 case 7:
00184 {
00185
00186
00187 break;
00188 }
00189 case 8:
00190 {
00191
00192
00193 break;
00194 }
00195 case 9:
00196 {
00197
00198
00199 break;
00200 }
00201 default:
00202 xsh_msg_error("Not supported");
00203 break;
00204 }
00205
00206 if(corr_mode<4) {
00207 cpl_image_subtract_scalar(raw_ima,*cor_val);
00208 } else {
00209 *cor_val=cpl_image_get_median_window(tmp_ima,1,1,naxis1,naxis2);
00210 cpl_image_subtract(raw_ima,tmp_ima);
00211 }
00212 xsh_msg("overscan correction %g",*cor_val);
00213
00214 if(corr_mode > 0 && corr_mode < 4 ) {
00215 if(fabs(*cor_val) < 1.e-6) {
00216 xsh_msg_error("The overscan correction is < 10^-6. Probably you have bad input");
00217 cpl_error_set(cpl_func, CPL_ERROR_ILLEGAL_INPUT);
00218 goto cleanup;
00219 }
00220 }
00221
00222 xsh_pfits_set_bunit(header,XSH_BUNIT_FLUX_REL_C);
00223 check(cpl_image_save(raw_ima,cor_fname,CPL_BPP_IEEE_FLOAT,header,CPL_IO_DEFAULT));
00224 cpl_frame_set_filename(raw,cor_fname);
00225
00226 xsh_add_temporary_file(cor_fname);
00227 cleanup:
00228
00229 xsh_free_image(&raw_ima);
00230 xsh_free_image(&tmp_ima);
00231 xsh_free_propertylist(&header);
00232
00233 return cpl_error_get_code();
00234 }
00235
00236
00237 static double
00238 xsh_compute_ron_nir(const double dit)
00239 {
00240 double ron=0;
00241 const int nsamples=10;
00242 int i=0;
00243 double dit_min=0;
00244 double dit_max=0;
00245 double ron_min=0;
00246 double ron_max=0;
00247 double slope=0;
00248 int i_min=0;
00249
00250
00251 static double dit_samples[10]={2,4,8,16,32,64,128,256,400,1024};
00252
00253
00254 static double ron_samples[10]={21.3,18.4,14.8,11.7,9.0,7.3,6.3,6.2,7.0,9.0};
00255
00256 for(i=0;i<nsamples;i++){
00257 if(dit_samples[i] < dit) i_min=i;
00258 }
00259
00260 dit_min=dit_samples[i_min];
00261 ron_min=ron_samples[i_min];
00262
00263 dit_max=dit_samples[i_min+1];
00264 ron_max=ron_samples[i_min+1];
00265 slope=(ron_max-ron_min)/(dit_max-dit_min);
00266
00267 ron=ron_min+slope*(dit-dit_min);
00268
00269 return ron;
00270
00271 }
00272
00308
00309 static void xsh_pre_init(xsh_pre* pre, cpl_propertylist* header,
00310 xsh_instrument * instrument)
00311 {
00312 XSH_ARM arm;
00313 double dit;
00314
00315 XSH_ASSURE_NOT_NULL( pre);
00316 XSH_ASSURE_NOT_NULL( header);
00317 XSH_ASSURE_NOT_NULL( pre->instrument);
00318
00319
00320 pre->data_header = header;
00321
00322
00323 arm = xsh_pfits_get_arm( pre->data_header);
00324 if ( cpl_error_get_code() != CPL_ERROR_NONE){
00325 xsh_msg_warning("No ARM keyword found put default");
00326 xsh_error_reset();
00327 check( xsh_pfits_set_arm(pre->data_header, instrument));
00328 }
00329 pre->decode_bp = instrument->decode_bp;
00330
00331
00332 check( pre->naxis1 = xsh_pfits_get_naxis1(pre->data_header));
00333 check( pre->naxis2 = xsh_pfits_get_naxis2(pre->data_header));
00334 if(cpl_propertylist_has(pre->data_header,"EXPTIME")) {
00335 check( pre->exptime = xsh_pfits_get_exptime(pre->data_header));
00336 }
00337 if( xsh_instrument_get_arm(pre->instrument) == XSH_ARM_NIR){
00338 check(dit= xsh_pfits_get_dit(pre->data_header)) ;
00339
00340
00341 pre->ron=xsh_compute_ron_nir(dit);
00342
00343 pre->conad=2.12;
00344 pre->gain=1./pre->conad;
00345 }else {
00346 check(pre->ron = xsh_pfits_get_ron(pre->data_header));
00347 check(pre->conad = xsh_pfits_get_conad(pre->data_header));
00348 check(pre->gain = xsh_pfits_get_det_gain(pre->data_header));
00349 }
00350 if( xsh_instrument_get_arm(pre->instrument) == XSH_ARM_NIR){
00351 int chip_ny;
00352
00353
00354 pre->binx = 1;
00355 pre->biny = 1;
00356
00357 check(pre->pszx = xsh_pfits_get_det_pxspace(
00358 pre->data_header));
00359
00360
00361 pre->pszx = pre->pszx * 1000000 ;
00362 pre->pszy = pre->pszx;
00363
00364 check( chip_ny = xsh_pfits_get_chip_ny (pre->data_header));
00365 pre->cutx = XSH_NIR_DEFAULT_CUT;
00366
00367
00368
00369
00370
00371 pre->cuty = XSH_NIR_DEFAULT_CUT_Y;
00372 pre->cutmx = XSH_NIR_DEFAULT_CUT_X;
00373 #if 0
00374 pre->cutmy = (chip_ny / 2) - XSH_NIR_DEFAULT_CUT_Y ;
00375 #else
00376
00377 pre->cutmy = XSH_NIR_DEFAULT_CUT_Y ;
00378 #endif
00379
00380 }
00381 else {
00382 pre->binx = xsh_pfits_get_binx( pre->data_header);
00383 pre->biny = xsh_pfits_get_biny( pre->data_header);
00384 if ( cpl_error_get_code() != CPL_ERROR_NONE){
00385 xsh_msg("WARNING : No binning keywords found. Force binning to 1x1");
00386 pre->binx = 1;
00387 pre->biny = 1;
00388 xsh_error_reset();
00389 }
00390
00391 check(pre->pszx = xsh_pfits_get_pszx(pre->data_header));
00392 check(pre->pszy = xsh_pfits_get_pszy(pre->data_header));
00393
00394 pre->pszx = pre->pszx * pre->binx;
00395 pre->pszy = pre->pszy * pre->biny;
00396
00397
00398
00399
00400
00401
00402
00403 pre->cutmx = xsh_pfits_get_ovscx(pre->data_header);
00404 pre->cutx = xsh_pfits_get_prscx(pre->data_header);
00405 pre->cutmy = xsh_pfits_get_ovscy(pre->data_header);
00406 pre->cuty = xsh_pfits_get_prscy(pre->data_header);
00407 xsh_error_reset();
00408 }
00409
00410 instrument->binx = pre->binx ;
00411 instrument->biny = pre->biny ;
00412
00413 cleanup:
00414
00415 return;
00416 }
00417
00418
00440
00441 xsh_pre* xsh_pre_create(cpl_frame* raw,cpl_frame* bpmap, cpl_image* bias_data,
00442 xsh_instrument* instr,const int pre_overscan_corr)
00443 {
00444 xsh_pre* result = NULL;
00445 const char* framename = NULL;
00446 const char* frame_tag = NULL;
00447 int nextensions = 0;
00448 double median_le = 0.0, median_ri = 0.0, median_up = 0.0, median_do = 0.0;
00449 double stdev_le = 0.0, stdev_ri = 0.0,stdev_up = 0.0, stdev_do = 0.0;
00450 cpl_image *image = NULL;
00451 float* errs = NULL;
00452 float* data = NULL;
00453 int i = 0;
00454 const char *bpfilename = NULL;
00455 cpl_propertylist* bplist = NULL, * data_header = NULL;
00456 int bpnaxis1 = 0,bpnaxis2 =0;
00457 float* pdata=NULL;
00458 int nsat=0;
00459 double frac_sat=0;
00460
00461 float sat_thresh=65535;
00462 double cor_val=0;
00463
00464
00465 XSH_ASSURE_NOT_NULL( raw);
00466 XSH_ASSURE_NOT_NULL( instr);
00467
00468
00469 XSH_CALLOC( result, xsh_pre,1);
00470
00471
00472 result->instrument = instr;
00473 result->decode_bp = instr->decode_bp;
00474
00475 XSH_NEW_PROPERTYLIST( result->errs_header);
00476 check( xsh_pfits_set_extname ( result->errs_header, "ERRS"));
00477 XSH_NEW_PROPERTYLIST( result->qual_header);
00478 check( xsh_pfits_set_extname ( result->qual_header, "QUAL"));
00479
00480
00481 check( framename = cpl_frame_get_filename( raw));
00482 check( result->group = cpl_frame_get_group( raw));
00483 check( frame_tag = cpl_frame_get_tag( raw));
00484
00485
00486 check(nextensions = cpl_frame_get_nextensions(raw));
00487
00488
00489 XSH_ASSURE_NOT_ILLEGAL(nextensions == 0);
00490
00491
00492 check_msg(data_header = cpl_propertylist_load(framename, 0),
00493 "Could not load header of file '%s'", framename);
00494
00495 if(pre_overscan_corr>0) {
00496 check(xsh_preoverscan_corr(raw,pre_overscan_corr,&cor_val));
00497 check( framename = cpl_frame_get_filename( raw));
00498 }
00499 check(xsh_pre_init(result,data_header, instr));
00500
00501
00502 if (strstr( frame_tag, "AFC") != NULL){
00503 check( xsh_pfits_set_dpr_tech ( data_header, XSH_DPR_TECH_SINGLE_PINHOLE));
00504 if ( xsh_instrument_get_arm(instr) != XSH_ARM_NIR){
00505 result->cutmx = 0;
00506 result->cutmy = 0;
00507 result->cutx = 0;
00508 result->cuty = 0;
00509 }
00510 }
00511
00512 result->nx = result->naxis1 - result->cutmx - result->cutx;
00513 result->ny = result->naxis2 - result->cutmy - result->cuty;
00514
00515
00516 if( xsh_instrument_get_arm(instr) == XSH_ARM_NIR){
00517
00518 XSH_ASSURE_NOT_ILLEGAL(result->nx > 0 && result->ny > 0);
00519
00520
00521 check(image = cpl_image_load(framename, XSH_PRE_DATA_TYPE, 0, 0));
00522
00523
00524
00525
00526
00527
00528 xsh_msg_dbg_medium("extracting region [%d,%d:%d,%d]",
00529 result->cutx+1, result->cuty+1,
00530 result->naxis1-XSH_NIR_DEFAULT_CUT,
00531 result->naxis2-result->cutmy-XSH_NIR_DEFAULT_CUT);
00532
00533 check( result->data = cpl_image_extract( image,
00534 result->cutx+1, result->cuty+1,
00535 result->naxis1-XSH_NIR_DEFAULT_CUT,
00536 result->naxis2-result->cutmy-XSH_NIR_DEFAULT_CUT));
00537
00538 check(cpl_image_turn(result->data,1));
00539 result->nx = cpl_image_get_size_x( result->data ) ;
00540 result->ny = cpl_image_get_size_y( result->data ) ;
00541 xsh_msg_dbg_low( "***** NX,NY: %d,%d", result->nx, result->ny ) ;
00542 int nx_ny=result->nx*result->ny;
00543
00544 check(result->errs = cpl_image_duplicate(result->data));
00545 check(errs = cpl_image_get_data_float(result->errs));
00546 check(data = cpl_image_get_data_float(result->data));
00547
00548 for(i = 0; i < nx_ny; i++) {
00549
00550 errs[i] = sqrt(fabs(data[i] * result->conad)
00551 + result->ron * result->ron) / result->conad;
00552 }
00553
00554
00555 pdata=cpl_image_get_data_float(result->data);
00556 for(i=0;i<nx_ny;i++) {
00557 if(pdata[i]>=(sat_thresh-cor_val) || pdata[i]==-cor_val) nsat++;
00558 }
00559 frac_sat=(double)nsat/(nx_ny);
00560
00561
00562 check(xsh_pfits_set_nsat(result->data_header, nsat));
00563 check(xsh_pfits_set_frac_sat(result->data_header, frac_sat));
00564
00565 }
00566
00567 else {
00568 XSH_ASSURE_NOT_ILLEGAL(result->nx > 0 && result->ny > 0);
00569
00570 check(image = cpl_image_load(framename, XSH_PRE_DATA_TYPE, 0, 0));
00571
00572
00573 if (result->cutx > 0) {
00574 check(median_le = cpl_image_get_median_window(image, 1, 1,
00575 result->cutx, result->naxis2));
00576 check(stdev_le = cpl_image_get_stdev_window(image, 1, 1,
00577 result->cutx, result->naxis2));
00578 }
00579 if (result->cuty > 0) {
00580 check(median_do = cpl_image_get_median_window(image, 1, 1,
00581 result->naxis1, result->cuty));
00582 check(stdev_do = cpl_image_get_stdev_window(image, 1, 1,
00583 result->naxis1, result->cuty));
00584 }
00585 if (result->cutmx > 0) {
00586 check(median_ri =cpl_image_get_median_window(image,
00587 result->naxis1 - result->cutmx + 1, 1, result->naxis1,
00588 result->naxis2));
00589 check(stdev_ri = cpl_image_get_stdev_window(image,
00590 result->naxis1 - result->cutmx + 1, 1, result->naxis1,
00591 result->naxis2));
00592 }
00593 if (result->cutmy > 0) {
00594 check(median_up =cpl_image_get_median_window(image, 1,
00595 result->naxis2 - result->cutmy + 1, result->naxis1, result->naxis2));
00596 check(stdev_ri = cpl_image_get_stdev_window(image, 1,
00597 result->naxis2 - result->cutmy + 1, result->naxis1, result->naxis2));
00598 }
00599
00600
00601 check(xsh_pfits_set_bias_left_median(result->data_header, median_le));
00602 check(xsh_pfits_set_bias_right_median(result->data_header, median_ri));
00603 check(xsh_pfits_set_bias_left_stdev(result->data_header, stdev_le));
00604 check(xsh_pfits_set_bias_right_stdev(result->data_header, stdev_ri));
00605 check(xsh_pfits_set_bias_up_median(result->data_header, median_up));
00606 check(xsh_pfits_set_bias_down_median(result->data_header, median_do));
00607 check(xsh_pfits_set_bias_up_stdev(result->data_header, stdev_up));
00608 check(xsh_pfits_set_bias_down_stdev(result->data_header, stdev_do));
00609
00610
00611 check(result->data = cpl_image_extract(image, result->cutx + 1,
00612 result->cuty + 1, result->naxis1 - result->cutmx, result->naxis2 -
00613 result->cutmy));
00614
00615 int nx_ny=result->nx*result->ny;
00616 pdata=cpl_image_get_data_float(result->data);
00617 for(i=0;i<nx_ny;i++) {
00618 if(pdata[i]>=(sat_thresh-cor_val) || pdata[i]==-cor_val) nsat++;
00619 }
00620 frac_sat=(double)nsat/(nx_ny);
00621
00622 if( xsh_instrument_get_arm(instr) == XSH_ARM_UVB){
00623
00624 check( cpl_image_turn(result->data,2));
00625 }
00626 check(xsh_pfits_set_nsat(result->data_header, nsat));
00627 check(xsh_pfits_set_frac_sat(result->data_header, frac_sat));
00628
00629
00630 check( result->errs = cpl_image_duplicate(result->data));
00631 check( errs = cpl_image_get_data_float(result->errs));
00632 check( data = cpl_image_get_data_float(result->data));
00633
00634
00635 if ( (strcmp(frame_tag, XSH_BIAS_UVB) == 0) ||
00636 (strcmp(frame_tag, XSH_BIAS_VIS) == 0) ){
00637
00638
00639 float ron_div_conad = result->ron / result->conad;
00640
00641 for(i = 0; i < nx_ny; i++) {
00642 errs[i] = ron_div_conad;
00643 }
00644
00645 }
00646 else if ( (strcmp(frame_tag, XSH_RAW_IMA_SLIT_UVB) == 0) ||
00647 (strcmp(frame_tag, XSH_RAW_IMA_SLIT_VIS) == 0) ){
00648
00649
00650 float ron_div_conad = result->ron / result->conad;
00651
00652 for(i = 0; i < nx_ny; i++) {
00653 errs[i] = ron_div_conad;
00654 }
00655
00656 }
00657
00658 else if ( (strcmp(frame_tag, XSH_LINEARITY_UVB) == 0) ||
00659 (strcmp(frame_tag, XSH_LINEARITY_VIS) == 0) ||
00660 (strcmp(frame_tag, XSH_RAW_BP_MAP_NL_UVB) == 0) ||
00661 (strcmp(frame_tag, XSH_RAW_BP_MAP_NL_VIS) == 0) ||
00662 (strcmp(frame_tag, XSH_BP_MAP_NL_UVB) == 0) ||
00663 (strcmp(frame_tag, XSH_BP_MAP_NL_VIS) == 0) ){
00664
00665 for(i = 0; i < nx_ny; i++) {
00666 errs[i] = 0;
00667 }
00668 }
00669 else {
00670
00671 int bias_x, bias_y;
00672 float* mbias_data = NULL;
00673 int nx_ny=result->nx*result->ny;
00674 if ( bias_data == (cpl_image *)-1 ) {
00675 xsh_msg( "No BIAS, just a Test" ) ;
00676 for ( i = 0 ; i < nx_ny; i++) {
00677 errs[i] = 0;
00678 }
00679 }
00680 else {
00681 XSH_ASSURE_NOT_NULL( bias_data);
00682 check( bias_x = cpl_image_get_size_x( bias_data));
00683 check( bias_y = cpl_image_get_size_y( bias_data));
00684 xsh_msg_dbg_medium("bias_x=%d nx=%d bias_y=%d ny=%d",
00685 bias_x,result->nx,bias_y,result->ny);
00686 XSH_ASSURE_NOT_ILLEGAL_MSG( bias_x == result->nx,
00687 "Master bias X size different from raw frame X size. Input image frames must match in arm and bin!");
00688 XSH_ASSURE_NOT_ILLEGAL_MSG( bias_y == result->ny,
00689 "Master bias Y size different from raw frame Y size. Input image frames must match in arm and bin!");
00690 double ron2=result->ron * result->ron;
00691 if(pre_overscan_corr==0) {
00692 check( mbias_data = cpl_image_get_data_float( bias_data));
00693
00694 for(i = 0; i < nx_ny; i++) {
00695
00696 errs[i] = sqrt( fabs( data[i] - mbias_data[i])
00697 * result->conad + ron2)
00698 / result->conad;
00699 }
00700 } else {
00701 for(i = 0; i < nx_ny; i++) {
00702
00703 errs[i] = sqrt( fabs( data[i])
00704 * result->conad + ron2)
00705 / result->conad;
00706 }
00707 }
00708 }
00709 }
00710 }
00711
00712
00713
00714 if (bpmap == NULL) {
00715 xsh_msg("No input BP map provided");
00716 check(result->qual = cpl_image_new(result->nx, result->ny,
00717 XSH_PRE_QUAL_TYPE));
00718
00719 }
00720 else {
00721 check(bpfilename = cpl_frame_get_filename(bpmap));
00722 xsh_msg("Use Bad pixel map file %s\n",bpfilename);
00723 check(bplist = cpl_propertylist_load(bpfilename, 0));
00724
00725 check(bpnaxis1 = xsh_pfits_get_naxis1(bplist));
00726 check(bpnaxis2 = xsh_pfits_get_naxis2(bplist));
00727 assure(bpnaxis1 == result->nx && bpnaxis2 == result->ny,
00728 CPL_ERROR_ILLEGAL_INPUT,"qual image %d %d must have same size of data\
00729 image %d %d",bpnaxis1,bpnaxis2,result->nx,result->ny);
00730 check(result->qual = cpl_image_load(bpfilename, XSH_PRE_QUAL_TYPE, 0, 0));
00731 check(xsh_image_flag_bp(result->data,result->qual,instr));
00732 }
00733 check(xsh_badpixelmap_flag_saturated_pixels(result,instr));
00734 cleanup:
00735 if (cpl_error_get_code () != CPL_ERROR_NONE) {
00736 xsh_pre_free (&result);
00737 result = NULL;
00738 }
00739 xsh_free_image(&image);
00740 xsh_free_propertylist(&bplist);
00741
00742 return result;
00743 }
00744
00745
00751
00752 void xsh_pre_free(xsh_pre** pre)
00753 {
00754 if (pre && *pre) {
00755 xsh_free_image(&((*pre)->data));
00756 xsh_free_propertylist(&((*pre)->data_header));
00757 xsh_free_image(&((*pre)->errs));
00758 xsh_free_propertylist(&((*pre)->errs_header));
00759 xsh_free_image(&((*pre)->qual));
00760 xsh_free_propertylist(&((*pre)->qual_header));
00761 cpl_free(*pre);
00762 *pre = NULL;
00763 }
00764 }
00765
00766
00777
00778 xsh_pre* xsh_pre_load (cpl_frame * frame, xsh_instrument* instr)
00779 {
00780
00781 xsh_pre * result = NULL;
00782
00783 const char *filename = NULL;
00784 int extension = 0;
00785 cpl_propertylist* data_header = NULL;
00786
00787
00788
00789 XSH_ASSURE_NOT_NULL(frame);
00790 XSH_ASSURE_NOT_NULL(instr);
00791 XSH_ASSURE_NOT_NULL(cpl_frame_get_tag (frame));
00792 check (filename = cpl_frame_get_filename (frame));
00793
00794 XSH_CALLOC(result, xsh_pre,1);
00795
00796 result->instrument = instr;
00797 check(result->group = cpl_frame_get_group(frame));
00798
00799
00800 XSH_ASSURE_NOT_ILLEGAL(cpl_frame_get_nextensions(frame) == 2);
00801
00802
00803 extension = 0;
00804 check_msg (data_header = cpl_propertylist_load (filename,extension),
00805 "Cannot read the FITS header from '%s' extension %d",
00806 filename, extension);
00807 check(xsh_pre_init(result,data_header, instr));
00808
00809 result->nx = result->naxis1;
00810 result->ny = result->naxis2;
00811 result->decode_bp = instr->decode_bp;
00812
00813
00814 check_msg (result->data = cpl_image_load (filename,XSH_PRE_DATA_TYPE,0,0),
00815 "Error loading image from %s extension 0", filename);
00816
00817
00818 check_msg (result->errs_header = cpl_propertylist_load (filename,1),
00819 "Cannot read the FITS header from '%s' extension 1",filename);
00820 assure(strcmp(xsh_pfits_get_extname(result->errs_header),"ERRS") == 0,
00821 CPL_ERROR_ILLEGAL_INPUT,"extension 1 must be a errs extension");
00822 check_msg (result->errs = cpl_image_load (filename, XSH_PRE_ERRS_TYPE,0,1),
00823 "Error loading image from %s extension 1", filename);
00824
00825 check_msg (result->qual_header = cpl_propertylist_load (filename,2),
00826 "Cannot read the FITS header from '%s' extension 2",filename);
00827 assure(strcmp("QUAL",xsh_pfits_get_extname (result->qual_header)) == 0,
00828 CPL_ERROR_ILLEGAL_INPUT,"extension 2 must be a qual extension");
00829 check_msg (result->qual = cpl_image_load (filename, XSH_PRE_QUAL_TYPE,0,2),
00830 "Error loading image from %s extension 2", filename);
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865
00866
00867 cleanup:
00868 if (cpl_error_get_code () != CPL_ERROR_NONE) {
00869 xsh_error_msg("can't load frame %s",cpl_frame_get_filename(frame));
00870 xsh_pre_free(&result);
00871 }
00872 return result;
00873 }
00874
00875
00881
00882 xsh_pre * xsh_pre_duplicate (const xsh_pre * pre)
00883 {
00884 xsh_pre *result = NULL;
00885
00886 assure(pre != NULL, CPL_ERROR_NULL_INPUT, "Null PRE");
00887
00888
00889 result = (xsh_pre*)(cpl_malloc (sizeof (xsh_pre)));
00890 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
00891 "Memory allocation failed!");
00892
00893
00894 result->data = NULL;
00895 result->data_header = NULL;
00896 result->errs = NULL;
00897 result->errs_header = NULL;
00898 result->qual = NULL;
00899 result->qual_header = NULL;
00900 result->instrument = pre->instrument;
00901
00902
00903 check(result->nx = xsh_pre_get_nx(pre));
00904 check(result->ny = xsh_pre_get_ny(pre));
00905 check(result->group = xsh_pre_get_group(pre));
00906 result->pszx = pre->pszx;
00907 result->pszy = pre->pszy;
00908 result->gain = pre->gain;
00909 result->exptime = pre->exptime;
00910
00911 check_msg(result->data_header = cpl_propertylist_duplicate(
00912 pre->data_header),"can't copy data header");
00913 check_msg(result->data = cpl_image_duplicate(pre->data),
00914 "can't copy data image");
00915
00916
00917 check_msg(result->errs_header = cpl_propertylist_duplicate(
00918 pre->errs_header),"can't copy errs header");
00919 check_msg(result->errs = cpl_image_duplicate(pre->errs),
00920 "can't copy errs image");
00921
00922
00923 check_msg(result->qual_header = cpl_propertylist_duplicate(
00924 pre->qual_header),"can't copy qual header");
00925
00926 check_msg(result->qual = cpl_image_duplicate(pre->qual),
00927 "can't copy qual image");
00928 result->decode_bp = pre->decode_bp;
00929
00930 cleanup:
00931 if (cpl_error_get_code () != CPL_ERROR_NONE) {
00932 xsh_pre_free(&result);
00933 result = NULL;
00934 }
00935 return result;
00936 }
00937
00938
00947
00948 cpl_frame* xsh_pre_save (const xsh_pre * pre,
00949 const char *filename,
00950 const char *tag,
00951 int temp )
00952 {
00953 cpl_frame *product_frame = NULL;
00954
00955 XSH_ASSURE_NOT_NULL(pre);
00956 XSH_ASSURE_NOT_NULL(filename);
00957
00958
00959 xsh_pfits_set_bunit(pre->data_header,XSH_BUNIT_FLUX_REL_C);
00960 xsh_pfits_set_bunit(pre->errs_header,XSH_BUNIT_FLUX_REL_C);
00961
00962 check( xsh_pfits_set_pcatg( pre->data_header,tag));
00963 check_msg (cpl_image_save (pre->data, filename, XSH_PRE_DATA_BPP,
00964 pre->data_header, CPL_IO_DEFAULT),
00965 "Could not save data to %s extension 0", filename);
00966 check_msg (cpl_image_save (pre->errs, filename, XSH_PRE_ERRS_BPP,
00967 pre->errs_header, CPL_IO_EXTEND),
00968 "Could not save errs to %s extension 1", filename);
00969 check_msg (cpl_image_save (pre->qual, filename, XSH_PRE_QUAL_BPP,
00970 pre->qual_header, CPL_IO_EXTEND),
00971 "Could not save qual to %s extension 2", filename);
00972
00973 product_frame = cpl_frame_new ();
00974 XSH_ASSURE_NOT_NULL( product_frame);
00975
00976 check ((cpl_frame_set_filename (product_frame, filename),
00977 cpl_frame_set_tag(product_frame,tag),
00978 cpl_frame_set_type (product_frame, CPL_FRAME_TYPE_IMAGE),
00979 cpl_frame_set_group (product_frame, xsh_pre_get_group(pre)) )) ;
00980
00981
00982 if ( temp != 0 ) {
00983 check( cpl_frame_set_level(product_frame,
00984 CPL_FRAME_LEVEL_TEMPORARY));
00985 xsh_add_temporary_file( filename ) ;
00986 }
00987
00988
00989 cleanup:
00990 if (cpl_error_get_code () != CPL_ERROR_NONE) {
00991 xsh_free_frame(&product_frame);
00992 product_frame = NULL;
00993 }
00994 return product_frame;
00995 }
00996
00997
01009
01010
01011 cpl_frame*
01012 xsh_pre_save_product(xsh_pre *pre,
01013 cpl_frame* frame,
01014 cpl_frameset* frameset,
01015 const cpl_parameterlist* parameters,
01016 const char* recipe_id,
01017 const char *prefix)
01018 {
01019 cpl_frame* result = NULL;
01020 char filename[256];
01021 time_t now ;
01022 char* date = NULL;
01023 const char* tag=NULL;
01024
01025 XSH_ASSURE_NOT_NULL( pre);
01026 XSH_ASSURE_NOT_NULL( frame);
01027 XSH_ASSURE_NOT_NULL( parameters);
01028 XSH_ASSURE_NOT_NULL( recipe_id);
01029 XSH_ASSURE_NOT_NULL( pre->instrument);
01030
01031
01032 check( cpl_frame_set_group (frame, CPL_FRAME_GROUP_PRODUCT));
01033 #if defined CPL_VERSION_CODE && CPL_VERSION_CODE >= CPL_VERSION(4, 8, 0)
01034 check (cpl_dfs_setup_product_header (pre->data_header,
01035 frame, frameset, parameters,
01036 recipe_id, pre->instrument->pipeline_id,
01037 pre->instrument->dictionary,NULL));
01038 #else
01039 check (cpl_dfs_setup_product_header (pre->data_header,
01040 frame, frameset, parameters,
01041 recipe_id, pre->instrument->pipeline_id,
01042 pre->instrument->dictionary));
01043 #endif
01044
01045 if ( prefix == NULL ) {
01046 sprintf(filename,"PRODUCT_%s",cpl_frame_get_filename (frame));
01047 }
01048 else if ( xsh_time_stamp_get() ) {
01049 time( &now ) ;
01050 date = xsh_sdate_utc(&now);
01051 sprintf( filename, "%s_%dx%d_%s.fits", prefix, pre->binx, pre->biny,
01052 date);
01053 }
01054 else
01055 sprintf( filename, "%s_%dx%d.fits", prefix, pre->binx, pre->biny );
01056 check(tag=xsh_pfits_get_pcatg(pre->data_header));
01057 check(result = xsh_pre_save(pre, filename, tag,0));
01058
01059 cpl_frame_set_type (result, CPL_FRAME_TYPE_IMAGE),
01060 cpl_frame_set_group (result, CPL_FRAME_GROUP_PRODUCT),
01061 cpl_frame_set_level (result, CPL_FRAME_LEVEL_FINAL);
01062 cleanup:
01063 if (cpl_error_get_code () != CPL_ERROR_NONE) {
01064 xsh_free_frame(&result);
01065 result = NULL;
01066 }
01067 XSH_FREE( date ) ;
01068
01069 return result;
01070 }
01071
01072
01085
01086 xsh_pre* xsh_pre_new (int nx, int ny)
01087 {
01088 xsh_pre *result = NULL;
01089
01090 assure (nx > 0 && ny > 0, CPL_ERROR_ILLEGAL_INPUT,
01091 "Illegal image size: %dx%d", nx, ny);
01092
01093 XSH_CALLOC( result, xsh_pre, 1);
01094
01095 result->nx = nx;
01096 result->ny = ny;
01097
01098 check( result->data = cpl_image_new (nx, ny, XSH_PRE_DATA_TYPE));
01099 check( result->errs = cpl_image_new (nx, ny, XSH_PRE_ERRS_TYPE));
01100 check( result->qual = cpl_image_new (nx, ny, XSH_PRE_QUAL_TYPE));
01101 check( result->data_header = cpl_propertylist_new());
01102 check( result->errs_header = cpl_propertylist_new());
01103 check( result->qual_header = cpl_propertylist_new());
01104
01105 cleanup:
01106 if (cpl_error_get_code () != CPL_ERROR_NONE) {
01107 xsh_pre_free ( &result);
01108 result = NULL;
01109 }
01110 return result;
01111 }
01112
01113
01119
01120 int xsh_pre_get_nx (const xsh_pre * pre)
01121 {
01122 int result = 0;
01123
01124 XSH_ASSURE_NOT_NULL( pre );
01125 result = pre->nx;
01126
01127 cleanup:
01128 return result;
01129 }
01130
01131
01137
01138 int xsh_pre_get_ny (const xsh_pre * pre)
01139 {
01140 int result = 0;
01141
01142 XSH_ASSURE_NOT_NULL( pre );
01143 result = pre->ny;
01144
01145 cleanup:
01146 return result;
01147 }
01148
01149
01150
01156
01157 int xsh_pre_get_binx (const xsh_pre * pre)
01158 {
01159 int result = 0;
01160
01161 XSH_ASSURE_NOT_NULL( pre );
01162 result = pre->binx;
01163
01164 cleanup:
01165 return result;
01166 }
01167
01168
01174
01175 int xsh_pre_get_biny (const xsh_pre * pre)
01176 {
01177 int result = 0;
01178
01179 XSH_ASSURE_NOT_NULL( pre );
01180 result = pre->biny;
01181
01182 cleanup:
01183 return result;
01184 }
01185
01186
01192
01193 float xsh_pre_get_pszx (const xsh_pre * pre)
01194 {
01195 float result = 0.0;
01196 assure (pre != NULL, CPL_ERROR_NULL_INPUT, "Null PRE");
01197 result = pre->pszx;
01198
01199 cleanup:
01200 return result;
01201 }
01202
01203
01212
01213
01214 void xsh_pre_from_raw_get(xsh_pre* pre, double raw_x, double raw_y,
01215 double* x, double* y)
01216 {
01217
01218 XSH_ASSURE_NOT_NULL(pre);
01219 XSH_ASSURE_NOT_NULL(x);
01220 XSH_ASSURE_NOT_NULL(y);
01221
01222
01223
01224
01225
01226
01227 if( xsh_instrument_get_arm(pre->instrument) == XSH_ARM_NIR){
01229 *x = raw_y ;
01230 *y = pre->ny + pre->cutx - raw_x;
01231 }
01232 else{
01233 *x = raw_x - pre->cutx;
01234 *y = raw_y - pre->cuty;
01235 }
01236
01237 cleanup:
01238 return;
01239 }
01240
01241
01247
01248 float xsh_pre_get_pszy (const xsh_pre * pre)
01249 {
01250 float result = 0.0;
01251
01252 XSH_ASSURE_NOT_NULL(pre);
01253 result = pre->pszy;
01254
01255 cleanup:
01256 return result;
01257 }
01258
01259
01265
01266 float xsh_pre_get_gain (const xsh_pre * pre)
01267 {
01268 float result = 0.0;
01269
01270 XSH_ASSURE_NOT_NULL(pre);
01271 result = pre->gain;
01272
01273 cleanup:
01274 return result;
01275 }
01276
01282
01283 cpl_frame_group xsh_pre_get_group (const xsh_pre * pre)
01284 {
01285 cpl_frame_group result = CPL_FRAME_GROUP_NONE;
01286
01287 XSH_ASSURE_NOT_NULL(pre);
01288 result = pre->group;
01289
01290 cleanup:
01291 return result;
01292 }
01293
01299
01300 cpl_mask* xsh_pre_get_bpmap(const xsh_pre * pre) {
01301 int* qual = NULL;
01302 cpl_mask* mask = NULL;
01303 cpl_binary* binary = NULL;
01304 int nx_ny = 0;
01305 int i = 0;
01306
01307 XSH_ASSURE_NOT_NULL(pre);
01308
01309 check(mask = cpl_image_get_bpm(pre->qual));
01310 check(qual = cpl_image_get_data_int(pre->qual));
01311 check(binary = cpl_mask_get_data(mask));
01312 nx_ny = pre->nx * pre->ny;
01313 for (i = 0; i < nx_ny; i++) {
01314 if ( (qual[i] & pre->decode_bp) > 0 ) {
01315
01316 binary[i] = CPL_BINARY_1;
01317 }
01318 }
01319
01320 cleanup: return mask;
01321 }
01322
01323
01343
01344
01345 void xsh_pre_add (xsh_pre* self, const xsh_pre * right)
01346 {
01347 float* errs1 = NULL;
01348 float* errs2 = NULL;
01349 int i = 0;
01350 cpl_mask* mask = NULL;
01351 cpl_binary* binary =NULL;
01352 int* qual = NULL;
01353
01354 XSH_ASSURE_NOT_NULL(self);
01355 XSH_ASSURE_NOT_NULL(right);
01356
01357
01358 assure (xsh_pre_get_nx (self) == xsh_pre_get_nx (right) &&
01359 xsh_pre_get_ny (self) == xsh_pre_get_ny (right),
01360 CPL_ERROR_INCOMPATIBLE_INPUT,
01361 "Image sizes don't match: %dx%d and %dx%d",
01362 xsh_pre_get_nx (self), xsh_pre_get_ny (self),
01363 xsh_pre_get_nx (right), xsh_pre_get_ny (right));
01364
01365
01366 check (cpl_image_add(self->data, right->data));
01367
01368
01369 check(errs1 = cpl_image_get_data_float(self->errs));
01370 check(errs2 = cpl_image_get_data_float(right->errs));
01371
01372 for(i=0;i< self->nx*self->ny; i++){
01373 errs1[i] = sqrt(pow(errs1[i],2)+pow(errs2[i],2));
01374 }
01375
01376
01377
01378
01379 if( (xsh_pre_get_group(right) == CPL_FRAME_GROUP_CALIB) ){
01380
01381 check( mask = xsh_pre_get_bpmap(right));
01382 check(binary = cpl_mask_get_data(mask));
01383 check(qual = cpl_image_get_data_int(self->qual));
01384 for(i=0;i<self->nx*self->ny;i++){
01385 if (binary[i]){
01386 qual[i] |= QFLAG_CALIB_FILE_DEFECT;
01387 }
01388 }
01389 }
01390
01391 else {
01392
01393
01394
01395
01396 xsh_badpixelmap_or( self, right ) ;
01397 }
01398 cleanup:
01399 return;
01400 }
01401
01402
01419 cpl_frameset* xsh_pre_frameset_subtract_frame( cpl_frameset *set,
01420 cpl_frame *sub,
01421 const char* spec,
01422 xsh_instrument *instr )
01423 {
01424 int i=0;
01425 int size=0;
01426
01427 cpl_frame* frm=NULL;
01428 cpl_frame* cor=NULL;
01429 cpl_frameset* result=NULL;
01430 char filename[80];
01431 const char * name=NULL;
01432 size=cpl_frameset_get_size(set);
01433 result=cpl_frameset_new();
01434 for(i=0;i<size;i++) {
01435 frm=cpl_frameset_get_frame(set,i);
01436 name=cpl_frame_get_filename(frm);
01437 sprintf(filename,"SUB_%s_%d_%s",spec,i,name);
01438 cor=xsh_pre_frame_subtract(frm,sub,filename,instr,0);
01439 cpl_frameset_insert(result,cor);
01440 }
01441
01442 return result;
01443
01444 }
01445
01446
01463 cpl_frame*
01464 xsh_pre_frame_subtract( cpl_frame *one,
01465 cpl_frame *two,
01466 const char *filename,
01467 xsh_instrument *instr,
01468 const int clean_tmp)
01469 {
01470 xsh_pre * pre1 = NULL ;
01471 xsh_pre * pre2 = NULL ;
01472 xsh_pre * pre_result = NULL ;
01473 cpl_frame * result = NULL ;
01474 const char* tag=NULL;
01475
01476
01477 XSH_ASSURE_NOT_NULL ( one);
01478 XSH_ASSURE_NOT_NULL ( two);
01479 XSH_ASSURE_NOT_NULL ( filename);
01480 XSH_ASSURE_NOT_NULL ( instr);
01481
01482
01483 check ( pre1 = xsh_pre_load( one, instr));
01484 check ( pre2 = xsh_pre_load( two, instr));
01485
01486
01487 check( pre_result = xsh_pre_duplicate( pre1));
01488 check ( xsh_pre_subtract( pre_result, pre2));
01489
01490 check(tag=cpl_frame_get_tag(one));
01491
01492 check( result = xsh_pre_save( pre_result, filename,tag,0));
01493
01494
01495 check ((cpl_frame_set_filename (result, filename),
01496 cpl_frame_set_type (result, CPL_FRAME_TYPE_IMAGE),
01497 cpl_frame_set_group (result, xsh_pre_get_group(pre_result)),
01498 cpl_frame_set_level (result, CPL_FRAME_LEVEL_TEMPORARY),
01499 cpl_frame_set_tag( result,tag)));
01500 if(clean_tmp) {
01501 xsh_add_temporary_file( filename ) ;
01502 }
01503 cleanup:
01504 xsh_pre_free( &pre1);
01505 xsh_pre_free( &pre2);
01506 xsh_pre_free( &pre_result);
01507 return result;
01508 }
01509
01510
01523
01524
01525 void xsh_pre_subtract (xsh_pre* self, const xsh_pre * right)
01526 {
01527
01528 float* errs1 = NULL;
01529 float* errs2 = NULL;
01530 int i = 0;
01531 cpl_mask* mask = NULL;
01532 cpl_binary* binary =NULL;
01533 int* qual = NULL;
01534
01535
01536 XSH_ASSURE_NOT_NULL( self);
01537 XSH_ASSURE_NOT_NULL( right);
01538
01539
01540 assure (xsh_pre_get_nx (self) == xsh_pre_get_nx (right) &&
01541 xsh_pre_get_ny (self) == xsh_pre_get_ny (right),
01542 CPL_ERROR_INCOMPATIBLE_INPUT,
01543 "Image sizes don't match: %dx%d and %dx%d",
01544 xsh_pre_get_nx (self), xsh_pre_get_ny (self),
01545 xsh_pre_get_nx (right), xsh_pre_get_ny (right));
01546
01547
01548 check ( cpl_image_subtract( self->data, right->data));
01549
01550
01551 check( errs1 = cpl_image_get_data_float( self->errs));
01552 check( errs2 = cpl_image_get_data_float( right->errs));
01553
01554 for(i=0;i< self->nx*self->ny; i++){
01555 errs1[i] = sqrt(pow(errs1[i],2)+pow(errs2[i],2));
01556 }
01557
01558
01559 if( (xsh_pre_get_group(right) == CPL_FRAME_GROUP_CALIB) ){
01560 check( mask = xsh_pre_get_bpmap(right));
01561 check(binary = cpl_mask_get_data(mask));
01562 check(qual = cpl_image_get_data_int(self->qual));
01563 for(i=0;i<self->nx*self->ny;i++){
01564 if ( (binary[i] & self->decode_bp) > 0 ){
01565
01566 qual[i] |= QFLAG_CALIB_FILE_DEFECT;
01567 }
01568 }
01569 }
01570 else {
01571
01572 xsh_badpixelmap_or( self, right ) ;
01573 }
01574
01575 cleanup:
01576 return ;
01577 }
01578
01579
01599
01600 void xsh_pre_divide (xsh_pre* self, const xsh_pre * right, double threshold)
01601 {
01602
01603 float *errs1 = NULL;
01604 float *errs2 = NULL;
01605 float *data1 = NULL;
01606 float *data2 = NULL;
01607 int *qual1 = NULL;
01608 int *qual2 = NULL;
01609 int i = 0;
01610 int nx_ny=0;
01611 assure (self != NULL, CPL_ERROR_NULL_INPUT, "Null image!");
01612 assure (right != NULL, CPL_ERROR_NULL_INPUT, "Null image!");
01613
01614
01615 assure (xsh_pre_get_nx (self) == xsh_pre_get_nx (right) &&
01616 xsh_pre_get_ny (self) == xsh_pre_get_ny (right),
01617 CPL_ERROR_INCOMPATIBLE_INPUT,
01618 "Image sizes don't match: %dx%d and %dx%d",
01619 xsh_pre_get_nx (self), xsh_pre_get_ny (self),
01620 xsh_pre_get_nx (right), xsh_pre_get_ny (right));
01621
01622
01623
01624 check(data1 = cpl_image_get_data_float(self->data));
01625 check(data2 = cpl_image_get_data_float(right->data));
01626 check(errs1 = cpl_image_get_data_float(self->errs));
01627 check(errs2 = cpl_image_get_data_float(right->errs));
01628 check(qual1 = cpl_image_get_data_int(self->qual));
01629 check(qual2 = cpl_image_get_data_int(right->qual));
01630 nx_ny=self->nx*self->ny;
01631 for(i=0;i< nx_ny; i++){
01632
01633 if ( (qual2[i] & self->decode_bp) > 0 ) {
01634
01635 if( (xsh_pre_get_group(right) == CPL_FRAME_GROUP_CALIB) ){
01636 qual1[i] |= QFLAG_CALIB_FILE_DEFECT;
01637 }
01638 else {
01639 qual1[i] |= qual2[i];
01640 }
01641 }
01642 else if ( fabs(data2[i]) < threshold){
01643 qual1[i] |= QFLAG_DIVISOR_ZERO;
01644 errs1[i] = 1;
01645 data1[i] = 0;
01646 }
01647 else {
01648 double d1 = 0.0, d2 = 0.0;
01649 double e1 = 0.0, e2 =0.0;
01650 double error = 0.0;
01651
01652 d1 = data1[i];
01653 d2 = data2[i];
01654 e1 = errs1[i];
01655 e2 = errs2[i];
01656 error = fabs( 1.0/d2) * sqrt( (e1*e1) + (e2*e2*d1*d1)/(d2*d2) );
01657 errs1[i] = (float) error;
01658 data1[i] = (float)(d1/d2);
01659 }
01660 }
01661
01662 cleanup:
01663 return;
01664 }
01665
01666
01686
01687 void xsh_pre_multiply (xsh_pre* self, const xsh_pre * right, double threshold)
01688 {
01689
01690 float *errs1 = NULL;
01691 float *errs2 = NULL;
01692 float *data1 = NULL;
01693 float *data2 = NULL;
01694 int *qual1 = NULL;
01695 int *qual2 = NULL;
01696 int i = 0;
01697 int nx_ny=0;
01698 assure (self != NULL, CPL_ERROR_NULL_INPUT, "Null image!");
01699 assure (right != NULL, CPL_ERROR_NULL_INPUT, "Null image!");
01700
01701
01702 assure (xsh_pre_get_nx (self) == xsh_pre_get_nx (right) &&
01703 xsh_pre_get_ny (self) == xsh_pre_get_ny (right),
01704 CPL_ERROR_INCOMPATIBLE_INPUT,
01705 "Image sizes don't match: %dx%d and %dx%d",
01706 xsh_pre_get_nx (self), xsh_pre_get_ny (self),
01707 xsh_pre_get_nx (right), xsh_pre_get_ny (right));
01708
01709
01710
01711 check(data1 = cpl_image_get_data_float(self->data));
01712 check(data2 = cpl_image_get_data_float(right->data));
01713 check(errs1 = cpl_image_get_data_float(self->errs));
01714 check(errs2 = cpl_image_get_data_float(right->errs));
01715 check(qual1 = cpl_image_get_data_int(self->qual));
01716 check(qual2 = cpl_image_get_data_int(right->qual));
01717 nx_ny=self->nx*self->ny;
01718 for(i=0;i< nx_ny; i++){
01719
01720 if ( (qual2[i] & self->decode_bp) > 0 ) {
01721
01722 if( (xsh_pre_get_group(right) == CPL_FRAME_GROUP_CALIB) ){
01723 qual1[i] |= QFLAG_CALIB_FILE_DEFECT;
01724 }
01725 else {
01726 qual1[i] |= qual2[i];
01727 }
01728 }
01729 else if ( fabs(data2[i]) > threshold){
01730 qual1[i] |= QFLAG_OUTSIDE_DATA_RANGE;
01731 errs1[i] = 1;
01732 data1[i] = 0;
01733 }
01734 else {
01735 double d1 = 0.0, d2 = 0.0;
01736 double e1 = 0.0, e2 =0.0;
01737 double error = 0.0;
01738
01739 d1 = data1[i];
01740 d2 = data2[i];
01741 e1 = errs1[i];
01742 e2 = errs2[i];
01743 error = sqrt( d2*d2*e1*e1 + d1*d1*e2*e2 );
01744 errs1[i] = (float) error;
01745 data1[i] = (float)(d1*d2);
01746 }
01747 }
01748
01749 cleanup:
01750 return;
01751 }
01752
01753
01754
01759
01760 void xsh_pre_normalize( xsh_pre* self)
01761 {
01762 double val1, val2, ct1, ct2;
01763 int i, rej, i1, i2;
01764
01765 XSH_ASSURE_NOT_NULL(self);
01766 i = 0;
01767
01768 do {
01769 i++;
01770 check(val1 = cpl_image_get(self->data, i, 1, &rej));
01771 }
01772 while (val1 == 0 || rej == 1);
01773 i1 = i;
01774
01775 do {
01776 i++;
01777 check(val2 = cpl_image_get(self->data, i, 1, &rej));
01778 }
01779 while (val2 == 0 || rej == 1);
01780 i2 = i;
01781
01782 check(cpl_image_normalise( self->data, CPL_NORM_MEAN));
01783
01784 check(ct1 = val1/ cpl_image_get(self->data, i1, 1, &rej));
01785 check(ct2 = val2/ cpl_image_get(self->data, i2, 1, &rej));
01786
01787 xsh_msg("normalize estimate pixel (%d,1) : %f",i1,ct1);
01788 xsh_msg("normalize estimate pixel (%d,1): %f",i2,ct2);
01789
01790 check( cpl_image_divide_scalar( self->errs, ct1));
01791
01792 cleanup:
01793 return;
01794 }
01795
01805 void xsh_pre_median_mean_stdev( xsh_pre * preFrame, double * mean,
01806 double * median, double * stdev )
01807 {
01808 int i, ng, nx, ny ;
01809 float * ppix = NULL;
01810 int * pbad = NULL;
01811 cpl_vector * ptemp = NULL;
01812 int nx_ny=0;
01813 XSH_ASSURE_NOT_NULL( preFrame ) ;
01814 XSH_ASSURE_NOT_NULL( mean ) ;
01815 XSH_ASSURE_NOT_NULL( median ) ;
01816 XSH_ASSURE_NOT_NULL( stdev ) ;
01817
01818 nx = xsh_pre_get_nx (preFrame);
01819 assure (nx != 0, cpl_error_get_code (), "Cant get X size");
01820 ny = xsh_pre_get_ny (preFrame);
01821 assure (ny != 0, cpl_error_get_code (), "Cant get Y size");
01822
01823 check( ptemp = cpl_vector_new( nx*ny )) ;
01824 check( ppix = cpl_image_get_data_float( preFrame->data ) ) ;
01825 check( pbad = cpl_image_get_data_int( preFrame->qual ) ) ;
01826 nx_ny=nx*ny;
01827 for( ng = 0, i = 0 ; i < nx_ny ; i++ ) {
01828 if ( (pbad[i] & preFrame->decode_bp) == 0 ){
01829
01830 check( cpl_vector_set( ptemp, ng, (double)(ppix[i]) )) ;
01831 ng++ ;
01832 }
01833 }
01834
01835
01836 check( cpl_vector_set_size( ptemp, ng ) );
01837 check( *mean = cpl_vector_get_mean( ptemp ) );
01838 check( *stdev = cpl_vector_get_stdev( ptemp ) );
01839 check( *median = cpl_vector_get_median( ptemp ) );
01840
01841 cleanup:
01842 if (cpl_error_get_code() != CPL_ERROR_NONE){
01843 *mean = 0.0;
01844 *stdev = 0.0;
01845 *median = 0.0;
01846 }
01847 xsh_free_vector( &ptemp ) ;
01848 return;
01849 }
01850
01864 void xsh_pre_median_mean_stdev_window( xsh_pre * preFrame, double * mean,
01865 double * median, double * stdev,
01866 const int llx, const int lly,
01867 const int urx, const int ury )
01868 {
01869 int i, ng, nx, ny ;
01870 int vx,vy;
01871 float * ppix = NULL;
01872 int * pbad = NULL;
01873 cpl_vector * ptemp = NULL;
01874 int j;
01875
01876 XSH_ASSURE_NOT_NULL( preFrame ) ;
01877 XSH_ASSURE_NOT_NULL( mean ) ;
01878 XSH_ASSURE_NOT_NULL( median ) ;
01879 XSH_ASSURE_NOT_NULL( stdev ) ;
01880
01881 nx = xsh_pre_get_nx (preFrame);
01882 assure (nx != 0, cpl_error_get_code (), "Cant get X size");
01883 ny = xsh_pre_get_ny (preFrame);
01884 assure (ny != 0, cpl_error_get_code (), "Cant get Y size");
01885
01886 vx=urx-llx+1;
01887 vy=ury-lly+1;
01888
01889 check( ptemp = cpl_vector_new( vx*vy )) ;
01890 check( ppix = cpl_image_get_data_float( preFrame->data ) ) ;
01891 check( pbad = cpl_image_get_data_int( preFrame->qual ) ) ;
01892
01893 ng=0;
01894
01895 for( j = lly-1 ; j < ury ; j++ ) {
01896 for( i = llx-1 ; i < urx ; i++ ) {
01897
01898 if ( (pbad[i] & preFrame->decode_bp) == 0) {
01899
01900 check( cpl_vector_set( ptemp, ng, (double)(ppix[j*nx+i]) )) ;
01901 ng++ ;
01902 }
01903 }
01904 }
01905
01906 cpl_table* tab=NULL;
01907 cpl_table* ext=NULL;
01908 int kappa=5;
01909 int niter1=2;
01910 int niter2=4;
01911
01912 tab=cpl_table_new(ng);
01913 cpl_table_wrap_double(tab,cpl_vector_get_data(ptemp),"VAL");
01914
01915
01916 *median=cpl_table_get_column_median(tab,"VAL");
01917 *mean=cpl_table_get_column_mean(tab,"VAL");
01918 *stdev=cpl_table_get_column_stdev(tab,"VAL");
01919 for(i=0;i<niter1;i++) {
01920
01921 cpl_table_and_selected_double(tab,"VAL",CPL_LESS_THAN,
01922 *median+kappa*(*stdev));
01923 cpl_table_and_selected_double(tab,"VAL",CPL_GREATER_THAN,
01924 *median-kappa*(*stdev));
01925 xsh_free_table(&ext);
01926 ext=cpl_table_extract_selected(tab);
01927 *median=cpl_table_get_column_median(ext,"VAL");
01928 *mean=cpl_table_get_column_mean(ext,"VAL");
01929 *stdev=cpl_table_get_column_stdev(ext,"VAL");
01930
01931 }
01932
01933
01934 for(i=0;i<niter2;i++) {
01935 cpl_table_and_selected_double(tab,"VAL",CPL_LESS_THAN,
01936 *mean+kappa*(*stdev));
01937 cpl_table_and_selected_double(tab,"VAL",CPL_GREATER_THAN,
01938 *mean-kappa*(*stdev));
01939 xsh_free_table(&ext);
01940 ext=cpl_table_extract_selected(tab);
01941 *median=cpl_table_get_column_median(ext,"VAL");
01942 *mean=cpl_table_get_column_mean(ext,"VAL");
01943 *stdev=cpl_table_get_column_stdev(ext,"VAL");
01944
01945 }
01946 xsh_free_table(&ext);
01947 ext=cpl_table_extract_selected(tab);
01948
01949 cpl_table_unwrap(tab,"VAL");
01950 *median=cpl_table_get_column_median(ext,"VAL");
01951 *mean=cpl_table_get_column_mean(ext,"VAL");
01952 *stdev=cpl_table_get_column_stdev(ext,"VAL");
01953
01954
01955
01956
01957
01958
01959
01960
01961
01962
01963
01964
01965
01966
01967
01968
01969
01970
01971 cleanup:
01972 if (cpl_error_get_code() != CPL_ERROR_NONE){
01973 *mean = 0.0;
01974 *stdev = 0.0;
01975 *median = 0.0;
01976 }
01977 xsh_free_vector( &ptemp ) ;
01978 xsh_free_table(&tab);
01979 xsh_free_table(&ext);
01980 return;
01981 }
01982
01983
02004
02005 int xsh_pre_window_best_median_flux_pos( xsh_pre* pre, int xcen, int ycen,
02006 int search_window_hsize, int running_median_hsize, int* xadj, int* yadj)
02007 {
02008 int search_win_xmin, search_win_xmax, search_win_ymin, search_win_ymax;
02009 float* data = NULL;
02010 int* qual = NULL;
02011 double* median_tab = NULL;
02012 int median_box_size = 0;
02013 double max_flux = -99999;
02014 int ibox, jbox;
02015 int xpos = -1, ypos = -1;
02016 int result= 0;
02017
02018 XSH_ASSURE_NOT_NULL( pre);
02019 XSH_ASSURE_NOT_NULL( xadj);
02020 XSH_ASSURE_NOT_NULL( yadj);
02021 XSH_CMP_INT( xcen, >=, 0, "Check central x position",);
02022 XSH_CMP_INT( xcen, <, pre->nx, "Check central x position",);
02023 XSH_CMP_INT( ycen, >=, 0, "Check central x position",);
02024 XSH_CMP_INT( ycen, <, pre->ny, "Check central x position",);
02025
02026 median_box_size = 1+running_median_hsize*2;
02027
02028 search_win_xmin = xcen-search_window_hsize;
02029 search_win_xmax = xcen+search_window_hsize;
02030 search_win_ymin = ycen-search_window_hsize;
02031 search_win_ymax = ycen+search_window_hsize;
02032
02033 if ( search_win_xmin < 0){
02034 search_win_xmin = 0;
02035 }
02036 if ( search_win_xmax >= pre->nx){
02037 search_win_xmax = pre->nx-1;
02038 }
02039 if ( search_win_ymin < 0){
02040 search_win_ymin = 0;
02041 }
02042 if ( search_win_ymax >= pre->ny){
02043 search_win_ymax = pre->ny-1;
02044 }
02045
02046 check( data = cpl_image_get_data_float( pre->data));
02047 check( qual = cpl_image_get_data_int( pre->qual));
02048 XSH_CALLOC(median_tab, double, median_box_size* median_box_size);
02049
02050 for (jbox=search_win_ymin; jbox <= (search_win_ymax+1-median_box_size);
02051 jbox++){
02052 for (ibox=search_win_xmin; ibox <= (search_win_xmax+1-median_box_size);
02053 ibox++){
02054 double med_flux = 0.0;
02055 int xc,yc;
02056
02057 med_flux = xsh_pre_data_window_median_flux_pa( pre,
02058 ibox, jbox, median_box_size, median_box_size, median_tab);
02059
02060 if ( cpl_error_get_code() == CPL_ERROR_NONE){
02061 xc = ibox+running_median_hsize;
02062 yc = jbox+running_median_hsize;
02063
02064 if ( (max_flux) < med_flux &&
02065 ( (qual[xc+yc*pre->nx] & pre->decode_bp) == 0) ){
02066
02067 max_flux = med_flux;
02068 xpos = xc;
02069 ypos = yc;
02070 }
02071 }
02072 else{
02073 xsh_error_reset();
02074 }
02075 }
02076 }
02077 if (xpos < 0 || ypos < 0){
02078 xsh_msg_dbg_high( "No valid pixels in the search box");
02079 result = 1;
02080 }
02081 else{
02082 *xadj = xpos;
02083 *yadj = ypos;
02084 }
02085
02086 cleanup:
02087 XSH_FREE( median_tab);
02088 return result;
02089 }
02090
02091
02102
02103 double xsh_pre_data_window_median_flux_pa(xsh_pre* pre, int x, int y,
02104 int size_x, int size_y, double* tab )
02105 {
02106 double medflux = 0.0;
02107 cpl_vector* v = NULL;
02108 float* data = NULL;
02109 int* qual = NULL;
02110 int ix = 0, iy = 0;
02111 int size = 0;
02112
02113
02114 XSH_ASSURE_NOT_NULL(pre);
02115 XSH_ASSURE_NOT_ILLEGAL(x >=0 && x < pre->nx);
02116 XSH_ASSURE_NOT_ILLEGAL(y >= 0 && y < pre->ny);
02117 XSH_ASSURE_NOT_ILLEGAL(size_x > 0 && (x+ size_x));
02118 XSH_ASSURE_NOT_ILLEGAL(size_y > 0 && (y+ size_y));
02119 XSH_ASSURE_NOT_NULL(tab);
02120
02121 if ( (x+size_x) >= pre->nx){
02122 size_x = pre->nx-x;
02123 }
02124 if ( (y+size_y) >= pre->ny){
02125 size_y = pre->ny-y;
02126 }
02127
02128
02129 check(data = cpl_image_get_data_float(pre->data));
02130
02131 check(qual = cpl_image_get_data_int(pre->qual));
02132
02133 for( iy=0; iy< size_y; iy++){
02134 for( ix=0; ix<size_x; ix++){
02135 if ( (qual[x+ix+(y+iy)*pre->nx] & pre->decode_bp) == 0 ) {
02136
02137 tab[size] = data[x+ix+(y+iy)*pre->nx];
02138 size++;
02139 }
02140 }
02141 }
02142 #if 0
02143
02144
02145
02146
02147
02148 XSH_ASSURE_NOT_ILLEGAL( ((float)size/(float)(size_x*size_y)) >
02149 XSH_WINDOW_MEDIAN_FRAC);
02150 #else
02151
02152
02153
02154
02155
02156
02157
02158
02159
02160 if ( ((float)size/(float)(size_x*size_y)) <= XSH_WINDOW_MEDIAN_FRAC ) {
02161 xsh_msg_warning( "Not enough good pixels in sub-window: %d/%d [%.2f < %.2f]", size,
02162 size_x*size_y, (float)size/(float)(size_x*size_y),
02163 XSH_WINDOW_MEDIAN_FRAC ) ;
02164 xsh_msg_warning( " Use Minimum/Median = 0." ) ;
02165 goto cleanup ;
02166 }
02167 #endif
02168
02169
02170 check(v = cpl_vector_wrap(size, tab));
02171 check( medflux = cpl_vector_get_median(v));
02172
02173 cleanup:
02174 xsh_unwrap_vector(&v);
02175 return medflux;
02176 }
02177
02178
02192
02193 double xsh_pre_data_window_sample_flux_pa(xsh_pre* pre, int x, int y,
02194 int size_x, int size_y, double* tab,
02195 const char* method,
02196 double min_window_frac )
02197 {
02198 double flux = 0.0;
02199 cpl_vector* v = NULL;
02200 float* data = NULL;
02201 int* qual = NULL;
02202 int ix = 0, iy = 0;
02203 int size = 0;
02204
02205
02206 XSH_ASSURE_NOT_NULL(pre);
02207 XSH_ASSURE_NOT_ILLEGAL(x >=1 && x <= pre->nx);
02208 XSH_ASSURE_NOT_ILLEGAL(y >= 1 && y <= pre->ny);
02209 XSH_ASSURE_NOT_ILLEGAL(size_x > 0 && (x+ size_x));
02210 XSH_ASSURE_NOT_ILLEGAL(size_y > 0 && (y+ size_y));
02211 XSH_ASSURE_NOT_NULL(tab);
02212
02213 x = x-1;
02214 y = y-1;
02215
02216 if ( (x+size_x) >= pre->nx){
02217 size_x = pre->nx-x;
02218 }
02219 if ( (y+size_y) >= pre->ny){
02220 size_y = pre->ny-y;
02221 }
02222
02223
02224 check(data = cpl_image_get_data_float(pre->data));
02225
02226 check(qual = cpl_image_get_data_int(pre->qual));
02227
02228 for( iy=0; iy< size_y; iy++){
02229 for( ix=0; ix<size_x; ix++){
02230 if ( (qual[x+ix+(y+iy)*pre->nx] & pre->decode_bp) == 0 ) {
02231
02232 tab[size] = data[x+ix+(y+iy)*pre->nx];
02233 size++;
02234 }
02235 }
02236 }
02237
02238 #if 0
02239
02240
02241
02242
02243
02244 XSH_ASSURE_NOT_ILLEGAL( ((float)size/(float)(size_x*size_y)) >
02245 XSH_WINDOW_MEDIAN_FRAC);
02246 #else
02247
02248
02249
02250
02251
02252
02253
02254
02255
02256 if ( ( (float)size/(float)(size_x*size_y)) <= min_window_frac ) {
02257 xsh_msg_warning( "Not enough good pixels in sub-window: %d/%d [%.2f < %.2f]", size,
02258 size_x*size_y, (float)size/(float)(size_x*size_y),
02259 min_window_frac ) ;
02260 xsh_msg_warning( " Use Minimum/Median = 0." ) ;
02261 goto cleanup ;
02262 }
02263 #endif
02264
02265
02266 check(v = cpl_vector_wrap(size, tab));
02267 if(strcmp(method,"minimum")==0) {
02268 check( flux = cpl_vector_get_min(v));
02269 } else if (strcmp(method,"median")==0) {
02270 check( flux = cpl_vector_get_median(v));
02271 } else if (strcmp(method,"poly")==0) {
02272 check( flux = cpl_vector_get_median(v));
02273 } else {
02274 flux=0;
02275 }
02276
02277 cleanup:
02278 xsh_unwrap_vector(&v);
02279 return flux;
02280 }
02281
02282
02283
02293
02294 double xsh_pre_data_window_median_flux(xsh_pre* pre, int x, int y,
02295 int size_x, int size_y)
02296 {
02297 double* data = NULL;
02298 double medflux = 0.0;
02299
02300 XSH_MALLOC(data,double,size_x*size_y);
02301 check(medflux =
02302 xsh_pre_data_window_median_flux_pa(pre, x, y, size_x, size_y, data));
02303
02304 cleanup:
02305 XSH_FREE(data);
02306 return medflux;
02307 }
02308
02314
02315 const cpl_propertylist *
02316 xsh_pre_get_header_const (const xsh_pre * pre)
02317 {
02318 cpl_propertylist *header = NULL;
02319
02320 XSH_ASSURE_NOT_NULL(pre);
02321 header = pre->data_header;
02322
02323 cleanup:
02324 return header;
02325 }
02326
02327
02333
02334 cpl_propertylist *
02335 xsh_pre_get_header (xsh_pre * pre)
02336 {
02337 XSH_ASSURE_NOT_NULL(pre);
02338
02339 cleanup:
02340 return (cpl_propertylist *) xsh_pre_get_header_const (pre);
02341 }
02342
02343
02344
02350
02351 const cpl_image* xsh_pre_get_data_const (const xsh_pre * pre)
02352 {
02353 cpl_image *data = NULL;
02354
02355 XSH_ASSURE_NOT_NULL(pre);
02356 data = pre->data;
02357
02358 cleanup:
02359 return data;
02360 }
02361
02362
02368
02369 cpl_image* xsh_pre_get_data (xsh_pre * pre)
02370 {
02371 return (cpl_image *) xsh_pre_get_data_const (pre);
02372 }
02373
02374
02380
02381 const cpl_image * xsh_pre_get_errs_const (const xsh_pre * pre)
02382 {
02383 cpl_image *errs = NULL;
02384
02385 XSH_ASSURE_NOT_NULL(pre);
02386 errs = pre->errs;
02387
02388 cleanup:
02389 return errs;
02390 }
02391
02392
02398
02399 cpl_image* xsh_pre_get_errs (xsh_pre * pre)
02400 {
02401 return (cpl_image *) xsh_pre_get_errs_const (pre);
02402 }
02403
02404
02410
02411 const cpl_image* xsh_pre_get_qual_const (const xsh_pre * pre)
02412 {
02413 cpl_image *qual = NULL;
02414
02415 XSH_ASSURE_NOT_NULL(pre);
02416 qual = pre->qual;
02417
02418 cleanup:
02419 return qual;
02420 }
02421
02422
02428 cpl_image* xsh_pre_get_qual (xsh_pre * pre)
02429 {
02430 return (cpl_image *) xsh_pre_get_qual_const (pre);
02431 }
02432
02433
02439
02440 const double* xsh_pre_get_data_buffer_const (const xsh_pre * pre)
02441 {
02442 double *buffer = NULL;
02443
02444 XSH_ASSURE_NOT_NULL(pre);
02445
02446
02447
02448 passure (cpl_image_get_type (pre->data) == CPL_TYPE_DOUBLE, " ");
02449 buffer = (double *) cpl_image_get_data (pre->data);
02450
02451 cleanup:
02452 return buffer;
02453 }
02454
02455
02461
02462 double* xsh_pre_get_data_buffer (xsh_pre * pre)
02463 {
02464 return (double *) xsh_pre_get_data_buffer_const (pre);
02465 }
02466
02467
02473
02474 const double* xsh_pre_get_errs_buffer_const (const xsh_pre * pre)
02475 {
02476 double *buffer = NULL;
02477
02478 XSH_ASSURE_NOT_NULL(pre);
02479 passure (cpl_image_get_type (pre->errs) == CPL_TYPE_DOUBLE, " ");
02480 buffer = (double *) cpl_image_get_data (pre->errs);
02481
02482 cleanup:
02483 return buffer;
02484 }
02485
02486
02492
02493 double* xsh_pre_get_errs_buffer (xsh_pre * pre)
02494 {
02495 return (double *) xsh_pre_get_errs_buffer_const(pre);
02496 }
02497
02498
02506
02507 void
02508 xsh_pre_dump (const xsh_pre * pre, FILE * stream)
02509 {
02510 cpl_stats *stats = NULL;
02511
02512 if (pre == NULL) {
02513 fprintf (stream, "Null");
02514 }
02515 else {
02516
02517 stats = cpl_stats_new_from_image (pre->data, CPL_STATS_ALL);
02518
02519 cpl_stats_dump (stats, CPL_STATS_ALL, stream);
02520
02521
02522
02523 fflush (stream);
02524 }
02525
02526 xsh_free_stats (&stats);
02527 return;
02528 }
02529
02530
02531
02537 void xsh_pre_multiply_scalar (const xsh_pre * pre, double x)
02538 {
02539
02540 XSH_ASSURE_NOT_NULL( pre);
02541
02542
02543 check (cpl_image_multiply_scalar(pre->data, x));
02544
02545
02546 check (cpl_image_multiply_scalar(pre->errs, fabs(x)));
02547
02548 cleanup:
02549 return;
02550 }
02551
02557 void xsh_pre_divide_scalar (const xsh_pre * pre, double x)
02558 {
02559
02560 XSH_ASSURE_NOT_NULL( pre);
02561 XSH_ASSURE_NOT_ILLEGAL( x != 0);
02562
02563
02564 check (cpl_image_divide_scalar(pre->data, x));
02565
02566
02567 check (cpl_image_divide_scalar(pre->errs, fabs(x)));
02568
02569 cleanup:
02570 return;
02571 }
02572
02579 void xsh_pre_add_scalar (const xsh_pre * pre, double x)
02580 {
02581
02582 XSH_ASSURE_NOT_NULL( pre);
02583 XSH_ASSURE_NOT_ILLEGAL( x != 0);
02584
02585
02586 check (cpl_image_add_scalar(pre->data, x));
02587
02588 cleanup:
02589 return;
02590 }
02591
02592
02598 void xsh_pre_subtract_scalar (const xsh_pre * pre, double x)
02599 {
02600
02601 XSH_ASSURE_NOT_NULL( pre);
02602 XSH_ASSURE_NOT_ILLEGAL( x != 0);
02603
02604
02605 check (cpl_image_subtract_scalar(pre->data, x));
02606
02607 cleanup:
02608 return;
02609 }
02610
02617 void xsh_pre_multiply_image(const xsh_pre *pre, cpl_image* img)
02618 {
02619 cpl_image *abs = NULL;
02620
02621 XSH_ASSURE_NOT_NULL( pre);
02622 XSH_ASSURE_NOT_NULL( img);
02623
02624
02625 check ( cpl_image_multiply(pre->data, img));
02626 check( abs = cpl_image_abs_create( img));
02627 check ( cpl_image_multiply(pre->errs, abs));
02628
02629 cleanup:
02630 xsh_free_image( &abs);
02631 return;
02632 }
02633
02634
02641 cpl_image* xsh_pre_abs (const xsh_pre * pre)
02642 {
02643
02644 cpl_image *result = NULL;
02645 int *result_data = NULL;
02646 float *data = NULL;
02647 int i, size;
02648
02649 XSH_ASSURE_NOT_NULL( pre);
02650
02651
02652 check ( data = cpl_image_get_data_float( pre->data));
02653 check( result = cpl_image_new( pre->nx, pre->ny, CPL_TYPE_INT));
02654 check( result_data = cpl_image_get_data_int( result));
02655
02656 size = pre->nx*pre->ny;
02657
02658 for(i =0; i < size; i++){
02659 if ( data[i] < 0){
02660 result_data[i] = -1;
02661 data[i] = -data[i];
02662 }
02663 else{
02664 result_data[i] = 1;
02665 }
02666 }
02667
02668 cleanup:
02669 return result;
02670 }
02671
02672
02681
02682
02683 cpl_frame*
02684 xsh_frameset_average_pre(cpl_frameset *set,
02685 xsh_instrument* instr,
02686 const char* tag)
02687 {
02688 cpl_frame* result=NULL;
02689 cpl_frame* frame=NULL;
02690 cpl_image* data=NULL;
02691 cpl_image* errs=NULL;
02692 cpl_image* qual=NULL;
02693
02694 xsh_pre* pre=NULL;
02695 cpl_imagelist* iml_data=NULL;
02696 cpl_imagelist* iml_errs=NULL;
02697 cpl_imagelist* iml_qual=NULL;
02698
02699 cpl_propertylist* plist=NULL;
02700 char name_o[80];
02701 const char* name=NULL;
02702 int i=0;
02703 int size=0;
02704 int nx=0;
02705 int ny=0;
02706
02707 size=cpl_frameset_get_size(set);
02708 iml_data=cpl_imagelist_new();
02709 iml_errs=cpl_imagelist_new();
02710 iml_qual=cpl_imagelist_new();
02711
02712 for(i=0;i<size;i++) {
02713 frame=cpl_frameset_get_frame(set,i);
02714 pre=xsh_pre_load(frame,instr);
02715 nx=pre->nx;
02716 ny=pre->ny;
02717 cpl_imagelist_set(iml_data,cpl_image_duplicate(pre->data),i);
02718 cpl_imagelist_set(iml_errs,cpl_image_duplicate(pre->errs),i);
02719 cpl_imagelist_set(iml_qual,cpl_image_duplicate(pre->qual),i);
02720 xsh_pre_free(&pre);
02721 }
02722
02723
02724 pre=xsh_pre_load(cpl_frameset_get_frame(set,0),instr);
02725 pre->data=cpl_imagelist_collapse_create(iml_data);
02726 pre->errs=cpl_imagelist_collapse_create(iml_errs);
02727 pre->qual=cpl_imagelist_collapse_create(iml_qual);
02728
02729 cpl_image_divide_scalar(pre->data,size);
02730 cpl_image_divide_scalar(pre->errs,size);
02731 cpl_image_divide_scalar(pre->qual,size);
02732
02733 frame=cpl_frameset_get_frame(set,0);
02734 name=cpl_frame_get_filename(frame);
02735 plist=cpl_propertylist_load(name,0);
02736
02737 sprintf(name_o,"%s.fits",tag);
02738 check(xsh_pre_save(pre,name_o,tag,0));
02739
02740 result=xsh_frame_product(name_o,tag,CPL_FRAME_TYPE_IMAGE,
02741 CPL_FRAME_GROUP_PRODUCT,CPL_FRAME_LEVEL_FINAL);
02742
02743 cleanup:
02744 xsh_free_image(&data);
02745 xsh_free_image(&errs);
02746 xsh_free_image(&qual);
02747
02748 xsh_free_imagelist(&iml_data);
02749 xsh_free_imagelist(&iml_errs);
02750 xsh_free_imagelist(&iml_qual);
02751
02752 xsh_pre_free(&pre);
02753 xsh_free_propertylist(&plist);
02754
02755 return result;
02756 }
02757
02765 void xsh_pre_turn( xsh_pre * pre, int rot )
02766 {
02767 cpl_image * img = NULL ;
02768
02769 XSH_ASSURE_NOT_NULL( pre ) ;
02770
02771 check( img = xsh_pre_get_data( pre ) ) ;
02772 check( cpl_image_turn( img, rot ) ) ;
02773
02774 check( img = xsh_pre_get_errs( pre ) ) ;
02775 check( cpl_image_turn( img, rot ) ) ;
02776
02777 check( img = xsh_pre_get_qual( pre ) ) ;
02778 check( cpl_image_turn( img, rot ) ) ;
02779
02780 cleanup:
02781 return ;
02782 }
02783
02798 void xsh_pre_extract( xsh_pre *pre, int xmin, int ymin, int xmax, int ymax)
02799 {
02800 cpl_image * img = NULL ;
02801 cpl_image * ext_img = NULL ;
02802
02803 XSH_ASSURE_NOT_NULL( pre);
02804
02805 check( img = xsh_pre_get_data( pre));
02806
02807 XSH_ASSURE_NOT_NULL( img);
02808
02809 check( ext_img = cpl_image_extract( img, xmin, ymin, xmax, ymax));
02810 xsh_free_image( &img);
02811 pre->data = ext_img;
02812
02813 check( img = xsh_pre_get_errs( pre));
02814 check( ext_img = cpl_image_extract( img, xmin, ymin, xmax, ymax));
02815 xsh_free_image( &img);
02816 pre->errs = ext_img;
02817
02818 check( img = xsh_pre_get_qual( pre));
02819 check( ext_img = cpl_image_extract( img, xmin, ymin, xmax, ymax));
02820 xsh_free_image( &img);
02821 pre->qual = ext_img;
02822
02823 cleanup:
02824 return;
02825 }
02834 void xsh_pre_flip( xsh_pre * pre, int angle )
02835 {
02836 cpl_image * img = NULL ;
02837
02838 XSH_ASSURE_NOT_NULL( pre ) ;
02839
02840 check( img = xsh_pre_get_data( pre ) ) ;
02841 check( cpl_image_flip( img, angle ) ) ;
02842
02843 check( img = xsh_pre_get_errs( pre ) ) ;
02844 check( cpl_image_flip( img, angle ) ) ;
02845
02846 check( img = xsh_pre_get_qual( pre ) ) ;
02847 check( cpl_image_flip( img, angle ) ) ;
02848
02849 cleanup:
02850 return ;
02851 }