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 check(cpl_table_set_int(table,XSH_LINETILT_TABLE_COLNAME_FLAG,
00328 i,3));
00329
00330 }
00331
00332 if(list->list[i]->flag>0) {
00333 cpl_table_set_invalid(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY, i);
00334 cpl_table_set_invalid(table,XSH_LINETILT_TABLE_COLNAME_FWHM, i);
00335 cpl_table_set_invalid(table,XSH_LINETILT_TABLE_COLNAME_INTENSITY, i);
00336 }
00337 check(cpl_table_set_int(table,XSH_LINETILT_TABLE_COLNAME_FLAG,
00338 i,list->list[i]->flag));
00339 }
00340
00341
00342 int k=0;
00343 double yshift_std=0;
00344 double yshift_avg=0;
00345 double* pshift=NULL;
00346 pshift=cpl_table_get_data_double(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY);
00347
00348 for(k=0;k<niter;k++) {
00349 yshift_std=cpl_table_get_column_stdev(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY);
00350 yshift_avg=cpl_table_get_column_mean(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY);
00351 for(i=0;i<list->size;i++){
00352 if( fabs(pshift[i]-yshift_avg) > kappa*yshift_std ) {
00353 list->list[i]->flag=4;
00354 cpl_table_set_invalid(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY, i);
00355 cpl_table_set_invalid(table,XSH_LINETILT_TABLE_COLNAME_FWHM, i);
00356 cpl_table_set_invalid(table,XSH_LINETILT_TABLE_COLNAME_INTENSITY, i);
00357 check(cpl_table_set_int(table,XSH_LINETILT_TABLE_COLNAME_FLAG,
00358 i,4));
00359 }
00360 }
00361 }
00362 double avg;
00363 double med;
00364 double std;
00365 double wavg;
00366 double wstd;
00367 int iavg;
00368
00369 avg = cpl_table_get_column_mean(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY );
00370 med = cpl_table_get_column_median(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY );
00371 std = cpl_table_get_column_stdev(table,XSH_LINETILT_TABLE_COLNAME_SHIFTY );
00372
00373 wstd = cpl_table_get_column_stdev(table, XSH_LINETILT_TABLE_COLNAME_FWHM);
00374 wavg = cpl_table_get_column_mean(table, XSH_LINETILT_TABLE_COLNAME_FWHM);
00375
00376 iavg = (int)cpl_table_get_column_mean(table, XSH_LINETILT_TABLE_COLNAME_INTENSITY);
00377 xsh_pfits_set_qc( list->header, &avg, QC_WAVECAL_DIFFYAVG,instr );
00378 xsh_pfits_set_qc( list->header, &med, QC_WAVECAL_DIFFYMED,instr );
00379 xsh_pfits_set_qc( list->header, &std, QC_WAVECAL_DIFFYSTD,instr );
00380 xsh_pfits_set_qc( list->header, &iavg, QC_WAVECAL_NLININT,instr );
00381 xsh_pfits_set_qc( list->header, &wavg, QC_WAVECAL_FWHMAVG,instr );
00382 xsh_pfits_set_qc( list->header, &wstd, QC_WAVECAL_FWHMRMS,instr );
00383
00384
00385 check( xsh_pfits_set_pcatg(list->header,tag));
00386 check(cpl_table_save(table, list->header, NULL, filename, CPL_IO_DEFAULT));
00387
00388
00389 check(result=xsh_frame_product(filename,
00390 XSH_GET_TAG_FROM_MODE( XSH_TILT_TAB, instr),
00391 CPL_FRAME_TYPE_TABLE,
00392 CPL_FRAME_GROUP_PRODUCT,
00393 CPL_FRAME_LEVEL_TEMPORARY));
00394 xsh_add_temporary_file( filename ) ;
00395
00396 cleanup:
00397 xsh_free_table(&ext);
00398 XSH_TABLE_FREE( table);
00399 return result ;
00400 }
00401
00402
00410
00411 double * xsh_linetilt_list_get_posx( xsh_linetilt_list * list)
00412 {
00413 double* res = NULL, *p ;
00414 int i, size ;
00415
00416 XSH_ASSURE_NOT_NULL( list );
00417 size = list->size ;
00418 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00419 for( p = res, i = 0 ; i<size ; i++, p++ )
00420 *p = list->list[i]->cenposx ;
00421
00422 cleanup:
00423 return res;
00424 }
00425
00433
00434 double * xsh_linetilt_list_get_posy( xsh_linetilt_list * list)
00435 {
00436 double* res = NULL, *p ;
00437 int i, size ;
00438
00439 XSH_ASSURE_NOT_NULL( list );
00440 size = list->size ;
00441 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00442 for( p = res, i = 0 ; i<size ; i++, p++ )
00443 *p = list->list[i]->cenposy ;
00444
00445 cleanup:
00446 return res;
00447 }
00448
00456
00457 double * xsh_linetilt_list_get_deltay( xsh_linetilt_list * list)
00458 {
00459 double* res = NULL, *p ;
00460 int i, size ;
00461
00462 XSH_ASSURE_NOT_NULL( list );
00463 size = list->size ;
00464
00465 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00466 for( p = res, i = 0 ; i<size ; i++, p++ )
00467 *p = list->list[i]->deltay ;
00468
00469
00470 cleanup:
00471 return res;
00472 }
00473
00481
00482 double * xsh_linetilt_list_get_sigma_y( xsh_linetilt_list * list)
00483 {
00484 double* res = NULL, *p ;
00485 int i, size ;
00486
00487 XSH_ASSURE_NOT_NULL( list );
00488 size = list->size ;
00489
00490 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00491 for( p = res, i = 0 ; i<size ; i++, p++ )
00492 *p = list->list[i]->chisq ;
00493
00494
00495 cleanup:
00496 return res;
00497 }
00498
00506
00507 double * xsh_linetilt_list_get_pre_posy( xsh_linetilt_list * list)
00508 {
00509 double* res = NULL, *p ;
00510 int i, size ;
00511
00512 XSH_ASSURE_NOT_NULL( list );
00513 size = list->size ;
00514
00515 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00516 for( p = res, i = 0 ; i<size ; i++, p++ )
00517 *p = list->list[i]->pre_pos_y ;
00518
00519
00520 cleanup:
00521 return res;
00522 }
00523
00531
00532 double * xsh_linetilt_list_get_orders( xsh_linetilt_list * list)
00533 {
00534 double* res = NULL, *p ;
00535 int i, size ;
00536
00537 XSH_ASSURE_NOT_NULL( list );
00538 size = list->size ;
00539 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00540 for( p = res, i = 0 ; i<size ; i++, p++ )
00541 *p = list->list[i]->order ;
00542
00543 cleanup:
00544 return res;
00545 }
00546
00554
00555 double * xsh_linetilt_list_get_wavelengths( xsh_linetilt_list * list)
00556 {
00557 double* res = NULL, *p ;
00558 int i, size ;
00559
00560 XSH_ASSURE_NOT_NULL( list );
00561 size = list->size ;
00562 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00563 for( p = res, i = 0 ; i<size ; i++, p++ )
00564 *p = list->list[i]->wavelength ;
00565
00566 cleanup:
00567 return res;
00568 }
00569
00577
00578 double * xsh_linetilt_list_get_slits( xsh_linetilt_list * list)
00579 {
00580 double* res = NULL, *p ;
00581 int i, size ;
00582
00583 XSH_ASSURE_NOT_NULL( list );
00584 size = list->size ;
00585 check( res = cpl_malloc( list->size * sizeof(double) ) ) ;
00586 for( p = res, i = 0 ; i<size ; i++, p++ )
00587 *p = list->list[i]->slit ;
00588
00589 cleanup:
00590 return res;
00591 }
00592
00600
00601 int * xsh_linetilt_list_get_slit_index( xsh_linetilt_list * list)
00602 {
00603 int * res = NULL, *p ;
00604 int i, size ;
00605
00606 XSH_ASSURE_NOT_NULL( list );
00607 size = list->size ;
00608 check( res = cpl_malloc( list->size * sizeof(int) ) ) ;
00609 for( p = res, i = 0 ; i<size ; i++, p++ )
00610 *p = list->list[i]->slit_index ;
00611
00612 cleanup:
00613 return res;
00614 }
00615
00624 cpl_propertylist * xsh_linetilt_list_get_header( xsh_linetilt_list * list)
00625 {
00626 cpl_propertylist * res = NULL ;
00627
00628 XSH_ASSURE_NOT_NULL( list );
00629
00630 res = list->header ;
00631
00632 cleanup:
00633 return res;
00634 }
00635
00645 int xsh_linetilt_is_duplicate( xsh_linetilt_list * list, float lambda,
00646 int order )
00647 {
00648 int i, res = 0 ;
00649 XSH_ASSURE_NOT_NULL( list );
00650
00651 for( i = 0 ; i<list->size ; i++ ) {
00652 if ( list->list[i]->wavelength == lambda &&
00653 list->list[i]->order == order ) {
00654 res = 1 ;
00655 break ;
00656 }
00657 }
00658
00659 cleanup:
00660 return res ;
00661 }
00662
00663 #if 0
00664 static int xsh_arclist_lambda_compare(const void* one, const void* two){
00665 xsh_arcline** a = NULL;
00666 xsh_arcline** b = NULL;
00667 float la, lb;
00668
00669 a = (xsh_arcline**) one;
00670 b = (xsh_arcline**) two;
00671
00672 la = (*a)->wavelength;
00673 lb = (*b)->wavelength;
00674
00675 if (la <= lb)
00676 return -1;
00677 else
00678 return 1;
00679
00680
00681 }
00682
00683
00684
00691
00692 void xsh_arclist_lambda_sort(xsh_arclist* list){
00693 qsort(list->list,list->size,sizeof(xsh_arcline*),
00694 xsh_arclist_lambda_compare);
00695 }
00696
00697
00704
00705 int xsh_arclist_get_size(xsh_arclist* list){
00706 int i=0;
00707
00708 XSH_ASSURE_NOT_NULL(list);
00709 i = list->size;
00710
00711 cleanup:
00712 return i;
00713 }
00714
00715
00716
00723
00724 int xsh_arclist_get_nbrejected(xsh_arclist* list){
00725 int i=0;
00726
00727 XSH_ASSURE_NOT_NULL(list);
00728 i = list->nbrejected;
00729
00730 cleanup:
00731 return i;
00732 }
00733
00734
00742
00743 float xsh_arclist_get_wavelength(xsh_arclist* list, int index)
00744 {
00745 float f = 0.0;
00746
00747 XSH_ASSURE_NOT_NULL(list);
00748 XSH_ASSURE_NOT_ILLEGAL(index >= 0 && index < list->size);
00749 f = list->list[index]->wavelength;
00750
00751 cleanup:
00752 return f;
00753 }
00754
00755
00762
00763 void xsh_arclist_reject(xsh_arclist* list, int index)
00764 {
00765 XSH_ASSURE_NOT_NULL(list);
00766 XSH_ASSURE_NOT_ILLEGAL(index >= 0 && index < list->size);
00767
00768 list->rejected[index] = 1;
00769 list->nbrejected++;
00770
00771 cleanup:
00772 return;
00773
00774 }
00775
00776
00783
00784 void xsh_arclist_restore(xsh_arclist* list, int index)
00785 {
00786 XSH_ASSURE_NOT_NULL(list);
00787 XSH_ASSURE_NOT_ILLEGAL(index >= 0 && index < list->size);
00788
00789 list->rejected[index] = 0;
00790 list->nbrejected--;
00791
00792 cleanup:
00793 return;
00794
00795 }
00796
00803
00804 int xsh_arclist_is_rejected(xsh_arclist* list, int index)
00805 {
00806 int res = 0;
00807
00808 XSH_ASSURE_NOT_NULL(list);
00809 XSH_ASSURE_NOT_ILLEGAL(index >= 0 && index < list->size);
00810
00811 res = list->rejected[index];
00812 cleanup:
00813 return res;
00814 }
00815
00816
00822
00823 cpl_propertylist* xsh_arclist_get_header(xsh_arclist* list)
00824 {
00825 cpl_propertylist * res = NULL;
00826
00827 XSH_ASSURE_NOT_NULL(list);
00828 res = list->header;
00829 cleanup:
00830 return res;
00831 }
00832
00833
00839
00840 void xsh_dump_arclist( xsh_arclist* list)
00841 {
00842 int i = 0;
00843
00844 XSH_ASSURE_NOT_NULL(list);
00845
00846 xsh_msg( "ARCLINE_LIST Dump %d lines",list->size);
00847
00848 for(i=0; i< list->size; i++) {
00849 const char* name = list->list[i]->name;
00850 const char* comment = list->list[i]->comment;
00851 if (name == NULL) name ="";
00852 if (comment == NULL) comment ="";
00853 xsh_msg(" Wavelength %f name %s flux %d comment %s",
00854 list->list[i]->wavelength, name,
00855 list->list[i]->flux, comment);
00856 }
00857 xsh_msg( "END ARCLINE_LIST");
00858
00859 cleanup:
00860 return;
00861 }
00862
00863
00870
00871 xsh_arclist* xsh_arclist_load(cpl_frame* frame){
00872 cpl_table* table = NULL;
00873 const char* tablename = NULL;
00874 xsh_arclist* result = NULL;
00875 int i = 0;
00876
00877
00878 XSH_ASSURE_NOT_NULL(frame);
00879
00880
00881 check( tablename = cpl_frame_get_filename(frame));
00882
00883 XSH_TABLE_LOAD( table, tablename);
00884
00885
00886 XSH_CALLOC(result,xsh_arclist,1);
00887
00888
00889 check(result->size = cpl_table_get_nrow(table));
00890 XSH_CALLOC(result->list, xsh_arcline*, result->size);
00891 XSH_CALLOC(result->rejected, int, result->size);
00892 result->nbrejected = 0;
00893
00894 check(result->header = cpl_propertylist_load(tablename, 0));
00895
00896
00897 for(i=0;i<result->size;i++){
00898 const char* name ="";
00899 const char* comment ="";
00900 xsh_arcline* arc = (xsh_arcline*)cpl_malloc(sizeof(xsh_arcline));
00901
00902 check(xsh_get_table_value(table, XSH_ARCLIST_TABLE_COLNAME_WAVELENGTH,
00903 CPL_TYPE_FLOAT, i, &(arc->wavelength)));
00904 check(xsh_get_table_value(table, XSH_ARCLIST_TABLE_COLNAME_NAME,
00905 CPL_TYPE_STRING, i, &name));
00906 check(xsh_get_table_value(table, XSH_ARCLIST_TABLE_COLNAME_FLUX,
00907 CPL_TYPE_INT, i, &(arc->flux)));
00908 check(xsh_get_table_value(table, XSH_ARCLIST_TABLE_COLNAME_COMMENT,
00909 CPL_TYPE_STRING, i, &comment));
00910 if (name != NULL) {
00911 arc->name = xsh_stringdup(name);
00912 }
00913 else {
00914 arc->name = NULL;
00915 }
00916 if (comment != NULL) {
00917 arc->comment = xsh_stringdup(comment);
00918 }
00919 else {
00920 arc->comment = NULL;
00921 }
00922 result->list[i] = arc;
00923 }
00924
00925 cleanup:
00926 if (cpl_error_get_code () != CPL_ERROR_NONE) {
00927 xsh_error_msg("can't load frame %s",cpl_frame_get_filename(frame));
00928 xsh_arclist_free(&result);
00929 }
00930 XSH_TABLE_FREE( table);
00931 return result;
00932 }
00933
00934
00939
00940 void xsh_arcline_free(xsh_arcline** arc)
00941 {
00942 if (arc && (*arc)){
00943 if ((*arc)->name != NULL) {
00944 cpl_free((*arc)->name);
00945 }
00946 if ((*arc)->comment != NULL) {
00947 cpl_free((*arc)->comment);
00948 }
00949 cpl_free(*arc);
00950 *arc = NULL;
00951 }
00952 }
00953
00954
00959
00960 void xsh_arclist_free(xsh_arclist** list)
00961 {
00962 int i;
00963
00964 if (list && *list) {
00965 if ((*list)->list) {
00966 for (i=0; i< (*list)->size; i++) {
00967 xsh_arcline* arc = (*list)->list[i];
00968 xsh_arcline_free(&arc);
00969 }
00970 cpl_free((*list)->list);
00971 xsh_free_propertylist(&((*list)->header));
00972 }
00973 XSH_FREE((*list)->rejected);
00974 cpl_free(*list);
00975 *list = NULL;
00976 }
00977 }
00978
00979 void xsh_arclist_clean(xsh_arclist* list)
00980 {
00981 int i, j;
00982
00983 XSH_ASSURE_NOT_NULL(list);
00984
00985 j = 0;
00986 for(i=0;i<list->size;i++)
00987 {
00988 if(xsh_arclist_is_rejected(list,i)){
00989 xsh_arcline_free(&list->list[i]);
00990 }
00991 else{
00992 j++;
00993 list->list[j-1] = list->list[i];
00994 list->rejected[j] = 0;
00995 }
00996 }
00997 list->size = j;
00998 list->nbrejected = 0;
00999
01000 cleanup:
01001 return;
01002 }
01003
01012
01013 cpl_frame*
01014 xsh_arclist_save(xsh_arclist* list,const char* filename,const char* tag)
01015 {
01016 cpl_table* table = NULL;
01017 cpl_frame * result = NULL ;
01018 int i=0;
01019
01020 XSH_ASSURE_NOT_NULL(list);
01021 XSH_ASSURE_NOT_NULL(filename);
01022
01023
01024 check(table = cpl_table_new(XSH_ARCLIST_TABLE_NB_COL));
01025
01026
01027 check(
01028 cpl_table_new_column(table,XSH_ARCLIST_TABLE_COLNAME_WAVELENGTH,
01029 CPL_TYPE_FLOAT));
01030 check(
01031 cpl_table_set_column_unit ( table, XSH_ARCLIST_TABLE_COLNAME_WAVELENGTH,
01032 XSH_ARCLIST_TABLE_UNIT_WAVELENGTH));
01033 check(
01034 cpl_table_new_column(table,XSH_ARCLIST_TABLE_COLNAME_NAME,
01035 CPL_TYPE_STRING));
01036 check(
01037 cpl_table_set_column_unit ( table, XSH_ARCLIST_TABLE_COLNAME_NAME,
01038 XSH_ARCLIST_TABLE_UNIT_NAME));
01039
01040 check(
01041 cpl_table_new_column(table,XSH_ARCLIST_TABLE_COLNAME_FLUX,
01042 CPL_TYPE_INT));
01043 check(
01044 cpl_table_set_column_unit ( table, XSH_ARCLIST_TABLE_COLNAME_FLUX,
01045 XSH_ARCLIST_TABLE_UNIT_FLUX));
01046
01047 check(
01048 cpl_table_new_column(table,XSH_ARCLIST_TABLE_COLNAME_COMMENT,
01049 CPL_TYPE_STRING));
01050 check(
01051 cpl_table_set_column_unit ( table, XSH_ARCLIST_TABLE_COLNAME_COMMENT,
01052 XSH_ARCLIST_TABLE_UNIT_COMMENT));
01053
01054 check(cpl_table_set_size(table,list->size));
01055
01056
01057 for(i=0;i<list->size;i++){
01058 check(cpl_table_set_float(table,XSH_ARCLIST_TABLE_COLNAME_WAVELENGTH,
01059 i,list->list[i]->wavelength));
01060 check(cpl_table_set_string(table,XSH_ARCLIST_TABLE_COLNAME_NAME,
01061 i,list->list[i]->name));
01062 check(cpl_table_set_int(table,XSH_ARCLIST_TABLE_COLNAME_FLUX,
01063 i,list->list[i]->flux));
01064 check(cpl_table_set_string(table,XSH_ARCLIST_TABLE_COLNAME_COMMENT,
01065 i,list->list[i]->comment));
01066 }
01067
01068
01069 check(cpl_table_save(table, list->header, NULL, filename, CPL_IO_DEFAULT));
01070
01071
01072 check(result=xsh_frame_product(filename,
01073 tag,
01074 CPL_FRAME_TYPE_TABLE,
01075 CPL_FRAME_GROUP_PRODUCT,
01076 CPL_FRAME_LEVEL_TEMPORARY));
01077
01078
01079 cleanup:
01080 XSH_TABLE_FREE( table);
01081 return result ;
01082 }
01083 #endif
01084