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_irplib_mkmaster.h>
00048 #include <xsh_dump.h>
00049 #include <xsh_utils.h>
00050 #include <xsh_error.h>
00051 #include <xsh_msg.h>
00052 #include <xsh_pfits.h>
00053 #include <xsh_dfs.h>
00054 #include <math.h>
00055 #include <time.h>
00056 #include <cpl.h>
00057
00058
00059
00060
00061 static cpl_error_code xsh_preoverscan_corr(cpl_frame* raw, const int corr_mode,
00062 double* cor_val) {
00063
00064 const char* fname = NULL;
00065 cpl_image* raw_ima = NULL;
00066 cpl_image* tmp_ima = NULL;
00067
00068 cpl_propertylist* header = NULL;
00069 int ovscx = 0;
00070
00071 int prscx = 0;
00072
00073 int naxis1 = 0;
00074 int naxis2 = 0;
00075 double tmp_val = 0;
00076 cpl_vector* cor_val_vect=NULL;
00077 cpl_imagelist* iml=NULL;
00078 cpl_image* ima_ext=NULL;
00079
00080
00081 float* ptmp = NULL;
00082 int i = 0;
00083 int j = 0;
00084 char cor_fname[256];
00085
00086 fname = cpl_frame_get_filename(raw);
00087 sprintf(cor_fname, "PREOVER_COR_%s", xsh_get_basename(fname));
00088 header = cpl_propertylist_load(fname, 0);
00089
00090 raw_ima = cpl_image_load(fname, XSH_PRE_DATA_TYPE, 0, 0);
00091 prscx = xsh_pfits_get_prscx(header);
00092 ovscx = xsh_pfits_get_ovscx(header);
00093
00094 naxis1 = xsh_pfits_get_naxis1(header);
00095 naxis2 = xsh_pfits_get_naxis2(header);
00096 tmp_ima = cpl_image_new(naxis1, naxis2, XSH_PRE_DATA_TYPE);
00097 ptmp = cpl_image_get_data_float(tmp_ima);
00098
00099 switch (corr_mode) {
00100
00101
00102 case 0: {
00103 *cor_val = 0;
00104 break;
00105 }
00106 case 1: {
00107
00108
00109 ima_ext = cpl_image_extract(raw_ima, naxis1 - ovscx, 1, naxis1, naxis2);
00110 iml = cpl_imagelist_new();
00111 cpl_imagelist_set(iml, ima_ext,0);
00112 cor_val_vect = xsh_irplib_imagelist_get_clean_mean_levels(iml, 3, 5, 0.001);
00113 xsh_free_imagelist(&iml);
00114
00115 *cor_val = cpl_vector_get(cor_val_vect, 0);
00116 xsh_free_vector(&cor_val_vect);
00117
00118 break;
00119 }
00120 case 2: {
00121
00122
00123 ima_ext = cpl_image_extract(raw_ima, 1, 1, prscx, naxis2);
00124 iml = cpl_imagelist_new();
00125 cpl_imagelist_set(iml, ima_ext,0);
00126 cor_val_vect = xsh_irplib_imagelist_get_clean_mean_levels(iml, 3, 5, 0.001);
00127 xsh_free_imagelist(&iml);
00128
00129 *cor_val = cpl_vector_get(cor_val_vect, 0);
00130 xsh_free_vector(&cor_val_vect);
00131
00132 break;
00133 }
00134 case 3: {
00135
00136
00137
00138 ima_ext = cpl_image_extract(raw_ima, 1, 1, prscx, naxis2);
00139 iml = cpl_imagelist_new();
00140 cpl_imagelist_set(iml, ima_ext,0);
00141 cor_val_vect = xsh_irplib_imagelist_get_clean_mean_levels(iml, 3, 5, 0.001);
00142 xsh_free_imagelist(&iml);
00143
00144 *cor_val = cpl_vector_get(cor_val_vect, 0);
00145 xsh_free_vector(&cor_val_vect);
00146
00147
00148 ima_ext = cpl_image_extract(raw_ima, naxis1 - ovscx, 1, naxis1, naxis2);
00149 iml = cpl_imagelist_new();
00150 cpl_imagelist_set(iml, ima_ext,0);
00151 cor_val_vect = xsh_irplib_imagelist_get_clean_mean_levels(iml, 3, 5, 0.001);
00152 xsh_free_imagelist(&iml);
00153
00154 *cor_val += cpl_vector_get(cor_val_vect, 0);
00155 xsh_free_vector(&cor_val_vect);
00156
00157
00158 *cor_val *= 0.5;
00159
00160 break;
00161 }
00162 case 4: {
00163
00164
00165
00166
00167
00168
00169
00170 for (j = 0; j < naxis2; j++) {
00171 tmp_val = cpl_image_get_median_window(raw_ima, naxis1 - ovscx, j + 1,
00172 naxis1, j + 1);
00173 for (i = 0; i < naxis1; i++) {
00174 ptmp[j * naxis1 + i] = tmp_val;
00175 }
00176 }
00177 break;
00178 }
00179 case 5: {
00180
00181 for (j = 0; j < naxis2; j++) {
00182 tmp_val = cpl_image_get_median_window(raw_ima, 1, j + 1,prscx, j + 1);
00183 for (i = 0; i < naxis1; i++) {
00184 ptmp[j * naxis1 + i] = tmp_val;
00185 }
00186 }
00187 break;
00188 }
00189 case 6: {
00190
00191
00192 for (j = 0; j < naxis2; j++) {
00193
00194 tmp_val = cpl_image_get_median_window(raw_ima, 1, j + 1,prscx, j + 1);
00195
00196 tmp_val += cpl_image_get_median_window(raw_ima, naxis1 - ovscx, j + 1, naxis1, j + 1);
00197
00198
00199 tmp_val *= 0.5;
00200 for (i = 0; i < naxis1; i++) {
00201 ptmp[j * naxis1 + i] = tmp_val;
00202 }
00203 }
00204 break;
00205 }
00206 default:
00207 xsh_msg_error("Not supported");
00208 break;
00209 }
00210
00211 if (corr_mode < 4) {
00212 cpl_image_subtract_scalar(raw_ima, *cor_val);
00213 } else {
00214 *cor_val = cpl_image_get_median_window(tmp_ima, 1, 1, naxis1, naxis2);
00215 cpl_image_subtract(raw_ima, tmp_ima);
00216 }
00217
00218 xsh_msg("Apply pre-overscan correction %g", *cor_val);
00219
00220 if (corr_mode > 0 && corr_mode < 4) {
00221 if (fabs(*cor_val) < 1.e-6) {
00222 xsh_msg_error(
00223 "The overscan correction is < 10^-6. Probably you have bad input");
00224 cpl_error_set(cpl_func, CPL_ERROR_ILLEGAL_INPUT);
00225 goto cleanup;
00226 }
00227 }
00228
00229 xsh_pfits_set_bunit(header, XSH_BUNIT_FLUX_REL_C);
00230 check(cpl_image_save( raw_ima, cor_fname, CPL_BPP_IEEE_FLOAT, header,
00231 CPL_IO_DEFAULT));
00232 cpl_frame_set_filename(raw, cor_fname);
00233
00234 xsh_add_temporary_file(cor_fname);
00235 cleanup:
00236
00237 xsh_free_vector(&cor_val_vect);
00238 xsh_free_imagelist(&iml);
00239 xsh_free_image(&raw_ima);
00240 xsh_free_image(&tmp_ima);
00241 xsh_free_propertylist(&header);
00242
00243 return cpl_error_get_code();
00244 }
00245
00246
00247 static double
00248 xsh_compute_ron_nir(const double dit)
00249 {
00250 double ron=0;
00251 const int nsamples=10;
00252 int i=0;
00253 double dit_min=0;
00254 double dit_max=0;
00255 double ron_min=0;
00256 double ron_max=0;
00257 double slope=0;
00258 int i_min=0;
00259
00260
00261 static double dit_samples[10]={2,4,8,16,32,64,128,256,400,1024};
00262
00263
00264 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};
00265
00266 for(i=0;i<nsamples;i++){
00267 if(dit_samples[i] < dit) i_min=i;
00268 }
00269
00270 dit_min=dit_samples[i_min];
00271 ron_min=ron_samples[i_min];
00272
00273 dit_max=dit_samples[i_min+1];
00274 ron_max=ron_samples[i_min+1];
00275 slope=(ron_max-ron_min)/(dit_max-dit_min);
00276
00277 ron=ron_min+slope*(dit-dit_min);
00278
00279 return ron;
00280
00281 }
00282
00318
00319 static void xsh_pre_init(xsh_pre* pre, cpl_propertylist* header,
00320 xsh_instrument * instrument)
00321 {
00322
00323 double dit;
00324
00325 XSH_ASSURE_NOT_NULL( pre);
00326 XSH_ASSURE_NOT_NULL( header);
00327 XSH_ASSURE_NOT_NULL( pre->instrument);
00328
00329
00330 pre->data_header = header;
00331
00332
00333
00334 if ( cpl_error_get_code() != CPL_ERROR_NONE){
00335 xsh_msg_warning("No ARM keyword found put default");
00336 xsh_error_reset();
00337 check( xsh_pfits_set_arm(pre->data_header, instrument));
00338 }
00339 pre->decode_bp = instrument->decode_bp;
00340
00341
00342 check( pre->naxis1 = xsh_pfits_get_naxis1(pre->data_header));
00343 check( pre->naxis2 = xsh_pfits_get_naxis2(pre->data_header));
00344 if(cpl_propertylist_has(pre->data_header,"EXPTIME")) {
00345 check( pre->exptime = xsh_pfits_get_exptime(pre->data_header));
00346 }
00347 if( xsh_instrument_get_arm(pre->instrument) == XSH_ARM_NIR){
00348 check(dit= xsh_pfits_get_dit(pre->data_header)) ;
00349
00350
00351 pre->ron=xsh_compute_ron_nir(dit);
00352
00353 pre->conad=2.12;
00354 pre->gain=1./pre->conad;
00355 }else {
00356 check(pre->ron = xsh_pfits_get_ron(pre->data_header));
00357 check(pre->conad = xsh_pfits_get_conad(pre->data_header));
00358 check(pre->gain = xsh_pfits_get_det_gain(pre->data_header));
00359 }
00360 if( xsh_instrument_get_arm(pre->instrument) == XSH_ARM_NIR){
00361 int chip_ny;
00362
00363
00364 pre->binx = 1;
00365 pre->biny = 1;
00366
00367 check(pre->pszx = xsh_pfits_get_det_pxspace(
00368 pre->data_header));
00369
00370
00371 pre->pszx = pre->pszx * 1000000 ;
00372 pre->pszy = pre->pszx;
00373
00374 check( chip_ny = xsh_pfits_get_chip_ny (pre->data_header));
00375 pre->cutx = XSH_NIR_DEFAULT_CUT;
00376
00377
00378
00379
00380
00381 pre->cuty = XSH_NIR_DEFAULT_CUT_Y;
00382 pre->cutmx = XSH_NIR_DEFAULT_CUT_X;
00383 #if 0
00384 pre->cutmy = (chip_ny / 2) - XSH_NIR_DEFAULT_CUT_Y ;
00385 #else
00386
00387 pre->cutmy = XSH_NIR_DEFAULT_CUT_Y ;
00388 #endif
00389
00390 }
00391 else {
00392 pre->binx = xsh_pfits_get_binx( pre->data_header);
00393 pre->biny = xsh_pfits_get_biny( pre->data_header);
00394 if ( cpl_error_get_code() != CPL_ERROR_NONE){
00395 xsh_msg("WARNING : No binning keywords found. Force binning to 1x1");
00396 pre->binx = 1;
00397 pre->biny = 1;
00398 xsh_error_reset();
00399 }
00400
00401 check(pre->pszx = xsh_pfits_get_pszx(pre->data_header));
00402 check(pre->pszy = xsh_pfits_get_pszy(pre->data_header));
00403
00404 pre->pszx = pre->pszx * pre->binx;
00405 pre->pszy = pre->pszy * pre->biny;
00406
00407
00408
00409
00410
00411
00412
00413 pre->cutmx = xsh_pfits_get_ovscx(pre->data_header);
00414 pre->cutx = xsh_pfits_get_prscx(pre->data_header);
00415 pre->cutmy = xsh_pfits_get_ovscy(pre->data_header);
00416 pre->cuty = xsh_pfits_get_prscy(pre->data_header);
00417 xsh_error_reset();
00418 }
00419
00420 instrument->binx = pre->binx ;
00421 instrument->biny = pre->biny ;
00422
00423 cleanup:
00424
00425 return;
00426 }
00427
00428
00450
00451 xsh_pre* xsh_pre_create(cpl_frame* raw, cpl_frame* bpmap, cpl_image* bias_data,
00452 xsh_instrument* instr, const int pre_overscan_corr,
00453 const bool flag_neg_and_thresh_pix) {
00454 xsh_pre* result = NULL;
00455 const char* framename = NULL;
00456 const char* frame_tag = NULL;
00457 int nextensions = 0;
00458 int mode_or=1;
00459
00460
00461
00462
00463
00464
00465
00466 cpl_image *image = NULL;
00467 float* errs = NULL;
00468 float* data = NULL;
00469 int i = 0;
00470 const char *bpfilename = NULL;
00471 cpl_propertylist* bplist = NULL, *data_header = NULL;
00472 int bpnaxis1 = 0, bpnaxis2 = 0;
00473
00474 int nsat = 0;
00475 double frac_sat = 0;
00476 double cor_val = 0;
00477
00478
00479 XSH_ASSURE_NOT_NULL(raw);
00480 XSH_ASSURE_NOT_NULL(instr);
00481
00482
00483 XSH_CALLOC(result, xsh_pre, 1);
00484
00485
00486 result->instrument = instr;
00487 result->decode_bp = instr->decode_bp;
00488
00489 XSH_NEW_PROPERTYLIST(result->errs_header);
00490 check(xsh_pfits_set_extname(result->errs_header, "ERRS"));
00491 XSH_NEW_PROPERTYLIST(result->qual_header);
00492 check(xsh_pfits_set_extname(result->qual_header, "QUAL"));
00493
00494
00495 check(framename = cpl_frame_get_filename(raw));
00496 check(result->group = cpl_frame_get_group(raw));
00497 check(frame_tag = cpl_frame_get_tag(raw));
00498
00499
00500 check(nextensions = cpl_frame_get_nextensions(raw));
00501
00502
00503 XSH_ASSURE_NOT_ILLEGAL(nextensions == 0);
00504
00505
00506 check_msg(data_header = cpl_propertylist_load(framename, 0),
00507 "Could not load header of file '%s'", framename);
00508
00509
00510 if (pre_overscan_corr > 0) {
00511 check(xsh_preoverscan_corr(raw, pre_overscan_corr, &cor_val));
00512 check(framename = cpl_frame_get_filename(raw));
00513 }
00514 check(xsh_pre_init(result, data_header, instr));
00515
00516
00517 if (strstr(frame_tag, "AFC") != NULL) {
00518 check(xsh_pfits_set_dpr_tech(data_header, XSH_DPR_TECH_SINGLE_PINHOLE));
00519 if (xsh_instrument_get_arm(instr) != XSH_ARM_NIR) {
00520 result->cutmx = 0;
00521 result->cutmy = 0;
00522 result->cutx = 0;
00523 result->cuty = 0;
00524 }
00525 }
00526
00527 result->nx = result->naxis1 - result->cutmx - result->cutx;
00528 result->ny = result->naxis2 - result->cutmy - result->cuty;
00529
00530
00531 if (xsh_instrument_get_arm(instr) == XSH_ARM_NIR) {
00532
00533 XSH_ASSURE_NOT_ILLEGAL(result->nx > 0 && result->ny > 0);
00534
00535
00536 check(image = cpl_image_load(framename, XSH_PRE_DATA_TYPE, 0, 0));
00537
00538
00539
00540
00541
00542
00543 xsh_msg_dbg_medium("extracting region [%d,%d:%d,%d]", result->cutx + 1,
00544 result->cuty + 1, result->naxis1 - XSH_NIR_DEFAULT_CUT,
00545 result->naxis2 - result->cutmy - XSH_NIR_DEFAULT_CUT);
00546
00547 check(
00548 result->data = cpl_image_extract(image, result->cutx + 1,
00549 result->cuty + 1, result->naxis1 - XSH_NIR_DEFAULT_CUT,
00550 result->naxis2 - result->cutmy - XSH_NIR_DEFAULT_CUT));
00551
00552 check(cpl_image_turn(result->data, 1));
00553 result->nx = cpl_image_get_size_x(result->data);
00554 result->ny = cpl_image_get_size_y(result->data);
00555 xsh_msg_dbg_low("***** NX,NY: %d,%d", result->nx, result->ny);
00556
00557 check(result->errs = cpl_image_duplicate(result->data));
00558 check(errs = cpl_image_get_data_float(result->errs));
00559 check(data = cpl_image_get_data_float(result->data));
00560 double cdata = 0;
00561 double ron2 = result->ron * result->ron;
00562 int nx_ny = result->nx * result->ny;
00563 double ron_div_conad = result->ron / result->conad;
00564 double crpix1=1.;
00565 double crpix2=1.;
00566 double crval1=1.;
00567 double crval2=1.;
00568 double cdelt1=1.;
00569 double cdelt2=1.;
00570 for (i = 0; i < nx_ny; i++) {
00571
00572 cdata = data[i];
00573 if (cdata > 0) {
00574 errs[i] = sqrt(cdata * result->conad + ron2) / result->conad;
00575 } else {
00576 errs[i] = ron_div_conad;
00577 }
00578 }
00579
00580
00581 result->qual=cpl_image_new(result->nx,result->ny,XSH_PRE_QUAL_TYPE);
00582
00583 xsh_badpixelmap_flag_saturated_pixels(result, instr, cor_val,
00584 flag_neg_and_thresh_pix, &nsat);
00585 frac_sat = (double) nsat / (nx_ny);
00586
00587 xsh_pfits_set_wcs(result->data_header,crpix1,crval1,cdelt1,crpix2,crval2,cdelt2);
00588 xsh_pfits_set_wcs(result->errs_header,crpix1,crval1,cdelt1,crpix2,crval2,cdelt2);
00589 xsh_pfits_set_wcs(result->qual_header,crpix1,crval1,cdelt1,crpix2,crval2,cdelt2);
00590 check(xsh_pfits_set_nsat(result->data_header, nsat));
00591 check(xsh_pfits_set_frac_sat(result->data_header, frac_sat));
00592
00593 }
00594
00595 else {
00596 XSH_ASSURE_NOT_ILLEGAL(result->nx > 0 && result->ny > 0);
00597
00598 check(image = cpl_image_load(framename, XSH_PRE_DATA_TYPE, 0, 0));
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608
00609
00610
00611
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621
00622
00623
00624
00625
00626
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643 check(
00644 result->data = cpl_image_extract(image, result->cutx + 1,
00645 result->cuty + 1, result->naxis1 - result->cutmx,
00646 result->naxis2 - result->cutmy));
00647
00648 if (xsh_instrument_get_arm(instr) == XSH_ARM_UVB) {
00649
00650 check(cpl_image_turn(result->data, 2));
00651 }
00652
00653
00654
00655 result->qual=cpl_image_new(result->nx,result->ny,XSH_PRE_QUAL_TYPE);
00656
00657
00658 check(xsh_badpixelmap_flag_saturated_pixels(result, instr, cor_val,
00659 flag_neg_and_thresh_pix, &nsat));
00660 int nx_ny = result->nx * result->ny;
00661 frac_sat = (double) nsat / (nx_ny);
00662 check(xsh_pfits_set_nsat(result->data_header, nsat));
00663 check(xsh_pfits_set_frac_sat(result->data_header, frac_sat));
00664 if ( (xsh_instrument_get_arm(instr) == XSH_ARM_VIS) ) {
00665
00666
00667
00668 check(xsh_badpixelmap_count_range_pixels(result, 4800,5200, cor_val,
00669 &nsat,&frac_sat));
00670 check(xsh_pfits_set_n_range_pix(result->data_header, nsat));
00671 check(xsh_pfits_set_frac_range_pix(result->data_header, frac_sat));
00672
00673 }
00674 double crpix1=1.;
00675 double crpix2=1.;
00676 double crval1=1.;
00677 double crval2=1.;
00678 double cdelt1=xsh_instrument_get_binx(instr);;
00679 double cdelt2=xsh_instrument_get_biny(instr);
00680
00681 xsh_pfits_set_wcs(result->data_header,crpix1,crval1,cdelt1,crpix2,crval2,cdelt2);
00682 xsh_pfits_set_wcs(result->errs_header,crpix1,crval1,cdelt1,crpix2,crval2,cdelt2);
00683 xsh_pfits_set_wcs(result->qual_header,crpix1,crval1,cdelt1,crpix2,crval2,cdelt2);
00684
00685
00686
00687 check(result->errs = cpl_image_duplicate(result->data));
00688 check(errs = cpl_image_get_data_float(result->errs));
00689 check(data = cpl_image_get_data_float(result->data));
00690
00691
00692 if ((strcmp(frame_tag, XSH_BIAS_UVB) == 0)
00693 || (strcmp(frame_tag, XSH_BIAS_VIS) == 0)
00694 || (strcmp(frame_tag, XSH_RAW_IMA_SLIT_UVB) == 0)
00695 || (strcmp(frame_tag, XSH_RAW_IMA_SLIT_VIS) == 0)) {
00696
00697
00698 float ron_div_conad = result->ron / result->conad;
00699
00700 for (i = 0; i < nx_ny; i++) {
00701 errs[i] = ron_div_conad;
00702 }
00703 }
00704
00705 else if ((strcmp(frame_tag, XSH_LINEARITY_UVB) == 0)
00706 || (strcmp(frame_tag, XSH_LINEARITY_VIS) == 0)
00707 || (strcmp(frame_tag, XSH_RAW_BP_MAP_NL_UVB) == 0)
00708 || (strcmp(frame_tag, XSH_RAW_BP_MAP_NL_VIS) == 0)
00709 || (strcmp(frame_tag, XSH_BP_MAP_NL_UVB) == 0)
00710 || (strcmp(frame_tag, XSH_BP_MAP_NL_VIS) == 0)) {
00711
00712 for (i = 0; i < nx_ny; i++) {
00713 errs[i] = 0;
00714 }
00715 } else {
00716
00717 int bias_x, bias_y;
00718 float* mbias_data = NULL;
00719 double ron2 = result->ron * result->ron;
00720 double cdata = 0;
00721 double ron_div_conad = result->ron / result->conad;
00722
00723 int flag_err_comp = 0;
00724 if (bias_data != (cpl_image *)-1) {
00725
00726
00727 xsh_msg("pre_overscan=%d",pre_overscan_corr);
00728 if (pre_overscan_corr == 0) {
00729
00730
00731 check(bias_x = cpl_image_get_size_x(bias_data));
00732 check(bias_y = cpl_image_get_size_y(bias_data));
00733 xsh_msg_dbg_medium(
00734 "bias_x=%d nx=%d bias_y=%d ny=%d", bias_x, result->nx, bias_y, result->ny);
00735 XSH_ASSURE_NOT_ILLEGAL_MSG(
00736 bias_x == result->nx,
00737 "Master bias X size different from raw frame X size. Input image frames must match in arm and bin!");
00738 XSH_ASSURE_NOT_ILLEGAL_MSG(
00739 bias_y == result->ny,
00740 "Master bias Y size different from raw frame Y size. Input image frames must match in arm and bin!");
00741
00742 flag_err_comp = 1;
00743 check( mbias_data = cpl_image_get_data_float( bias_data));
00744 for (i = 0; i < nx_ny; i++) {
00745
00746 cdata = data[i] - mbias_data[i];
00747 if (cdata > 0) {
00748 errs[i] = sqrt(cdata * result->conad + ron2) / result->conad;
00749 } else {
00750 errs[i] = ron_div_conad;
00751 }
00752 }
00753
00754 }
00755 }
00756
00757 if (flag_err_comp == 0) {
00758
00759 for (i = 0; i < nx_ny; i++) {
00760
00761 cdata = data[i];
00762 if (cdata > 0) {
00763 errs[i] = sqrt(cdata * result->conad + ron2) / result->conad;
00764 } else {
00765 errs[i] = ron_div_conad;
00766 }
00767 }
00768
00769 }
00770
00771 }
00772
00773 }
00774
00775
00776 if (bpmap != NULL) {
00777 check(bpfilename = cpl_frame_get_filename(bpmap));
00778 xsh_msg("Use Bad pixel map file %s\n", bpfilename);
00779 check(bplist = cpl_propertylist_load(bpfilename, 0));
00780
00781 check(bpnaxis1 = xsh_pfits_get_naxis1(bplist));
00782 check(bpnaxis2 = xsh_pfits_get_naxis2(bplist));
00783 assure(bpnaxis1 == result->nx && bpnaxis2 == result->ny,
00784 CPL_ERROR_ILLEGAL_INPUT,
00785 "qual image %d %d must have same size of data\
00786 image %d %d",
00787 bpnaxis1, bpnaxis2, result->nx, result->ny);
00788 cpl_image* ima_ref_bp = cpl_image_load(bpfilename, XSH_PRE_QUAL_TYPE, 0, 0);
00789 xsh_badpixelmap_image_coadd(&(result->qual), ima_ref_bp,mode_or);
00790 xsh_free_image(&ima_ref_bp);
00791 }
00792
00793
00794
00795
00796 check(xsh_image_flag_bp(result->data, result->qual, instr));
00797
00798 cleanup: if (cpl_error_get_code() != CPL_ERROR_NONE) {
00799 xsh_pre_free(&result);
00800 result = NULL;
00801 }
00802 xsh_free_image(&image);
00803 xsh_free_propertylist(&bplist);
00804
00805 return result;
00806 }
00807
00808
00814
00815 void xsh_pre_free(xsh_pre** pre)
00816 {
00817 if (pre && *pre) {
00818 xsh_free_image(&((*pre)->data));
00819 xsh_free_propertylist(&((*pre)->data_header));
00820 xsh_free_image(&((*pre)->errs));
00821 xsh_free_propertylist(&((*pre)->errs_header));
00822 xsh_free_image(&((*pre)->qual));
00823 xsh_free_propertylist(&((*pre)->qual_header));
00824 cpl_free(*pre);
00825 *pre = NULL;
00826 }
00827 }
00828
00829
00840
00841 xsh_pre* xsh_pre_load (cpl_frame * frame, xsh_instrument* instr)
00842 {
00843
00844 xsh_pre * result = NULL;
00845
00846 const char *filename = NULL;
00847 int extension = 0;
00848 cpl_propertylist* data_header = NULL;
00849
00850
00851
00852 XSH_ASSURE_NOT_NULL(frame);
00853 XSH_ASSURE_NOT_NULL(instr);
00854 XSH_ASSURE_NOT_NULL(cpl_frame_get_tag (frame));
00855 check (filename = cpl_frame_get_filename (frame));
00856
00857 XSH_CALLOC(result, xsh_pre,1);
00858
00859 result->instrument = instr;
00860 check(result->group = cpl_frame_get_group(frame));
00861
00862
00863 XSH_ASSURE_NOT_ILLEGAL(cpl_frame_get_nextensions(frame) == 2);
00864
00865
00866 extension = 0;
00867 check_msg (data_header = cpl_propertylist_load (filename,extension),
00868 "Cannot read the FITS header from '%s' extension %d",
00869 filename, extension);
00870 check(xsh_pre_init(result,data_header, instr));
00871
00872 result->nx = result->naxis1;
00873 result->ny = result->naxis2;
00874 result->decode_bp = instr->decode_bp;
00875
00876
00877 check_msg (result->data = cpl_image_load (filename,XSH_PRE_DATA_TYPE,0,0),
00878 "Error loading image from %s extension 0", filename);
00879
00880
00881 check_msg (result->errs_header = cpl_propertylist_load (filename,1),
00882 "Cannot read the FITS header from '%s' extension 1",filename);
00883 assure(strcmp(xsh_pfits_get_extname(result->errs_header),"ERRS") == 0,
00884 CPL_ERROR_ILLEGAL_INPUT,"extension 1 must be a errs extension");
00885 check_msg (result->errs = cpl_image_load (filename, XSH_PRE_ERRS_TYPE,0,1),
00886 "Error loading image from %s extension 1", filename);
00887
00888 check_msg (result->qual_header = cpl_propertylist_load (filename,2),
00889 "Cannot read the FITS header from '%s' extension 2",filename);
00890 assure(strcmp("QUAL",xsh_pfits_get_extname (result->qual_header)) == 0,
00891 CPL_ERROR_ILLEGAL_INPUT,"extension 2 must be a qual extension");
00892 check_msg (result->qual = cpl_image_load (filename, XSH_PRE_QUAL_TYPE,0,2),
00893 "Error loading image from %s extension 2", filename);
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915
00916
00917
00918
00919
00920
00921
00922
00923
00924
00925
00926
00927
00928
00929
00930 cleanup:
00931 if (cpl_error_get_code () != CPL_ERROR_NONE) {
00932 xsh_error_msg("can't load frame %s",cpl_frame_get_filename(frame));
00933 xsh_pre_free(&result);
00934 }
00935 return result;
00936 }
00937
00938
00944
00945 xsh_pre * xsh_pre_duplicate (const xsh_pre * pre)
00946 {
00947 xsh_pre *result = NULL;
00948
00949 assure(pre != NULL, CPL_ERROR_NULL_INPUT, "Null PRE");
00950
00951
00952 result = (xsh_pre*)(cpl_malloc (sizeof (xsh_pre)));
00953 assure (result != NULL, CPL_ERROR_ILLEGAL_OUTPUT,
00954 "Memory allocation failed!");
00955
00956
00957 result->data = NULL;
00958 result->data_header = NULL;
00959 result->errs = NULL;
00960 result->errs_header = NULL;
00961 result->qual = NULL;
00962 result->qual_header = NULL;
00963 result->instrument = pre->instrument;
00964
00965
00966 check(result->nx = xsh_pre_get_nx(pre));
00967 check(result->ny = xsh_pre_get_ny(pre));
00968 check(result->group = xsh_pre_get_group(pre));
00969 result->pszx = pre->pszx;
00970 result->pszy = pre->pszy;
00971 result->gain = pre->gain;
00972 result->exptime = pre->exptime;
00973
00974 check_msg(result->data_header = cpl_propertylist_duplicate(
00975 pre->data_header),"can't copy data header");
00976 check_msg(result->data = cpl_image_duplicate(pre->data),
00977 "can't copy data image");
00978
00979
00980 check_msg(result->errs_header = cpl_propertylist_duplicate(
00981 pre->errs_header),"can't copy errs header");
00982 check_msg(result->errs = cpl_image_duplicate(pre->errs),
00983 "can't copy errs image");
00984
00985
00986 check_msg(result->qual_header = cpl_propertylist_duplicate(
00987 pre->qual_header),"can't copy qual header");
00988
00989 check_msg(result->qual = cpl_image_duplicate(pre->qual),
00990 "can't copy qual image");
00991 result->decode_bp = pre->decode_bp;
00992
00993 cleanup:
00994 if (cpl_error_get_code () != CPL_ERROR_NONE) {
00995 xsh_pre_free(&result);
00996 result = NULL;
00997 }
00998 return result;
00999 }
01000
01001
01010
01011 cpl_frame* xsh_pre_save (const xsh_pre * pre,
01012 const char *filename,
01013 const char *tag,
01014 int temp )
01015 {
01016 cpl_frame *product_frame = NULL;
01017
01018 XSH_ASSURE_NOT_NULL(pre);
01019 XSH_ASSURE_NOT_NULL(filename);
01020
01021
01022 xsh_pfits_set_bunit(pre->data_header,XSH_BUNIT_FLUX_REL_C);
01023 xsh_pfits_set_bunit(pre->errs_header,XSH_BUNIT_FLUX_REL_C);
01024 xsh_pfits_set_bunit(pre->qual_header,XSH_BUNIT_NONE_C);
01025
01026 check( xsh_pfits_set_pcatg( pre->data_header,tag));
01027 check_msg (cpl_image_save (pre->data, filename, XSH_PRE_DATA_BPP,
01028 pre->data_header, CPL_IO_DEFAULT),
01029 "Could not save data to %s extension 0", filename);
01030 check_msg (cpl_image_save (pre->errs, filename, XSH_PRE_ERRS_BPP,
01031 pre->errs_header, CPL_IO_EXTEND),
01032 "Could not save errs to %s extension 1", filename);
01033 check_msg (cpl_image_save (pre->qual, filename, XSH_PRE_QUAL_BPP,
01034 pre->qual_header, CPL_IO_EXTEND),
01035 "Could not save qual to %s extension 2", filename);
01036
01037 product_frame = cpl_frame_new ();
01038 XSH_ASSURE_NOT_NULL( product_frame);
01039
01040 check ((cpl_frame_set_filename (product_frame, filename),
01041 cpl_frame_set_tag(product_frame,tag),
01042 cpl_frame_set_type (product_frame, CPL_FRAME_TYPE_IMAGE),
01043 cpl_frame_set_group (product_frame, xsh_pre_get_group(pre)) )) ;
01044
01045
01046 if ( temp != 0 ) {
01047 check( cpl_frame_set_level(product_frame,
01048 CPL_FRAME_LEVEL_TEMPORARY));
01049 xsh_add_temporary_file( filename ) ;
01050 }
01051
01052
01053 cleanup:
01054 if (cpl_error_get_code () != CPL_ERROR_NONE) {
01055 xsh_free_frame(&product_frame);
01056 product_frame = NULL;
01057 }
01058 return product_frame;
01059 }
01060
01061
01073
01074
01075 cpl_frame*
01076 xsh_pre_save_product(xsh_pre *pre,
01077 cpl_frame* frame,
01078 cpl_frameset* frameset,
01079 const cpl_parameterlist* parameters,
01080 const char* recipe_id,
01081 const char *prefix)
01082 {
01083 cpl_frame* result = NULL;
01084 char filename[256];
01085 time_t now ;
01086 char* date = NULL;
01087 const char* tag=NULL;
01088
01089 XSH_ASSURE_NOT_NULL( pre);
01090 XSH_ASSURE_NOT_NULL( frame);
01091 XSH_ASSURE_NOT_NULL( parameters);
01092 XSH_ASSURE_NOT_NULL( recipe_id);
01093 XSH_ASSURE_NOT_NULL( pre->instrument);
01094
01095
01096 check( cpl_frame_set_group (frame, CPL_FRAME_GROUP_PRODUCT));
01097 #if defined CPL_VERSION_CODE && CPL_VERSION_CODE >= CPL_VERSION(4, 8, 0)
01098 check (cpl_dfs_setup_product_header (pre->data_header,
01099 frame, frameset, parameters,
01100 recipe_id, pre->instrument->pipeline_id,
01101 pre->instrument->dictionary,NULL));
01102 #else
01103 check (cpl_dfs_setup_product_header (pre->data_header,
01104 frame, frameset, parameters,
01105 recipe_id, pre->instrument->pipeline_id,
01106 pre->instrument->dictionary));
01107 #endif
01108
01109 if ( prefix == NULL ) {
01110 sprintf(filename,"PRODUCT_%s",cpl_frame_get_filename (frame));
01111 }
01112 else if ( xsh_time_stamp_get() ) {
01113 time( &now ) ;
01114 date = xsh_sdate_utc(&now);
01115 sprintf( filename, "%s_%dx%d_%s.fits", prefix, pre->binx, pre->biny,
01116 date);
01117 }
01118 else
01119 sprintf( filename, "%s_%dx%d.fits", prefix, pre->binx, pre->biny );
01120 check(tag=xsh_pfits_get_pcatg(pre->data_header));
01121 check(result = xsh_pre_save(pre, filename, tag,0));
01122
01123 cpl_frame_set_type (result, CPL_FRAME_TYPE_IMAGE),
01124 cpl_frame_set_group (result, CPL_FRAME_GROUP_PRODUCT),
01125 cpl_frame_set_level (result, CPL_FRAME_LEVEL_FINAL);
01126 cleanup:
01127 if (cpl_error_get_code () != CPL_ERROR_NONE) {
01128 xsh_free_frame(&result);
01129 result = NULL;
01130 }
01131 XSH_FREE( date ) ;
01132
01133 return result;
01134 }
01135
01136
01149
01150 xsh_pre* xsh_pre_new (int nx, int ny)
01151 {
01152 xsh_pre *result = NULL;
01153
01154 assure (nx > 0 && ny > 0, CPL_ERROR_ILLEGAL_INPUT,
01155 "Illegal image size: %dx%d", nx, ny);
01156
01157 XSH_CALLOC( result, xsh_pre, 1);
01158
01159 result->nx = nx;
01160 result->ny = ny;
01161
01162 check( result->data = cpl_image_new (nx, ny, XSH_PRE_DATA_TYPE));
01163 check( result->errs = cpl_image_new (nx, ny, XSH_PRE_ERRS_TYPE));
01164 check( result->qual = cpl_image_new (nx, ny, XSH_PRE_QUAL_TYPE));
01165 check( result->data_header = cpl_propertylist_new());
01166 check( result->errs_header = cpl_propertylist_new());
01167 check( result->qual_header = cpl_propertylist_new());
01168
01169 cleanup:
01170 if (cpl_error_get_code () != CPL_ERROR_NONE) {
01171 xsh_pre_free ( &result);
01172 result = NULL;
01173 }
01174 return result;
01175 }
01176
01177
01183
01184 int xsh_pre_get_nx (const xsh_pre * pre)
01185 {
01186 int result = 0;
01187
01188 XSH_ASSURE_NOT_NULL( pre );
01189 result = pre->nx;
01190
01191 cleanup:
01192 return result;
01193 }
01194
01195
01201
01202 int xsh_pre_get_ny (const xsh_pre * pre)
01203 {
01204 int result = 0;
01205
01206 XSH_ASSURE_NOT_NULL( pre );
01207 result = pre->ny;
01208
01209 cleanup:
01210 return result;
01211 }
01212
01213
01214
01220
01221 int xsh_pre_get_binx (const xsh_pre * pre)
01222 {
01223 int result = 0;
01224
01225 XSH_ASSURE_NOT_NULL( pre );
01226 result = pre->binx;
01227
01228 cleanup:
01229 return result;
01230 }
01231
01232
01238
01239 int xsh_pre_get_biny (const xsh_pre * pre)
01240 {
01241 int result = 0;
01242
01243 XSH_ASSURE_NOT_NULL( pre );
01244 result = pre->biny;
01245
01246 cleanup:
01247 return result;
01248 }
01249
01250
01256
01257 float xsh_pre_get_pszx (const xsh_pre * pre)
01258 {
01259 float result = 0.0;
01260 assure (pre != NULL, CPL_ERROR_NULL_INPUT, "Null PRE");
01261 result = pre->pszx;
01262
01263 cleanup:
01264 return result;
01265 }
01266
01267
01276
01277
01278 void xsh_pre_from_raw_get(xsh_pre* pre, double raw_x, double raw_y,
01279 double* x, double* y)
01280 {
01281
01282 XSH_ASSURE_NOT_NULL(pre);
01283 XSH_ASSURE_NOT_NULL(x);
01284 XSH_ASSURE_NOT_NULL(y);
01285
01286
01287
01288
01289
01290
01291 if( xsh_instrument_get_arm(pre->instrument) == XSH_ARM_NIR){
01293 *x = raw_y ;
01294 *y = pre->ny + pre->cutx - raw_x;
01295 }
01296 else{
01297 *x = raw_x - pre->cutx;
01298 *y = raw_y - pre->cuty;
01299 }
01300
01301 cleanup:
01302 return;
01303 }
01304
01305
01311
01312 float xsh_pre_get_pszy (const xsh_pre * pre)
01313 {
01314 float result = 0.0;
01315
01316 XSH_ASSURE_NOT_NULL(pre);
01317 result = pre->pszy;
01318
01319 cleanup:
01320 return result;
01321 }
01322
01323
01329
01330 float xsh_pre_get_gain (const xsh_pre * pre)
01331 {
01332 float result = 0.0;
01333
01334 XSH_ASSURE_NOT_NULL(pre);
01335 result = pre->gain;
01336
01337 cleanup:
01338 return result;
01339 }
01340
01346
01347 cpl_frame_group xsh_pre_get_group (const xsh_pre * pre)
01348 {
01349 cpl_frame_group result = CPL_FRAME_GROUP_NONE;
01350
01351 XSH_ASSURE_NOT_NULL(pre);
01352 result = pre->group;
01353
01354 cleanup:
01355 return result;
01356 }
01357
01363
01364 cpl_mask* xsh_pre_get_bpmap(const xsh_pre * pre) {
01365 int* qual = NULL;
01366 cpl_mask* mask = NULL;
01367 cpl_binary* binary = NULL;
01368 int nx_ny = 0;
01369 int i = 0;
01370
01371 XSH_ASSURE_NOT_NULL(pre);
01372
01373 check(mask = cpl_image_get_bpm(pre->qual));
01374 check(qual = cpl_image_get_data_int(pre->qual));
01375 check(binary = cpl_mask_get_data(mask));
01376 nx_ny = pre->nx * pre->ny;
01377 for (i = 0; i < nx_ny; i++) {
01378 if ( (qual[i] & pre->decode_bp) > 0 ) {
01379
01380 binary[i] = CPL_BINARY_1;
01381 }
01382 }
01383
01384 cleanup: return mask;
01385 }
01386
01387
01407
01408
01409 void xsh_pre_add (xsh_pre* self, const xsh_pre * right)
01410 {
01411 float* errs1 = NULL;
01412 float* errs2 = NULL;
01413 int i = 0;
01414 cpl_mask* mask = NULL;
01415 cpl_binary* binary =NULL;
01416 int* qual = NULL;
01417
01418 XSH_ASSURE_NOT_NULL(self);
01419 XSH_ASSURE_NOT_NULL(right);
01420
01421
01422 assure (xsh_pre_get_nx (self) == xsh_pre_get_nx (right) &&
01423 xsh_pre_get_ny (self) == xsh_pre_get_ny (right),
01424 CPL_ERROR_INCOMPATIBLE_INPUT,
01425 "Image sizes don't match: %dx%d and %dx%d",
01426 xsh_pre_get_nx (self), xsh_pre_get_ny (self),
01427 xsh_pre_get_nx (right), xsh_pre_get_ny (right));
01428
01429
01430 check (cpl_image_add(self->data, right->data));
01431
01432
01433 check(errs1 = cpl_image_get_data_float(self->errs));
01434 check(errs2 = cpl_image_get_data_float(right->errs));
01435
01436 for(i=0;i< self->nx*self->ny; i++){
01437 errs1[i] = sqrt(pow(errs1[i],2)+pow(errs2[i],2));
01438 }
01439
01440
01441
01442
01443 if( (xsh_pre_get_group(right) == CPL_FRAME_GROUP_CALIB) ){
01444
01445 check( mask = xsh_pre_get_bpmap(right));
01446 check(binary = cpl_mask_get_data(mask));
01447 check(qual = cpl_image_get_data_int(self->qual));
01448 for(i=0;i<self->nx*self->ny;i++){
01449 if (binary[i]){
01450 qual[i] |= QFLAG_CALIB_FILE_DEFECT;
01451 }
01452 }
01453 }
01454
01455 else {
01456
01457
01458
01459
01460 xsh_badpixelmap_or( self, right ) ;
01461 }
01462 cleanup:
01463 return;
01464 }
01465
01466
01483 cpl_frameset* xsh_pre_frameset_subtract_frame( cpl_frameset *set,
01484 cpl_frame *sub,
01485 const char* spec,
01486 xsh_instrument *instr )
01487 {
01488 int i=0;
01489 int size=0;
01490
01491 cpl_frame* frm=NULL;
01492 cpl_frame* cor=NULL;
01493 cpl_frameset* result=NULL;
01494 char filename[256];
01495 const char * name=NULL;
01496 size=cpl_frameset_get_size(set);
01497 result=cpl_frameset_new();
01498 for(i=0;i<size;i++) {
01499 frm=cpl_frameset_get_frame(set,i);
01500 name=cpl_frame_get_filename(frm);
01501 sprintf(filename,"SUB_%s_%d_%s",spec,i,name);
01502 cor=xsh_pre_frame_subtract(frm,sub,filename,instr,1);
01503 cpl_frameset_insert(result,cor);
01504 }
01505
01506 return result;
01507
01508 }
01509
01510
01527 cpl_frame*
01528 xsh_pre_frame_subtract( cpl_frame *one,
01529 cpl_frame *two,
01530 const char *filename,
01531 xsh_instrument *instr,
01532 const int clean_tmp)
01533 {
01534 xsh_pre * pre1 = NULL ;
01535 xsh_pre * pre2 = NULL ;
01536 xsh_pre * pre_result = NULL ;
01537 cpl_frame * result = NULL ;
01538 const char* tag=NULL;
01539
01540
01541 XSH_ASSURE_NOT_NULL ( one);
01542 XSH_ASSURE_NOT_NULL ( two);
01543 XSH_ASSURE_NOT_NULL ( filename);
01544 XSH_ASSURE_NOT_NULL ( instr);
01545
01546
01547 check ( pre1 = xsh_pre_load( one, instr));
01548 check ( pre2 = xsh_pre_load( two, instr));
01549
01550
01551 check( pre_result = xsh_pre_duplicate( pre1));
01552 check ( xsh_pre_subtract( pre_result, pre2));
01553
01554 check(tag=cpl_frame_get_tag(one));
01555
01556 check( result = xsh_pre_save( pre_result, filename,tag,0));
01557
01558
01559 check ((cpl_frame_set_filename (result, filename),
01560 cpl_frame_set_type (result, CPL_FRAME_TYPE_IMAGE),
01561 cpl_frame_set_group (result, xsh_pre_get_group(pre_result)),
01562 cpl_frame_set_level (result, CPL_FRAME_LEVEL_TEMPORARY),
01563 cpl_frame_set_tag( result,tag)));
01564 if(clean_tmp) {
01565 xsh_add_temporary_file( filename ) ;
01566 }
01567 cleanup:
01568 xsh_pre_free( &pre1);
01569 xsh_pre_free( &pre2);
01570 xsh_pre_free( &pre_result);
01571 return result;
01572 }
01573
01574
01587
01588
01589 void xsh_pre_subtract (xsh_pre* self, const xsh_pre * right)
01590 {
01591
01592 float* errs1 = NULL;
01593 float* errs2 = NULL;
01594 int i = 0;
01595 cpl_mask* mask = NULL;
01596 cpl_binary* binary =NULL;
01597 int* qual = NULL;
01598
01599
01600 XSH_ASSURE_NOT_NULL( self);
01601 XSH_ASSURE_NOT_NULL( right);
01602
01603
01604 assure (xsh_pre_get_nx (self) == xsh_pre_get_nx (right) &&
01605 xsh_pre_get_ny (self) == xsh_pre_get_ny (right),
01606 CPL_ERROR_INCOMPATIBLE_INPUT,
01607 "Image sizes don't match: %dx%d and %dx%d",
01608 xsh_pre_get_nx (self), xsh_pre_get_ny (self),
01609 xsh_pre_get_nx (right), xsh_pre_get_ny (right));
01610
01611
01612 check ( cpl_image_subtract( self->data, right->data));
01613
01614
01615 check( errs1 = cpl_image_get_data_float( self->errs));
01616 check( errs2 = cpl_image_get_data_float( right->errs));
01617
01618 for(i=0;i< self->nx*self->ny; i++){
01619 errs1[i] = sqrt(pow(errs1[i],2)+pow(errs2[i],2));
01620 }
01621
01622
01623 if( (xsh_pre_get_group(right) == CPL_FRAME_GROUP_CALIB) ){
01624 check( mask = xsh_pre_get_bpmap(right));
01625 check(binary = cpl_mask_get_data(mask));
01626 check(qual = cpl_image_get_data_int(self->qual));
01627 for(i=0;i<self->nx*self->ny;i++){
01628 if ( (binary[i] & self->decode_bp) > 0 ){
01629
01630 qual[i] |= QFLAG_CALIB_FILE_DEFECT;
01631 }
01632 }
01633 }
01634 else {
01635
01636 xsh_badpixelmap_or( self, right ) ;
01637 }
01638
01639 cleanup:
01640 return ;
01641 }
01642
01662
01663 xsh_pre* xsh_pre_subsample (xsh_pre* self, const int binx, const int biny, const int rescale,xsh_instrument* inst)
01664 {
01665
01666 xsh_pre* result=NULL;
01667 float *errsi = NULL;
01668 float *errso = NULL;
01669 float *datai = NULL;
01670 float *datao = NULL;
01671 int *quali = NULL;
01672 int *qualo = NULL;
01673 int i = 0;
01674 int j = 0;
01675 int nx_ny=0;
01676 int nx=0;
01677 int ny=0;
01678 int m=0;
01679 int k=0;
01680 int sx=0;
01681 int sy=0;
01682
01683 int pixeli=0;
01684 int pixelo=0;
01685
01686 int j_biny=0;
01687 int j_nx=0;
01688 int nx_binx=0;
01689 float inv_binx_biny=0;
01690
01691 assure (self != NULL, CPL_ERROR_NULL_INPUT, "Null image!");
01692 assure (binx >0, CPL_ERROR_ILLEGAL_INPUT, "binx <=0!");
01693 assure (biny >0, CPL_ERROR_ILLEGAL_INPUT, "biny <=0!");
01694
01695
01696 check(datai = cpl_image_get_data_float(self->data));
01697 check(errsi = cpl_image_get_data_float(self->errs));
01698 check(quali = cpl_image_get_data_int(self->qual));
01699
01700 sx=self->nx;
01701 sy=self->ny;
01702 nx=sx/binx;
01703 ny=sy/biny;
01704
01705
01706 result=xsh_pre_new(nx,ny);
01707 check(datao = cpl_image_get_data_float(result->data));
01708 check(errso = cpl_image_get_data_float(result->errs));
01709 check(qualo = cpl_image_get_data_int(result->qual));
01710
01711 nx_binx=sx;
01712 int cpix=0;
01713 int cpix_k=0;
01714
01715
01716 for (j = 0; j < ny; j++) {
01717 j_biny = j*biny;
01718 j_nx = j*nx;
01719 for (i = 0; i < nx; i++) {
01720 pixeli = j_biny*nx_binx + (i*binx);
01721 pixelo = j_nx + i;
01722
01723
01724 for (m = 0; m < biny; m++) {
01725 cpix = pixeli +m*nx_binx;
01726 for (k = 0; k < binx;k++) {
01727
01728 cpix_k = cpix + k;
01729 datao[pixelo] += datai[cpix_k];
01730 errso[pixelo] += errsi[cpix_k] * errsi[cpix_k];
01731 qualo[pixelo] |= quali[cpix_k];
01732
01733 }
01734 }
01735 errso[pixelo] = sqrt(errso[pixelo]);
01736 }
01737 }
01738
01739 if (rescale > 0) {
01740 nx_ny=nx*ny;
01741 inv_binx_biny=1./(binx*biny);
01742
01743 for (i = 0; i < nx_ny; i++) {
01744 datao[i] *= inv_binx_biny;
01745 errso[i] *= inv_binx_biny;
01746 }
01747 }
01748
01749 cleanup:
01750 return result;
01751 }
01752
01753
01773
01774 void xsh_pre_divide (xsh_pre* self, const xsh_pre * right, double threshold)
01775 {
01776
01777 float *errs1 = NULL;
01778 float *errs2 = NULL;
01779 float *data1 = NULL;
01780 float *data2 = NULL;
01781 int *qual1 = NULL;
01782 int *qual2 = NULL;
01783 int i = 0;
01784 int nx_ny=0;
01785 assure (self != NULL, CPL_ERROR_NULL_INPUT, "Null image!");
01786 assure (right != NULL, CPL_ERROR_NULL_INPUT, "Null image!");
01787
01788
01789 assure (xsh_pre_get_nx (self) == xsh_pre_get_nx (right) &&
01790 xsh_pre_get_ny (self) == xsh_pre_get_ny (right),
01791 CPL_ERROR_INCOMPATIBLE_INPUT,
01792 "Image sizes don't match: %dx%d and %dx%d",
01793 xsh_pre_get_nx (self), xsh_pre_get_ny (self),
01794 xsh_pre_get_nx (right), xsh_pre_get_ny (right));
01795
01796
01797
01798 check(data1 = cpl_image_get_data_float(self->data));
01799 check(data2 = cpl_image_get_data_float(right->data));
01800 check(errs1 = cpl_image_get_data_float(self->errs));
01801 check(errs2 = cpl_image_get_data_float(right->errs));
01802 check(qual1 = cpl_image_get_data_int(self->qual));
01803 check(qual2 = cpl_image_get_data_int(right->qual));
01804 nx_ny=self->nx*self->ny;
01805
01806 for(i=0;i< nx_ny; i++){
01807
01808 if ( (qual2[i] & self->decode_bp) > 0 ) {
01809
01810 if( (xsh_pre_get_group(right) == CPL_FRAME_GROUP_CALIB) ){
01811 qual1[i] |= QFLAG_CALIB_FILE_DEFECT;
01812 }
01813 else {
01814 qual1[i] |= qual2[i];
01815 }
01816 }
01817 else if ( fabs(data2[i]) < threshold){
01818 qual1[i] |= QFLAG_DIVISOR_ZERO;
01819 errs1[i] = 1;
01820 data1[i] = 0;
01821 }
01822 else {
01823 double d1 = 0.0, d2 = 0.0;
01824 double e1 = 0.0, e2 =0.0;
01825 double error = 0.0;
01826
01827 d1 = data1[i];
01828 d2 = data2[i];
01829 e1 = errs1[i];
01830 e2 = errs2[i];
01831 error = fabs( 1.0/d2) * sqrt( (e1*e1) + (e2*e2*d1*d1)/(d2*d2) );
01832 errs1[i] = (float) error;
01833 data1[i] = (float)(d1/d2);
01834 }
01835 }
01836
01837 cleanup:
01838 return;
01839 }
01840
01841
01860
01861 void xsh_pre_multiply (xsh_pre* self, const xsh_pre * right, double threshold)
01862 {
01863
01864 float *errs1 = NULL;
01865 float *errs2 = NULL;
01866 float *data1 = NULL;
01867 float *data2 = NULL;
01868 int *qual1 = NULL;
01869 int *qual2 = NULL;
01870 int i = 0;
01871 int nx_ny=0;
01872 assure (self != NULL, CPL_ERROR_NULL_INPUT, "Null image!");
01873 assure (right != NULL, CPL_ERROR_NULL_INPUT, "Null image!");
01874
01875
01876 assure (xsh_pre_get_nx (self) == xsh_pre_get_nx (right) &&
01877 xsh_pre_get_ny (self) == xsh_pre_get_ny (right),
01878 CPL_ERROR_INCOMPATIBLE_INPUT,
01879 "Image sizes don't match: %dx%d and %dx%d",
01880 xsh_pre_get_nx (self), xsh_pre_get_ny (self),
01881 xsh_pre_get_nx (right), xsh_pre_get_ny (right));
01882
01883
01884
01885 check(data1 = cpl_image_get_data_float(self->data));
01886 check(data2 = cpl_image_get_data_float(right->data));
01887 check(errs1 = cpl_image_get_data_float(self->errs));
01888 check(errs2 = cpl_image_get_data_float(right->errs));
01889 check(qual1 = cpl_image_get_data_int(self->qual));
01890 check(qual2 = cpl_image_get_data_int(right->qual));
01891 nx_ny=self->nx*self->ny;
01892 for(i=0;i< nx_ny; i++){
01893
01894 if ( (qual2[i] & self->decode_bp) > 0 ) {
01895
01896 if( (xsh_pre_get_group(right) == CPL_FRAME_GROUP_CALIB) ){
01897 qual1[i] |= QFLAG_CALIB_FILE_DEFECT;
01898 }
01899 else {
01900 qual1[i] |= qual2[i];
01901 }
01902 }
01903 else if ( fabs(data2[i]) > threshold){
01904 qual1[i] |= QFLAG_OUTSIDE_DATA_RANGE;
01905 errs1[i] = 1;
01906 data1[i] = 0;
01907 }
01908 else {
01909 double d1 = 0.0, d2 = 0.0;
01910 double e1 = 0.0, e2 =0.0;
01911 double error = 0.0;
01912
01913 d1 = data1[i];
01914 d2 = data2[i];
01915 e1 = errs1[i];
01916 e2 = errs2[i];
01917 error = sqrt( d2*d2*e1*e1 + d1*d1*e2*e2 );
01918 errs1[i] = (float) error;
01919 data1[i] = (float)(d1*d2);
01920 }
01921 }
01922
01923 cleanup:
01924 return;
01925 }
01926
01927
01928
01933
01934 void xsh_pre_normalize( xsh_pre* self)
01935 {
01936 double val1, ct1;
01937 int i, rej, i1;
01938
01939 XSH_ASSURE_NOT_NULL(self);
01940 i = 0;
01941
01942
01943 do {
01944 i++;
01945 check(val1 = cpl_image_get(self->data, i, 1, &rej));
01946 }
01947 while (val1 == 0 || rej == 1);
01948 i1 = i;
01949
01950
01951 check(cpl_image_normalise( self->data, CPL_NORM_MEAN));
01952
01953
01954 check(ct1 = val1/ cpl_image_get(self->data, i1, 1, &rej));
01955
01956 xsh_msg("normalize estimate pixel (%d,1) : %f",i1,ct1);
01957
01958
01959 check( cpl_image_divide_scalar( self->errs, ct1));
01960
01961 cleanup:
01962 return;
01963 }
01964
01974 void xsh_pre_median_mean_stdev( xsh_pre * preFrame, double * mean,
01975 double * median, double * stdev )
01976 {
01977 int i, ng, nx, ny ;
01978 float * ppix = NULL;
01979 int * pbad = NULL;
01980 cpl_vector * ptemp = NULL;
01981 int nx_ny=0;
01982 XSH_ASSURE_NOT_NULL( preFrame ) ;
01983 XSH_ASSURE_NOT_NULL( mean ) ;
01984 XSH_ASSURE_NOT_NULL( median ) ;
01985 XSH_ASSURE_NOT_NULL( stdev ) ;
01986
01987 nx = xsh_pre_get_nx (preFrame);
01988 assure (nx != 0, cpl_error_get_code (), "Cant get X size");
01989 ny = xsh_pre_get_ny (preFrame);
01990 assure (ny != 0, cpl_error_get_code (), "Cant get Y size");
01991
01992 check( ptemp = cpl_vector_new( nx*ny )) ;
01993 check( ppix = cpl_image_get_data_float( preFrame->data ) ) ;
01994 check( pbad = cpl_image_get_data_int( preFrame->qual ) ) ;
01995 nx_ny=nx*ny;
01996 for( ng = 0, i = 0 ; i < nx_ny ; i++ ) {
01997 if ( (pbad[i] & preFrame->decode_bp) == 0 ){
01998
01999 check( cpl_vector_set( ptemp, ng, (double)(ppix[i]) )) ;
02000 ng++ ;
02001 }
02002 }
02003
02004
02005 check( cpl_vector_set_size( ptemp, ng ) );
02006 check( *mean = cpl_vector_get_mean( ptemp ) );
02007 check( *stdev = cpl_vector_get_stdev( ptemp ) );
02008 check( *median = cpl_vector_get_median( ptemp ) );
02009
02010 cleanup:
02011 if (cpl_error_get_code() != CPL_ERROR_NONE){
02012 *mean = 0.0;
02013 *stdev = 0.0;
02014 *median = 0.0;
02015 }
02016 xsh_free_vector( &ptemp ) ;
02017 return;
02018 }
02019
02033 void xsh_pre_median_mean_stdev_window( xsh_pre * preFrame, double * mean,
02034 double * median, double * stdev,
02035 const int llx, const int lly,
02036 const int urx, const int ury )
02037 {
02038 int i=0, ng=0, nx=0, ny=0 ;
02039 int vx=0,vy=0;
02040 float * ppix = NULL;
02041 int * pbad = NULL;
02042 cpl_vector * ptemp = NULL;
02043 int j=0;
02044
02045 XSH_ASSURE_NOT_NULL( preFrame ) ;
02046 XSH_ASSURE_NOT_NULL( mean ) ;
02047 XSH_ASSURE_NOT_NULL( median ) ;
02048 XSH_ASSURE_NOT_NULL( stdev ) ;
02049
02050 nx = xsh_pre_get_nx (preFrame);
02051 assure (nx != 0, cpl_error_get_code (), "Cant get X size");
02052 ny = xsh_pre_get_ny (preFrame);
02053 assure (ny != 0, cpl_error_get_code (), "Cant get Y size");
02054
02055 vx=urx-llx+1;
02056 vy=ury-lly+1;
02057
02058 check( ptemp = cpl_vector_new( vx*vy )) ;
02059 check( ppix = cpl_image_get_data_float( preFrame->data ) ) ;
02060 check( pbad = cpl_image_get_data_int( preFrame->qual ) ) ;
02061
02062 ng=0;
02063
02064 for( j = lly-1 ; j < ury ; j++ ) {
02065 for( i = llx-1 ; i < urx ; i++ ) {
02066
02067 if ( (pbad[i] & preFrame->decode_bp) == 0) {
02068
02069 check( cpl_vector_set( ptemp, ng, (double)(ppix[j*nx+i]) )) ;
02070 ng++ ;
02071 }
02072 }
02073 }
02074
02075 cpl_table* tab=NULL;
02076 cpl_table* ext=NULL;
02077 int kappa=5;
02078 int niter1=2;
02079 int niter2=4;
02080
02081
02082 if(ng>0) {
02083 tab=cpl_table_new(ng);
02084 cpl_table_wrap_double(tab,cpl_vector_get_data(ptemp),"VAL");
02085
02086
02087 *median=cpl_table_get_column_median(tab,"VAL");
02088 *mean=cpl_table_get_column_mean(tab,"VAL");
02089 *stdev=cpl_table_get_column_stdev(tab,"VAL");
02090 for(i=0;i<niter1;i++) {
02091
02092 cpl_table_and_selected_double(tab,"VAL",CPL_LESS_THAN,
02093 *median+kappa*(*stdev));
02094 cpl_table_and_selected_double(tab,"VAL",CPL_GREATER_THAN,
02095 *median-kappa*(*stdev));
02096 xsh_free_table(&ext);
02097 ext=cpl_table_extract_selected(tab);
02098 *median=cpl_table_get_column_median(ext,"VAL");
02099 *mean=cpl_table_get_column_mean(ext,"VAL");
02100 *stdev=cpl_table_get_column_stdev(ext,"VAL");
02101
02102 }
02103
02104
02105 for(i=0;i<niter2;i++) {
02106 cpl_table_and_selected_double(tab,"VAL",CPL_LESS_THAN,
02107 *mean+kappa*(*stdev));
02108 cpl_table_and_selected_double(tab,"VAL",CPL_GREATER_THAN,
02109 *mean-kappa*(*stdev));
02110 xsh_free_table(&ext);
02111 ext=cpl_table_extract_selected(tab);
02112 *median=cpl_table_get_column_median(ext,"VAL");
02113 *mean=cpl_table_get_column_mean(ext,"VAL");
02114 *stdev=cpl_table_get_column_stdev(ext,"VAL");
02115
02116 }
02117 xsh_free_table(&ext);
02118 ext=cpl_table_extract_selected(tab);
02119
02120 cpl_table_unwrap(tab,"VAL");
02121 *median=cpl_table_get_column_median(ext,"VAL");
02122 *mean=cpl_table_get_column_mean(ext,"VAL");
02123 *stdev=cpl_table_get_column_stdev(ext,"VAL");
02124 } else {
02125 *mean = -999.0;
02126 *stdev = -999.0;
02127 *median = -999.0;
02128 }
02129
02130
02131 cleanup:
02132 if (cpl_error_get_code() != CPL_ERROR_NONE){
02133 *mean = 0.0;
02134 *stdev = 0.0;
02135 *median = 0.0;
02136 }
02137 xsh_free_vector( &ptemp ) ;
02138 xsh_free_table(&tab);
02139 xsh_free_table(&ext);
02140 return;
02141 }
02142
02143
02164
02165 int xsh_pre_window_best_median_flux_pos( xsh_pre* pre, int xcen, int ycen,
02166 int search_window_hsize, int running_median_hsize, int* xadj, int* yadj)
02167 {
02168 int search_win_xmin, search_win_xmax, search_win_ymin, search_win_ymax;
02169
02170 int* qual = NULL;
02171 double* median_tab = NULL;
02172 int median_box_size = 0;
02173 double max_flux = -99999;
02174 int ibox, jbox;
02175 int xpos = -1, ypos = -1;
02176 int result= 0;
02177 int status=0;
02178 XSH_ASSURE_NOT_NULL( pre);
02179 XSH_ASSURE_NOT_NULL( xadj);
02180 XSH_ASSURE_NOT_NULL( yadj);
02181 XSH_CMP_INT( xcen, >=, 0, "Check central x position",);
02182 XSH_CMP_INT( xcen, <, pre->nx, "Check central x position",);
02183 XSH_CMP_INT( ycen, >=, 0, "Check central x position",);
02184 XSH_CMP_INT( ycen, <, pre->ny, "Check central x position",);
02185
02186 median_box_size = 1+running_median_hsize*2;
02187
02188 search_win_xmin = xcen-search_window_hsize;
02189 search_win_xmax = xcen+search_window_hsize;
02190 search_win_ymin = ycen-search_window_hsize;
02191 search_win_ymax = ycen+search_window_hsize;
02192
02193 if ( search_win_xmin < 0){
02194 search_win_xmin = 0;
02195 }
02196 if ( search_win_xmax >= pre->nx){
02197 search_win_xmax = pre->nx-1;
02198 }
02199 if ( search_win_ymin < 0){
02200 search_win_ymin = 0;
02201 }
02202 if ( search_win_ymax >= pre->ny){
02203 search_win_ymax = pre->ny-1;
02204 }
02205
02206
02207 check( qual = cpl_image_get_data_int( pre->qual));
02208 XSH_CALLOC(median_tab, double, median_box_size* median_box_size);
02209
02210 int xc,yc;
02211 double med_flux = 0.0;
02212
02213 for (jbox=search_win_ymin; jbox <= (search_win_ymax+1-median_box_size);
02214 jbox++){
02215 yc = jbox+running_median_hsize;
02216 int array_shift=yc*pre->nx;
02217 for (ibox=search_win_xmin; ibox <= (search_win_xmax+1-median_box_size);
02218 ibox++){
02219
02220 med_flux = xsh_pre_data_window_median_flux_pa( pre,
02221 ibox, jbox, median_box_size, median_box_size, median_tab,&status);
02222
02223 if ( cpl_error_get_code() == CPL_ERROR_NONE){
02224
02225 if (max_flux < med_flux) {
02226 xc = ibox+running_median_hsize;
02227 if ( (qual[xc+array_shift] & pre->decode_bp ) == 0) {
02228
02229
02230 max_flux = med_flux;
02231 xpos = xc;
02232 ypos = yc;
02233
02234 }
02235
02236 }
02237
02238 }
02239 else{
02240 xsh_error_reset();
02241 }
02242 }
02243 }
02244 if (xpos < 0 || ypos < 0){
02245 xsh_msg_dbg_high( "No valid pixels in the search box");
02246 result = 1;
02247 }
02248 else{
02249 *xadj = xpos;
02250 *yadj = ypos;
02251 }
02252
02253 cleanup:
02254 XSH_FREE( median_tab);
02255 return result;
02256 }
02257
02258
02259
02260
02274
02275 double xsh_pre_data_window_median_flux_pa(xsh_pre* pre, int x, int y,
02276 int size_x, int size_y, double* tab,int* status)
02277 {
02278
02279 cpl_vector* v = NULL;
02280 float* data = NULL;
02281 int* qual = NULL;
02282 int ix = 0, iy = 0;
02283 int size = 0;
02284 *status=0;
02285
02286 XSH_ASSURE_NOT_NULL(pre);
02287 XSH_ASSURE_NOT_ILLEGAL(x >=1 && x <= pre->nx);
02288 XSH_ASSURE_NOT_ILLEGAL(y >= 1 && y <= pre->ny);
02289 XSH_ASSURE_NOT_ILLEGAL(size_x > 0);
02290 XSH_ASSURE_NOT_ILLEGAL(size_y > 0);
02291 XSH_ASSURE_NOT_NULL(tab);
02292
02293 x = x-1;
02294 y = y-1;
02295
02296 if ( (x+size_x) >= pre->nx){
02297 size_x = pre->nx-x;
02298 }
02299 if ( (y+size_y) >= pre->ny){
02300 size_y = pre->ny-y;
02301 }
02302
02303
02304 check(data = cpl_image_get_data_float(pre->data));
02305
02306 check(qual = cpl_image_get_data_int(pre->qual));
02307
02308
02309 int offset=0;
02310 int x_plus_size_x = x + size_x;
02311 int y_plus_size_y = y + size_y;
02312 int ix_plus_offset = 0;
02313 for( iy=y; iy< y_plus_size_y; iy++){
02314 offset=iy*pre->nx;
02315 for( ix=x; ix<x_plus_size_x;ix++){
02316 ix_plus_offset = ix + offset;
02317 if ( (qual[ix_plus_offset] & pre->decode_bp) == 0 ) {
02318
02319 tab[size] = data[ix_plus_offset];
02320 size++;
02321 }
02322 }
02323 }
02324
02325 double flux = 0.0;
02326 if (size==0) {
02327
02328 *status=1;
02329 } else if (size==1) {
02330
02331 flux = tab[0];
02332 } else if (size>1) {
02333
02334 check(v = cpl_vector_wrap(size, tab));
02335 check( flux = cpl_vector_get_median(v));
02336 }
02337 cleanup:
02338 xsh_unwrap_vector(&v);
02339 return flux;
02340 }
02341
02342
02343
02344
02350
02351 const cpl_propertylist *
02352 xsh_pre_get_header_const (const xsh_pre * pre)
02353 {
02354 cpl_propertylist *header = NULL;
02355
02356 XSH_ASSURE_NOT_NULL(pre);
02357 header = pre->data_header;
02358
02359 cleanup:
02360 return header;
02361 }
02362
02363
02369
02370 cpl_propertylist *
02371 xsh_pre_get_header (xsh_pre * pre)
02372 {
02373 XSH_ASSURE_NOT_NULL(pre);
02374
02375 cleanup:
02376 return (cpl_propertylist *) xsh_pre_get_header_const (pre);
02377 }
02378
02379
02380
02386
02387 const cpl_image* xsh_pre_get_data_const (const xsh_pre * pre)
02388 {
02389 cpl_image *data = NULL;
02390
02391 XSH_ASSURE_NOT_NULL(pre);
02392 data = pre->data;
02393
02394 cleanup:
02395 return data;
02396 }
02397
02398
02404
02405 cpl_image* xsh_pre_get_data (xsh_pre * pre)
02406 {
02407 return (cpl_image *) xsh_pre_get_data_const (pre);
02408 }
02409
02410
02416
02417 const cpl_image * xsh_pre_get_errs_const (const xsh_pre * pre)
02418 {
02419 cpl_image *errs = NULL;
02420
02421 XSH_ASSURE_NOT_NULL(pre);
02422 errs = pre->errs;
02423
02424 cleanup:
02425 return errs;
02426 }
02427
02428
02434
02435 cpl_image* xsh_pre_get_errs (xsh_pre * pre)
02436 {
02437 return (cpl_image *) xsh_pre_get_errs_const (pre);
02438 }
02439
02440
02446
02447 const cpl_image* xsh_pre_get_qual_const (const xsh_pre * pre)
02448 {
02449 cpl_image *qual = NULL;
02450
02451 XSH_ASSURE_NOT_NULL(pre);
02452 qual = pre->qual;
02453
02454 cleanup:
02455 return qual;
02456 }
02457
02458
02464 cpl_image* xsh_pre_get_qual (xsh_pre * pre)
02465 {
02466 return (cpl_image *) xsh_pre_get_qual_const (pre);
02467 }
02468
02469
02475
02476 const double* xsh_pre_get_data_buffer_const (const xsh_pre * pre)
02477 {
02478 double *buffer = NULL;
02479
02480 XSH_ASSURE_NOT_NULL(pre);
02481
02482
02483
02484 passure (cpl_image_get_type (pre->data) == CPL_TYPE_DOUBLE, " ");
02485 buffer = (double *) cpl_image_get_data (pre->data);
02486
02487 cleanup:
02488 return buffer;
02489 }
02490
02491
02497
02498 double* xsh_pre_get_data_buffer (xsh_pre * pre)
02499 {
02500 return (double *) xsh_pre_get_data_buffer_const (pre);
02501 }
02502
02503
02509
02510 const double* xsh_pre_get_errs_buffer_const (const xsh_pre * pre)
02511 {
02512 double *buffer = NULL;
02513
02514 XSH_ASSURE_NOT_NULL(pre);
02515 passure (cpl_image_get_type (pre->errs) == CPL_TYPE_DOUBLE, " ");
02516 buffer = (double *) cpl_image_get_data (pre->errs);
02517
02518 cleanup:
02519 return buffer;
02520 }
02521
02522
02528
02529 double* xsh_pre_get_errs_buffer (xsh_pre * pre)
02530 {
02531 return (double *) xsh_pre_get_errs_buffer_const(pre);
02532 }
02533
02534
02542
02543 void
02544 xsh_pre_dump (const xsh_pre * pre, FILE * stream)
02545 {
02546 cpl_stats *stats = NULL;
02547
02548 if (pre == NULL) {
02549 fprintf (stream, "Null");
02550 }
02551 else {
02552
02553 stats = cpl_stats_new_from_image (pre->data, CPL_STATS_ALL);
02554
02555 cpl_stats_dump (stats, CPL_STATS_ALL, stream);
02556
02557
02558
02559 fflush (stream);
02560 }
02561
02562 xsh_free_stats (&stats);
02563 return;
02564 }
02565
02566
02567
02573 void xsh_pre_multiply_scalar (const xsh_pre * pre, double x)
02574 {
02575
02576 XSH_ASSURE_NOT_NULL( pre);
02577
02578
02579 check (cpl_image_multiply_scalar(pre->data, x));
02580
02581
02582 check (cpl_image_multiply_scalar(pre->errs, fabs(x)));
02583
02584 cleanup:
02585 return;
02586 }
02587
02593 void xsh_pre_divide_scalar (const xsh_pre * pre, double x)
02594 {
02595
02596 XSH_ASSURE_NOT_NULL( pre);
02597 XSH_ASSURE_NOT_ILLEGAL( x != 0);
02598
02599
02600 check (cpl_image_divide_scalar(pre->data, x));
02601
02602
02603 check (cpl_image_divide_scalar(pre->errs, fabs(x)));
02604
02605 cleanup:
02606 return;
02607 }
02608
02615 void xsh_pre_add_scalar (const xsh_pre * pre, double x)
02616 {
02617
02618 XSH_ASSURE_NOT_NULL( pre);
02619 XSH_ASSURE_NOT_ILLEGAL( x != 0);
02620
02621
02622 check (cpl_image_add_scalar(pre->data, x));
02623
02624 cleanup:
02625 return;
02626 }
02627
02628
02634 void xsh_pre_subtract_scalar (const xsh_pre * pre, double x)
02635 {
02636
02637 XSH_ASSURE_NOT_NULL( pre);
02638 XSH_ASSURE_NOT_ILLEGAL( x != 0);
02639
02640
02641 check (cpl_image_subtract_scalar(pre->data, x));
02642
02643 cleanup:
02644 return;
02645 }
02646
02653 void xsh_pre_multiply_image(const xsh_pre *pre, cpl_image* img)
02654 {
02655 cpl_image *abs = NULL;
02656
02657 XSH_ASSURE_NOT_NULL( pre);
02658 XSH_ASSURE_NOT_NULL( img);
02659
02660
02661 check ( cpl_image_multiply(pre->data, img));
02662 check( abs = cpl_image_abs_create( img));
02663 check ( cpl_image_multiply(pre->errs, abs));
02664
02665 cleanup:
02666 xsh_free_image( &abs);
02667 return;
02668 }
02669
02670
02677 cpl_image* xsh_pre_abs (const xsh_pre * pre)
02678 {
02679
02680 cpl_image *result = NULL;
02681 int *result_data = NULL;
02682 float *data = NULL;
02683 int i, size;
02684
02685 XSH_ASSURE_NOT_NULL( pre);
02686
02687
02688 check ( data = cpl_image_get_data_float( pre->data));
02689 check( result = cpl_image_new( pre->nx, pre->ny, CPL_TYPE_INT));
02690 check( result_data = cpl_image_get_data_int( result));
02691
02692 size = pre->nx*pre->ny;
02693
02694 for(i =0; i < size; i++){
02695 if ( data[i] < 0){
02696 result_data[i] = -1;
02697 data[i] = -data[i];
02698 }
02699 else{
02700 result_data[i] = 1;
02701 }
02702 }
02703
02704 cleanup:
02705 return result;
02706 }
02707
02708
02717
02718
02719 cpl_frame*
02720 xsh_frameset_average_pre(cpl_frameset *set,
02721 xsh_instrument* instr,
02722 const char* tag)
02723 {
02724 cpl_frame* result=NULL;
02725 cpl_frame* frame=NULL;
02726 cpl_image* data=NULL;
02727 cpl_image* errs=NULL;
02728 cpl_image* qual=NULL;
02729
02730 xsh_pre* pre=NULL;
02731 cpl_imagelist* iml_data=NULL;
02732 cpl_imagelist* iml_errs=NULL;
02733 cpl_imagelist* iml_qual=NULL;
02734
02735 cpl_propertylist* plist=NULL;
02736 char name_o[256];
02737 const char* name=NULL;
02738 cpl_frame* frm_tmp=NULL;
02739 int i=0;
02740 int size=0;
02741
02742
02743
02744 size=cpl_frameset_get_size(set);
02745 iml_data=cpl_imagelist_new();
02746 iml_errs=cpl_imagelist_new();
02747 iml_qual=cpl_imagelist_new();
02748
02749 for(i=0;i<size;i++) {
02750 frame=cpl_frameset_get_frame(set,i);
02751 pre=xsh_pre_load(frame,instr);
02752
02753
02754 cpl_imagelist_set(iml_data,cpl_image_duplicate(pre->data),i);
02755 cpl_imagelist_set(iml_errs,cpl_image_duplicate(pre->errs),i);
02756 cpl_imagelist_set(iml_qual,cpl_image_duplicate(pre->qual),i);
02757 xsh_pre_free(&pre);
02758 }
02759
02760
02761 pre=xsh_pre_load(cpl_frameset_get_frame(set,0),instr);
02762 xsh_free_image(&(pre->data));
02763 xsh_free_image(&(pre->errs));
02764 xsh_free_image(&(pre->qual));
02765 pre->data=cpl_imagelist_collapse_create(iml_data);
02766 pre->errs=cpl_imagelist_collapse_create(iml_errs);
02767 pre->qual=cpl_imagelist_collapse_create(iml_qual);
02768
02769 cpl_image_divide_scalar(pre->data,size);
02770 cpl_image_divide_scalar(pre->errs,size);
02771 cpl_image_divide_scalar(pre->qual,size);
02772
02773 frame=cpl_frameset_get_frame(set,0);
02774 name=cpl_frame_get_filename(frame);
02775 plist=cpl_propertylist_load(name,0);
02776
02777 sprintf(name_o,"%s.fits",tag);
02778 check(frm_tmp=xsh_pre_save(pre,name_o,tag,0));
02779
02780 result=xsh_frame_product(name_o,tag,CPL_FRAME_TYPE_IMAGE,
02781 CPL_FRAME_GROUP_PRODUCT,CPL_FRAME_LEVEL_FINAL);
02782
02783 cleanup:
02784 xsh_free_frame(&frm_tmp);
02785 xsh_free_image(&data);
02786 xsh_free_image(&errs);
02787 xsh_free_image(&qual);
02788
02789 xsh_free_imagelist(&iml_data);
02790 xsh_free_imagelist(&iml_errs);
02791 xsh_free_imagelist(&iml_qual);
02792
02793 xsh_pre_free(&pre);
02794 xsh_free_propertylist(&plist);
02795
02796 return result;
02797 }
02798
02806 void xsh_pre_turn( xsh_pre * pre, int rot )
02807 {
02808 cpl_image * img = NULL ;
02809
02810 XSH_ASSURE_NOT_NULL( pre ) ;
02811
02812 check( img = xsh_pre_get_data( pre ) ) ;
02813 check( cpl_image_turn( img, rot ) ) ;
02814
02815 check( img = xsh_pre_get_errs( pre ) ) ;
02816 check( cpl_image_turn( img, rot ) ) ;
02817
02818 check( img = xsh_pre_get_qual( pre ) ) ;
02819 check( cpl_image_turn( img, rot ) ) ;
02820
02821 cleanup:
02822 return ;
02823 }
02824
02839 void xsh_pre_extract( xsh_pre *pre, int xmin, int ymin, int xmax, int ymax)
02840 {
02841 cpl_image * img = NULL ;
02842 cpl_image * ext_img = NULL ;
02843
02844 XSH_ASSURE_NOT_NULL( pre);
02845
02846 check( img = xsh_pre_get_data( pre));
02847
02848 XSH_ASSURE_NOT_NULL( img);
02849
02850 check( ext_img = cpl_image_extract( img, xmin, ymin, xmax, ymax));
02851 xsh_free_image( &img);
02852 pre->data = ext_img;
02853
02854 check( img = xsh_pre_get_errs( pre));
02855 check( ext_img = cpl_image_extract( img, xmin, ymin, xmax, ymax));
02856 xsh_free_image( &img);
02857 pre->errs = ext_img;
02858
02859 check( img = xsh_pre_get_qual( pre));
02860 check( ext_img = cpl_image_extract( img, xmin, ymin, xmax, ymax));
02861 xsh_free_image( &img);
02862 pre->qual = ext_img;
02863
02864 cleanup:
02865 return;
02866 }
02875 void xsh_pre_flip( xsh_pre * pre, int angle )
02876 {
02877 cpl_image * img = NULL ;
02878
02879 XSH_ASSURE_NOT_NULL( pre ) ;
02880
02881 check( img = xsh_pre_get_data( pre ) ) ;
02882 check( cpl_image_flip( img, angle ) ) ;
02883
02884 check( img = xsh_pre_get_errs( pre ) ) ;
02885 check( cpl_image_flip( img, angle ) ) ;
02886
02887 check( img = xsh_pre_get_qual( pre ) ) ;
02888 check( cpl_image_flip( img, angle ) ) ;
02889
02890 cleanup:
02891 return ;
02892 }