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 #include <math.h>
00031
00032
00037
00038
00042
00043
00044
00045 #include <xsh_data_instrument.h>
00046 #include <xsh_data_arclist.h>
00047 #include <xsh_data_linetilt.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 <cpl.h>
00054 #include <xsh_utils_table.h>
00055
00056
00057 #define XSH_MAX_SHIFT_Y 10.
00058
00059
00060
00061
00062 xsh_linetilt_list * xsh_linetilt_list_new( int size,
00063 cpl_propertylist * header )
00064 {
00065 xsh_linetilt_list * result = NULL ;
00066
00067 XSH_ASSURE_NOT_NULL( header ) ;
00068
00069
00070 check( result = cpl_malloc( sizeof( xsh_linetilt_list ) ) ) ;
00071 memset( result, 0, sizeof( xsh_linetilt_list ) ) ;
00072
00073 check( result->list = cpl_malloc( sizeof( xsh_linetilt * ) * size ) ) ;
00074 memset( result->list, 0, sizeof( xsh_linetilt * )*size ) ;
00075 result->full_size = size ;
00076 result->header = header ;
00077
00078 cleanup:
00079 return result ;
00080 }
00085
00086 void xsh_linetilt_list_free( xsh_linetilt_list ** list)
00087 {
00088 int i;
00089
00090 if (list && *list) {
00091 if ((*list)->list) {
00092 for (i=0; i< (*list)->size; i++) {
00093 xsh_linetilt * tilt = (*list)->list[i];
00094 xsh_linetilt_free( &tilt );
00095 }
00096 cpl_free((*list)->list);
00097 xsh_free_propertylist(&((*list)->header));
00098 }
00099 cpl_free(*list);
00100 *list = NULL;
00101 }
00102 }
00103
00108
00109 void xsh_linetilt_free( xsh_linetilt ** tilt)
00110 {
00111 if (tilt && (*tilt) ){
00112 if ((*tilt)->name != NULL) {
00113 cpl_free(( *tilt)->name );
00114 }
00115 cpl_free( *tilt );
00116 *tilt = NULL;
00117 }
00118 }
00119
00120 xsh_linetilt * xsh_linetilt_new( void )
00121 {
00122 xsh_linetilt * result = NULL ;
00123
00124 XSH_CALLOC( result, xsh_linetilt, 1) ;
00125
00126 cleanup:
00127 return result ;
00128 }
00129
00137 void xsh_linetilt_list_add( xsh_linetilt_list * list,
00138 xsh_linetilt * line, int idx )
00139 {
00140 XSH_ASSURE_NOT_NULL( list ) ;
00141 XSH_ASSURE_NOT_NULL( line ) ;
00142 list->list[idx] = line ;
00143 list->size++ ;
00144 cleanup:
00145 return ;
00146 }
00147
00159
00160 cpl_frame* xsh_linetilt_list_save(xsh_linetilt_list * list,
00161 xsh_instrument * instr,
00162 const char* filename,
00163 const char* tag,
00164 const double kappa,
00165 const int niter)
00166 {
00167 cpl_table* table = NULL;
00168 cpl_table* ext = NULL;
00169 cpl_frame * result = NULL ;
00170 int i=0;
00171
00172
00173
00174
00175
00176 XSH_ASSURE_NOT_NULL(list);
00177 XSH_ASSURE_NOT_NULL(filename);
00178
00179
00180 check( table = cpl_table_new( XSH_LINETILT_TABLE_NB_COL));
00181
00182
00183 check(
00184 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_WAVELENGTH,
00185 CPL_TYPE_FLOAT));
00186 check(
00187 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_WAVELENGTH,
00188 XSH_LINETILT_TABLE_UNIT_WAVELENGTH));
00189
00190 check(
00191 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_NAME,
00192 CPL_TYPE_STRING));
00193 check(
00194 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_NAME,
00195 XSH_LINETILT_TABLE_UNIT_NAME));
00196
00197 check(
00198 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_ORDER,
00199 CPL_TYPE_INT));
00200 check(
00201 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_ORDER,
00202 XSH_LINETILT_TABLE_UNIT_ORDER));
00203
00204 check(
00205 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_FLUX,
00206 CPL_TYPE_DOUBLE));
00207 check(
00208 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_FLUX,
00209 XSH_LINETILT_TABLE_UNIT_FLUX));
00210
00211 check(
00212 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_INTENSITY,
00213 CPL_TYPE_DOUBLE));
00214 check(
00215 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_INTENSITY,
00216 XSH_LINETILT_TABLE_UNIT_INTENSITY));
00217
00218 check(
00219 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_CENPOSX,
00220 CPL_TYPE_DOUBLE));
00221 check(
00222 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_CENPOSX,
00223 XSH_LINETILT_TABLE_UNIT_CENPOSX));
00224
00225 check(
00226 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_CENPOSY,
00227 CPL_TYPE_DOUBLE));
00228 check(
00229 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_CENPOSY,
00230 XSH_LINETILT_TABLE_UNIT_CENPOSY));
00231
00232
00233 check(
00234 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_GAUSSY,
00235 CPL_TYPE_DOUBLE));
00236 check(
00237 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_GAUSSY,
00238 XSH_LINETILT_TABLE_UNIT_GAUSSY));
00239
00240 check(
00241 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_TILTY,
00242 CPL_TYPE_DOUBLE));
00243 check(
00244 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_TILTY,
00245 XSH_LINETILT_TABLE_UNIT_TILTY));
00246
00247 check(
00248 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_FWHM,
00249 CPL_TYPE_DOUBLE));
00250 check(
00251 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_FWHM,
00252 XSH_LINETILT_TABLE_UNIT_FWHM));
00253
00254 check(
00255 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY,
00256 CPL_TYPE_DOUBLE));
00257 check(
00258 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_SHIFTY,
00259 XSH_LINETILT_TABLE_UNIT_SHIFTY));
00260
00261 check(
00262 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_TILT,
00263 CPL_TYPE_DOUBLE));
00264 check(
00265 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_TILT,
00266 XSH_LINETILT_TABLE_UNIT_TILT));
00267
00268 check(
00269 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_CHISQ,
00270 CPL_TYPE_DOUBLE));
00271 check(
00272 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_CHISQ,
00273 XSH_LINETILT_TABLE_UNIT_CHISQ));
00274
00275 check(
00276 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_SPECRES,
00277 CPL_TYPE_DOUBLE));
00278 check(
00279 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_SPECRES,
00280 XSH_LINETILT_TABLE_UNIT_SPECRES));
00281 check(
00282 cpl_table_new_column(table,XSH_LINETILT_TABLE_COLNAME_FLAG,
00283 CPL_TYPE_INT));
00284 check(
00285 cpl_table_set_column_unit ( table, XSH_LINETILT_TABLE_COLNAME_FLAG,
00286 XSH_LINETILT_TABLE_UNIT_FLAG));
00287
00288
00289
00290
00291 check(cpl_table_set_size(table,list->size));
00292
00293
00294 for(i=0;i<list->size;i++){
00295 check(cpl_table_set_float(table,XSH_LINETILT_TABLE_COLNAME_WAVELENGTH,
00296 i,list->list[i]->wavelength));
00297 check(cpl_table_set_string(table,XSH_LINETILT_TABLE_COLNAME_NAME,
00298 i,list->list[i]->name));
00299 check(cpl_table_set_int(table,XSH_LINETILT_TABLE_COLNAME_ORDER,
00300 i,list->list[i]->order));
00301 check(cpl_table_set_double(table,XSH_LINETILT_TABLE_COLNAME_FLUX,
00302 i,list->list[i]->area));
00303 check(cpl_table_set_double(table,XSH_LINETILT_TABLE_COLNAME_INTENSITY,
00304 i,list->list[i]->intensity));
00305 check(cpl_table_set_double(table,XSH_LINETILT_TABLE_COLNAME_CENPOSX,
00306 i,list->list[i]->cenposx));
00307 check(cpl_table_set_double(table,XSH_LINETILT_TABLE_COLNAME_CENPOSY,
00308 i,list->list[i]->pre_pos_y));
00309 check(cpl_table_set_double(table,XSH_LINETILT_TABLE_COLNAME_GAUSSY,
00310 i,list->list[i]->cenposy));
00311 check(cpl_table_set_double(table,XSH_LINETILT_TABLE_COLNAME_TILTY,
00312 i,list->list[i]->tilt_y));
00313 check(cpl_table_set_double(table,XSH_LINETILT_TABLE_COLNAME_FWHM,
00314 i,list->list[i]->deltay));
00315 check(cpl_table_set_double(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY,
00316 i,list->list[i]->shift_y));
00317 check(cpl_table_set_double(table,XSH_LINETILT_TABLE_COLNAME_TILT,
00318 i,list->list[i]->tilt));
00319 check(cpl_table_set_double(table,XSH_LINETILT_TABLE_COLNAME_CHISQ,
00320 i,list->list[i]->chisq));
00321
00322 check(cpl_table_set_double(table,XSH_LINETILT_TABLE_COLNAME_SPECRES,
00323 i,list->list[i]->specres));
00324
00325 if( fabs(list->list[i]->shift_y)> XSH_MAX_SHIFT_Y ) {
00326 list->list[i]->flag=3;
00327
00328 }
00329
00330 if(list->list[i]->flag>0) {
00331 cpl_table_set_invalid(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY, i);
00332 cpl_table_set_invalid(table,XSH_LINETILT_TABLE_COLNAME_FWHM, i);
00333 cpl_table_set_invalid(table,XSH_LINETILT_TABLE_COLNAME_INTENSITY, i);
00334 }
00335 check(cpl_table_set_int(table,XSH_LINETILT_TABLE_COLNAME_FLAG,
00336 i,list->list[i]->flag));
00337 }
00338
00339
00340 int k=0;
00341 double yshift_std=0;
00342 double yshift_avg=0;
00343 double* pshift=NULL;
00344 pshift=cpl_table_get_data_double(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY);
00345
00346 for(k=0;k<niter;k++) {
00347 yshift_std=cpl_table_get_column_stdev(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY);
00348 yshift_avg=cpl_table_get_column_mean(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY);
00349 for(i=0;i<list->size;i++){
00350 if( fabs(pshift[i]-yshift_avg) > kappa*yshift_std ) {
00351 list->list[i]->flag=4;
00352 cpl_table_set_invalid(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY, i);
00353 cpl_table_set_invalid(table,XSH_LINETILT_TABLE_COLNAME_FWHM, i);
00354 cpl_table_set_invalid(table,XSH_LINETILT_TABLE_COLNAME_INTENSITY, i);
00355 }
00356 }
00357 }
00358 double avg;
00359 double med;
00360 double std;
00361 double wavg;
00362 double wstd;
00363 int iavg;
00364
00365 avg = cpl_table_get_column_mean(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY );
00366 med = cpl_table_get_column_median(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY );
00367 std = cpl_table_get_column_stdev(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY );
00368
00369 wstd = cpl_table_get_column_stdev(table, XSH_LINETILT_TABLE_COLNAME_FWHM);
00370 wavg = cpl_table_get_column_mean(table, XSH_LINETILT_TABLE_COLNAME_FWHM);
00371
00372 iavg = (int)cpl_table_get_column_mean(table, XSH_LINETILT_TABLE_COLNAME_INTENSITY);
00373 xsh_pfits_set_qc( list->header, &avg, QC_WAVECAL_DIFFYAVG,instr );
00374 xsh_pfits_set_qc( list->header, &med, QC_WAVECAL_DIFFYMED,instr );
00375 xsh_pfits_set_qc( list->header, &std, QC_WAVECAL_DIFFYSTD,instr );
00376 xsh_pfits_set_qc( list->header, &iavg, QC_WAVECAL_NLININT,instr );
00377 xsh_pfits_set_qc( list->header, &wavg, QC_WAVECAL_FWHMAVG,instr );
00378 xsh_pfits_set_qc( list->header, &wstd, QC_WAVECAL_FWHMRMS,instr );
00379
00380
00381 check( xsh_pfits_set_pcatg(list->header,tag));
00382 check(cpl_table_save(table, list->header, NULL, filename, CPL_IO_DEFAULT));
00383
00384
00385 check(result=xsh_frame_product(filename,
00386 XSH_GET_TAG_FROM_MODE( XSH_TILT_TAB, instr),
00387 CPL_FRAME_TYPE_TABLE,
00388 CPL_FRAME_GROUP_PRODUCT,
00389 CPL_FRAME_LEVEL_TEMPORARY));
00390 xsh_add_temporary_file( filename ) ;
00391
00392 cleanup:
00393 xsh_free_table(&ext);
00394 XSH_TABLE_FREE( table);
00395 return result ;
00396 }
00397
00398
00406
00407 double * xsh_linetilt_list_get_posx( xsh_linetilt_list * list)
00408 {
00409 double* res = NULL, *p ;
00410 int i, size ;
00411
00412 XSH_ASSURE_NOT_NULL( list );
00413 size = list->size ;
00414 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00415 for( p = res, i = 0 ; i<size ; i++, p++ )
00416 *p = list->list[i]->cenposx ;
00417
00418 cleanup:
00419 return res;
00420 }
00421
00429
00430 double * xsh_linetilt_list_get_posy( xsh_linetilt_list * list)
00431 {
00432 double* res = NULL, *p ;
00433 int i, size ;
00434
00435 XSH_ASSURE_NOT_NULL( list );
00436 size = list->size ;
00437 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00438 for( p = res, i = 0 ; i<size ; i++, p++ )
00439 *p = list->list[i]->cenposy ;
00440
00441 cleanup:
00442 return res;
00443 }
00444
00452
00453 double * xsh_linetilt_list_get_deltay( xsh_linetilt_list * list)
00454 {
00455 double* res = NULL, *p ;
00456 int i, size ;
00457
00458 XSH_ASSURE_NOT_NULL( list );
00459 size = list->size ;
00460
00461 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00462 for( p = res, i = 0 ; i<size ; i++, p++ )
00463 *p = list->list[i]->deltay ;
00464
00465
00466 cleanup:
00467 return res;
00468 }
00469
00477
00478 double * xsh_linetilt_list_get_sigma_y( xsh_linetilt_list * list)
00479 {
00480 double* res = NULL, *p ;
00481 int i, size ;
00482
00483 XSH_ASSURE_NOT_NULL( list );
00484 size = list->size ;
00485
00486 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00487 for( p = res, i = 0 ; i<size ; i++, p++ )
00488 *p = list->list[i]->chisq ;
00489
00490
00491 cleanup:
00492 return res;
00493 }
00494
00502
00503 double * xsh_linetilt_list_get_pre_posy( xsh_linetilt_list * list)
00504 {
00505 double* res = NULL, *p ;
00506 int i, size ;
00507
00508 XSH_ASSURE_NOT_NULL( list );
00509 size = list->size ;
00510
00511 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00512 for( p = res, i = 0 ; i<size ; i++, p++ )
00513 *p = list->list[i]->pre_pos_y ;
00514
00515
00516 cleanup:
00517 return res;
00518 }
00519
00527
00528 double * xsh_linetilt_list_get_orders( xsh_linetilt_list * list)
00529 {
00530 double* res = NULL, *p ;
00531 int i, size ;
00532
00533 XSH_ASSURE_NOT_NULL( list );
00534 size = list->size ;
00535 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00536 for( p = res, i = 0 ; i<size ; i++, p++ )
00537 *p = list->list[i]->order ;
00538
00539 cleanup:
00540 return res;
00541 }
00542
00550
00551 double * xsh_linetilt_list_get_wavelengths( xsh_linetilt_list * list)
00552 {
00553 double* res = NULL, *p ;
00554 int i, size ;
00555
00556 XSH_ASSURE_NOT_NULL( list );
00557 size = list->size ;
00558 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00559 for( p = res, i = 0 ; i<size ; i++, p++ )
00560 *p = list->list[i]->wavelength ;
00561
00562 cleanup:
00563 return res;
00564 }
00565
00573
00574 double * xsh_linetilt_list_get_slits( xsh_linetilt_list * list)
00575 {
00576 double* res = NULL, *p ;
00577 int i, size ;
00578
00579 XSH_ASSURE_NOT_NULL( list );
00580 size = list->size ;
00581 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00582 for( p = res, i = 0 ; i<size ; i++, p++ )
00583 *p = list->list[i]->slit ;
00584
00585 cleanup:
00586 return res;
00587 }
00588
00596
00597 int * xsh_linetilt_list_get_slit_index( xsh_linetilt_list * list)
00598 {
00599 int * res = NULL, *p ;
00600 int i, size ;
00601
00602 XSH_ASSURE_NOT_NULL( list );
00603 size = list->size ;
00604 check( res = cpl_malloc( list->size * sizeof(int) ) ) ;
00605 for( p = res, i = 0 ; i<size ; i++, p++ )
00606 *p = list->list[i]->slit_index ;
00607
00608 cleanup:
00609 return res;
00610 }
00611
00620 cpl_propertylist * xsh_linetilt_list_get_header( xsh_linetilt_list * list)
00621 {
00622 cpl_propertylist * res = NULL ;
00623
00624 XSH_ASSURE_NOT_NULL( list );
00625
00626 res = list->header ;
00627
00628 cleanup:
00629 return res;
00630 }
00631
00641 int xsh_linetilt_is_duplicate( xsh_linetilt_list * list, float lambda,
00642 int order )
00643 {
00644 int i, res = 0 ;
00645 XSH_ASSURE_NOT_NULL( list );
00646
00647 for( i = 0 ; i<list->size ; i++ ) {
00648 if ( list->list[i]->wavelength == lambda &&
00649 list->list[i]->order == order ) {
00650 res = 1 ;
00651 break ;
00652 }
00653 }
00654
00655 cleanup:
00656 return res ;
00657 }
00658
00659 #if 0
00660 static int xsh_arclist_lambda_compare(const void* one, const void* two){
00661 xsh_arcline** a = NULL;
00662 xsh_arcline** b = NULL;
00663 float la, lb;
00664
00665 a = (xsh_arcline**) one;
00666 b = (xsh_arcline**) two;
00667
00668 la = (*a)->wavelength;
00669 lb = (*b)->wavelength;
00670
00671 if (la <= lb)
00672 return -1;
00673 else
00674 return 1;
00675
00676
00677 }
00678
00679
00680
00687
00688 void xsh_arclist_lambda_sort(xsh_arclist* list){
00689 qsort(list->list,list->size,sizeof(xsh_arcline*),
00690 xsh_arclist_lambda_compare);
00691 }
00692
00693
00700
00701 int xsh_arclist_get_size(xsh_arclist* list){
00702 int i=0;
00703
00704 XSH_ASSURE_NOT_NULL(list);
00705 i = list->size;
00706
00707 cleanup:
00708 return i;
00709 }
00710
00711
00712
00719
00720 int xsh_arclist_get_nbrejected(xsh_arclist* list){
00721 int i=0;
00722
00723 XSH_ASSURE_NOT_NULL(list);
00724 i = list->nbrejected;
00725
00726 cleanup:
00727 return i;
00728 }
00729
00730
00738
00739 float xsh_arclist_get_wavelength(xsh_arclist* list, int index)
00740 {
00741 float f = 0.0;
00742
00743 XSH_ASSURE_NOT_NULL(list);
00744 XSH_ASSURE_NOT_ILLEGAL(index >= 0 && index < list->size);
00745 f = list->list[index]->wavelength;
00746
00747 cleanup:
00748 return f;
00749 }
00750
00751
00758
00759 void xsh_arclist_reject(xsh_arclist* list, int index)
00760 {
00761 XSH_ASSURE_NOT_NULL(list);
00762 XSH_ASSURE_NOT_ILLEGAL(index >= 0 && index < list->size);
00763
00764 list->rejected[index] = 1;
00765 list->nbrejected++;
00766
00767 cleanup:
00768 return;
00769
00770 }
00771
00772
00779
00780 void xsh_arclist_restore(xsh_arclist* list, int index)
00781 {
00782 XSH_ASSURE_NOT_NULL(list);
00783 XSH_ASSURE_NOT_ILLEGAL(index >= 0 && index < list->size);
00784
00785 list->rejected[index] = 0;
00786 list->nbrejected--;
00787
00788 cleanup:
00789 return;
00790
00791 }
00792
00799
00800 int xsh_arclist_is_rejected(xsh_arclist* list, int index)
00801 {
00802 int res = 0;
00803
00804 XSH_ASSURE_NOT_NULL(list);
00805 XSH_ASSURE_NOT_ILLEGAL(index >= 0 && index < list->size);
00806
00807 res = list->rejected[index];
00808 cleanup:
00809 return res;
00810 }
00811
00812
00818
00819 cpl_propertylist* xsh_arclist_get_header(xsh_arclist* list)
00820 {
00821 cpl_propertylist * res = NULL;
00822
00823 XSH_ASSURE_NOT_NULL(list);
00824 res = list->header;
00825 cleanup:
00826 return res;
00827 }
00828
00829
00835
00836 void xsh_dump_arclist( xsh_arclist* list)
00837 {
00838 int i = 0;
00839
00840 XSH_ASSURE_NOT_NULL(list);
00841
00842 xsh_msg( "ARCLINE_LIST Dump %d lines",list->size);
00843
00844 for(i=0; i< list->size; i++) {
00845 const char* name = list->list[i]->name;
00846 const char* comment = list->list[i]->comment;
00847 if (name == NULL) name ="";
00848 if (comment == NULL) comment ="";
00849 xsh_msg(" Wavelength %f name %s flux %d comment %s",
00850 list->list[i]->wavelength, name,
00851 list->list[i]->flux, comment);
00852 }
00853 xsh_msg( "END ARCLINE_LIST");
00854
00855 cleanup:
00856 return;
00857 }
00858
00859
00866
00867 xsh_arclist* xsh_arclist_load(cpl_frame* frame){
00868 cpl_table* table = NULL;
00869 const char* tablename = NULL;
00870 xsh_arclist* result = NULL;
00871 int i = 0;
00872
00873
00874 XSH_ASSURE_NOT_NULL(frame);
00875
00876
00877 check( tablename = cpl_frame_get_filename(frame));
00878
00879 XSH_TABLE_LOAD( table, tablename);
00880
00881
00882 XSH_CALLOC(result,xsh_arclist,1);
00883
00884
00885 check(result->size = cpl_table_get_nrow(table));
00886 XSH_CALLOC(result->list, xsh_arcline*, result->size);
00887 XSH_CALLOC(result->rejected, int, result->size);
00888 result->nbrejected = 0;
00889
00890 check(result->header = cpl_propertylist_load(tablename, 0));
00891
00892
00893 for(i=0;i<result->size;i++){
00894 const char* name ="";
00895 const char* comment ="";
00896 xsh_arcline* arc = (xsh_arcline*)cpl_malloc(sizeof(xsh_arcline));
00897
00898 check(xsh_get_table_value(table, XSH_ARCLIST_TABLE_COLNAME_WAVELENGTH,
00899 CPL_TYPE_FLOAT, i, &(arc->wavelength)));
00900 check(xsh_get_table_value(table, XSH_ARCLIST_TABLE_COLNAME_NAME,
00901 CPL_TYPE_STRING, i, &name));
00902 check(xsh_get_table_value(table, XSH_ARCLIST_TABLE_COLNAME_FLUX,
00903 CPL_TYPE_INT, i, &(arc->flux)));
00904 check(xsh_get_table_value(table, XSH_ARCLIST_TABLE_COLNAME_COMMENT,
00905 CPL_TYPE_STRING, i, &comment));
00906 if (name != NULL) {
00907 arc->name = xsh_stringdup(name);
00908 }
00909 else {
00910 arc->name = NULL;
00911 }
00912 if (comment != NULL) {
00913 arc->comment = xsh_stringdup(comment);
00914 }
00915 else {
00916 arc->comment = NULL;
00917 }
00918 result->list[i] = arc;
00919 }
00920
00921 cleanup:
00922 if (cpl_error_get_code () != CPL_ERROR_NONE) {
00923 xsh_error_msg("can't load frame %s",cpl_frame_get_filename(frame));
00924 xsh_arclist_free(&result);
00925 }
00926 XSH_TABLE_FREE( table);
00927 return result;
00928 }
00929
00930
00935
00936 void xsh_arcline_free(xsh_arcline** arc)
00937 {
00938 if (arc && (*arc)){
00939 if ((*arc)->name != NULL) {
00940 cpl_free((*arc)->name);
00941 }
00942 if ((*arc)->comment != NULL) {
00943 cpl_free((*arc)->comment);
00944 }
00945 cpl_free(*arc);
00946 *arc = NULL;
00947 }
00948 }
00949
00950
00955
00956 void xsh_arclist_free(xsh_arclist** list)
00957 {
00958 int i;
00959
00960 if (list && *list) {
00961 if ((*list)->list) {
00962 for (i=0; i< (*list)->size; i++) {
00963 xsh_arcline* arc = (*list)->list[i];
00964 xsh_arcline_free(&arc);
00965 }
00966 cpl_free((*list)->list);
00967 xsh_free_propertylist(&((*list)->header));
00968 }
00969 XSH_FREE((*list)->rejected);
00970 cpl_free(*list);
00971 *list = NULL;
00972 }
00973 }
00974
00975 void xsh_arclist_clean(xsh_arclist* list)
00976 {
00977 int i, j;
00978
00979 XSH_ASSURE_NOT_NULL(list);
00980
00981 j = 0;
00982 for(i=0;i<list->size;i++)
00983 {
00984 if(xsh_arclist_is_rejected(list,i)){
00985 xsh_arcline_free(&list->list[i]);
00986 }
00987 else{
00988 j++;
00989 list->list[j-1] = list->list[i];
00990 list->rejected[j] = 0;
00991 }
00992 }
00993 list->size = j;
00994 list->nbrejected = 0;
00995
00996 cleanup:
00997 return;
00998 }
00999
01008
01009 cpl_frame*
01010 xsh_arclist_save(xsh_arclist* list,const char* filename,const char* tag)
01011 {
01012 cpl_table* table = NULL;
01013 cpl_frame * result = NULL ;
01014 int i=0;
01015
01016 XSH_ASSURE_NOT_NULL(list);
01017 XSH_ASSURE_NOT_NULL(filename);
01018
01019
01020 check(table = cpl_table_new(XSH_ARCLIST_TABLE_NB_COL));
01021
01022
01023 check(
01024 cpl_table_new_column(table,XSH_ARCLIST_TABLE_COLNAME_WAVELENGTH,
01025 CPL_TYPE_FLOAT));
01026 check(
01027 cpl_table_set_column_unit ( table, XSH_ARCLIST_TABLE_COLNAME_WAVELENGTH,
01028 XSH_ARCLIST_TABLE_UNIT_WAVELENGTH));
01029 check(
01030 cpl_table_new_column(table,XSH_ARCLIST_TABLE_COLNAME_NAME,
01031 CPL_TYPE_STRING));
01032 check(
01033 cpl_table_set_column_unit ( table, XSH_ARCLIST_TABLE_COLNAME_NAME,
01034 XSH_ARCLIST_TABLE_UNIT_NAME));
01035
01036 check(
01037 cpl_table_new_column(table,XSH_ARCLIST_TABLE_COLNAME_FLUX,
01038 CPL_TYPE_INT));
01039 check(
01040 cpl_table_set_column_unit ( table, XSH_ARCLIST_TABLE_COLNAME_FLUX,
01041 XSH_ARCLIST_TABLE_UNIT_FLUX));
01042
01043 check(
01044 cpl_table_new_column(table,XSH_ARCLIST_TABLE_COLNAME_COMMENT,
01045 CPL_TYPE_STRING));
01046 check(
01047 cpl_table_set_column_unit ( table, XSH_ARCLIST_TABLE_COLNAME_COMMENT,
01048 XSH_ARCLIST_TABLE_UNIT_COMMENT));
01049
01050 check(cpl_table_set_size(table,list->size));
01051
01052
01053 for(i=0;i<list->size;i++){
01054 check(cpl_table_set_float(table,XSH_ARCLIST_TABLE_COLNAME_WAVELENGTH,
01055 i,list->list[i]->wavelength));
01056 check(cpl_table_set_string(table,XSH_ARCLIST_TABLE_COLNAME_NAME,
01057 i,list->list[i]->name));
01058 check(cpl_table_set_int(table,XSH_ARCLIST_TABLE_COLNAME_FLUX,
01059 i,list->list[i]->flux));
01060 check(cpl_table_set_string(table,XSH_ARCLIST_TABLE_COLNAME_COMMENT,
01061 i,list->list[i]->comment));
01062 }
01063
01064
01065 check(cpl_table_save(table, list->header, NULL, filename, CPL_IO_DEFAULT));
01066
01067
01068 check(result=xsh_frame_product(filename,
01069 tag,
01070 CPL_FRAME_TYPE_TABLE,
01071 CPL_FRAME_GROUP_PRODUCT,
01072 CPL_FRAME_LEVEL_TEMPORARY));
01073
01074
01075 cleanup:
01076 XSH_TABLE_FREE( table);
01077 return result ;
01078 }
01079 #endif
01080