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
00028
00029
00030 #include <math.h>
00031 #include <string.h>
00032 #include <xsh_error.h>
00033 #include <xsh_utils_ifu.h>
00034 #include <xsh_utils_image.h>
00035 #include <xsh_utils_wrappers.h>
00036 #include <xsh_utils_table.h>
00037 #include <xsh_pfits.h>
00038 #include <xsh_model_io.h>
00039 #include <xsh_data_rec.h>
00040 #include <xsh_data_spectrum.h>
00041 #include <xsh_dfs.h>
00042 #include <xsh_drl.h>
00043 #include <xsh_blaze.h>
00044
00045
00051
00054
00055
00056
00070
00071 cpl_frame *xsh_divide_by_blaze( cpl_frame *pre_frame, cpl_frame *blaze_frame,
00072 xsh_instrument *instrument)
00073 {
00074 xsh_pre *pre = NULL;
00075 const char* blaze_name = NULL;
00076 cpl_image *blaze_img = NULL;
00077 cpl_frame *result_frame = NULL;
00078 float *data1 = NULL;
00079 float *data2 = NULL;
00080 float *errs1 = NULL;
00081 int i;
00082 const char* tag = NULL;
00083
00084 XSH_ASSURE_NOT_NULL( pre_frame);
00085 XSH_ASSURE_NOT_NULL( blaze_frame);
00086 XSH_ASSURE_NOT_NULL( instrument);
00087
00088 check( pre = xsh_pre_load( pre_frame, instrument));
00089 check( tag = cpl_frame_get_tag( pre_frame));
00090 check( blaze_name = cpl_frame_get_filename( blaze_frame));
00091 check( blaze_img = cpl_image_load( blaze_name, CPL_TYPE_FLOAT,0,0));
00092
00093 check( data1 = cpl_image_get_data_float( pre->data));
00094 check( errs1 = cpl_image_get_data_float( pre->errs));
00095 check( data2 = cpl_image_get_data_float( blaze_img));
00096
00097 for(i=0;i< pre->nx*pre->ny; i++){
00098
00099 if ( data2[i] == 0){
00100 data1[i] = 0;
00101 }
00102 else {
00103 double d1 = 0.0, d2 = 0.0;
00104 double e1 = 0.0;
00105 d1 = data1[i];
00106 d2 = data2[i];
00107 e1 = errs1[i];
00108 data1[i] = (float)(d1/d2);
00109 errs1[i] = (float)(e1/d2);
00110 }
00111 }
00112
00113 check( result_frame = xsh_pre_save ( pre, "DIV_BY_BLAZE.fits", tag, 1));
00114 check( cpl_frame_set_tag ( result_frame, tag));
00115
00116 cleanup:
00117 xsh_free_image( &blaze_img);
00118 xsh_pre_free( &pre);
00119
00120 if ( cpl_error_get_code() != CPL_ERROR_NONE){
00121 xsh_free_frame( &result_frame);
00122 }
00123 return result_frame;
00124 }
00125
00126
00127
00141
00142
00143 cpl_frame *xsh_blaze_image( cpl_frame* masterflat_frame,
00144 cpl_frame *order_frame, xsh_instrument *instrument)
00145 {
00146 cpl_image *result_img = NULL;
00147 cpl_frame *result_frame = NULL;
00148 xsh_order_list *order_list = NULL;
00149 char blaze_name[256];
00150 char blaze_tag[16];
00151
00152 XSH_ASSURE_NOT_NULL( masterflat_frame);
00153 XSH_ASSURE_NOT_NULL( order_frame);
00154 XSH_ASSURE_NOT_NULL( instrument);
00155
00156
00157 sprintf( blaze_name, "%s", "BLAZE_IMAGE.fits");
00158 sprintf(blaze_tag, "%s", "BLAZE");
00159
00160 check( order_list = xsh_order_list_load( order_frame, instrument));
00161 check( result_img = xsh_create_blaze( masterflat_frame, order_list,
00162 instrument));
00163
00164 check( cpl_image_save( result_img, blaze_name,
00165 CPL_BPP_IEEE_FLOAT, NULL,CPL_IO_DEFAULT));
00166
00167 check( result_frame = cpl_frame_new());
00168 check( cpl_frame_set_filename( result_frame, blaze_name));
00169 check( cpl_frame_set_tag( result_frame, blaze_tag));
00170
00171 cleanup:
00172 xsh_free_image( &result_img);
00173 xsh_order_list_free( &order_list);
00174
00175 if ( cpl_error_get_code() != CPL_ERROR_NONE){
00176 xsh_free_frame( &result_frame);
00177 }
00178 return result_frame;
00179 }
00180
00181
00182
00183
00196
00197 cpl_image* xsh_create_blaze( cpl_frame* masterflat_frame,
00198 xsh_order_list* order_list, xsh_instrument *instrument)
00199 {
00200 xsh_pre *masterflat_pre = NULL;
00201 float *masterflat_data = NULL;
00202 cpl_image *result = NULL;
00203 float *result_data = NULL;
00204 int i, iorder, y, nx, ny;
00205 cpl_vector *cen_flux_vect = NULL, *cen_flux_pos_vect = NULL;
00206 double *cen_flux_pos = NULL, *cen_flux = NULL;
00207 int deg_poly = 18;
00208 double mse =0.0;
00209
00210 XSH_ASSURE_NOT_NULL( masterflat_frame);
00211 XSH_ASSURE_NOT_NULL( order_list);
00212 XSH_ASSURE_NOT_NULL( instrument);
00213
00214
00215 check( masterflat_pre = xsh_pre_load( masterflat_frame, instrument));
00216 XSH_CMP_INT( order_list->bin_x, ==, masterflat_pre->binx, "binning in x",);
00217 XSH_CMP_INT( order_list->bin_y, ==, masterflat_pre->biny, "binning in y",);
00218
00219 check( nx = cpl_image_get_size_x( masterflat_pre->data));
00220 check( ny = cpl_image_get_size_y( masterflat_pre->data));
00221 check( masterflat_data = cpl_image_get_data_float( masterflat_pre->data));
00222 XSH_MALLOC( cen_flux, double, ny);
00223 XSH_MALLOC( cen_flux_pos, double, ny);
00224
00225 check( result = cpl_image_new( nx,ny, CPL_TYPE_FLOAT));
00226 check( result_data = cpl_image_get_data_float( result));
00227
00228
00229 for( iorder= 0; iorder < order_list->size; iorder++) {
00230 int x_cen;
00231 int start_y, end_y;
00232 int size_y=0;
00233 int absorder;
00234
00235 check( start_y = xsh_order_list_get_starty( order_list, iorder));
00236 check( end_y = xsh_order_list_get_endy( order_list, iorder));
00237 absorder = order_list->list[iorder].absorder;
00238
00239 for(y=start_y; y <= end_y; y++){
00240 check( x_cen = xsh_order_list_eval_int( order_list,
00241 order_list->list[iorder].cenpoly, y));
00242 cen_flux[y-start_y] = masterflat_data[(x_cen-1)+(y-1)*nx];
00243 cen_flux_pos[y-start_y] = (double)y;
00244 size_y++;
00245 }
00246
00247 check( cen_flux_vect = cpl_vector_wrap( size_y, cen_flux));
00248 check( cen_flux_pos_vect = cpl_vector_wrap( size_y, cen_flux_pos));
00249
00250 check( order_list->list[iorder].blazepoly =
00251 xsh_polynomial_fit_1d_create( cen_flux_pos_vect,
00252 cen_flux_vect, deg_poly, &mse));
00253 xsh_msg_dbg_medium("Polynomial blaze fitting for order %d with mse %f", absorder, mse);
00254
00255 while( mse >= MSE_LIMIT){
00256 deg_poly--;
00257 xsh_msg( "Not good mse %f Decrease deg poly to %d",mse, deg_poly);
00258 xsh_free_polynomial( &(order_list->list[iorder].blazepoly));
00259 check( order_list->list[iorder].blazepoly = xsh_polynomial_fit_1d_create(
00260 cen_flux_pos_vect,
00261 cen_flux_vect, deg_poly, &mse));
00262 }
00263 #if REGDEBUG_BLAZE
00264
00265 {
00266 FILE* regdebug = NULL;
00267 char filename[256];
00268
00269 sprintf(filename, "blaze_%d.dat",absorder);
00270 regdebug = fopen(filename,"w");
00271
00272 fprintf( regdebug, "# y flux poly\n");
00273
00274 for( y=0; y< size_y; y++){
00275 double flux_cen_val;
00276
00277 check( flux_cen_val = cpl_polynomial_eval_1d(
00278 order_list->list[iorder].blazepoly, cen_flux_pos[y], NULL));
00279 fprintf(regdebug, "%f %f %f\n", cen_flux_pos[y], cen_flux[y], flux_cen_val);
00280 }
00281 fclose(regdebug);
00282 }
00283 #endif
00284
00285
00286 for(y=start_y; y <= end_y; y++){
00287 double flux_cen_val;
00288 int x_min, x_max;
00289
00290 check( x_min = xsh_order_list_eval_int( order_list,
00291 order_list->list[iorder].edglopoly, y));
00292 check( x_max = xsh_order_list_eval_int( order_list,
00293 order_list->list[iorder].edguppoly, y));
00294 check( flux_cen_val = cpl_polynomial_eval_1d(
00295 order_list->list[iorder].blazepoly, y, NULL));
00296
00297 for( i=x_min; i<= x_max; i++){
00298 result_data[i-1+(y-1)*nx] = flux_cen_val;
00299 }
00300 }
00301 xsh_unwrap_vector( &cen_flux_vect);
00302 xsh_unwrap_vector( &cen_flux_pos_vect);
00303 }
00304
00305 #if REGDEBUG_BLAZE
00306 {
00307
00308 check( cpl_image_save( result, "BLAZE_IMAGE.fits",
00309 CPL_BPP_IEEE_FLOAT, NULL,CPL_IO_DEFAULT));
00310 }
00311 #endif
00312
00313 cleanup:
00314 if ( cpl_error_get_code() != CPL_ERROR_NONE){
00315 xsh_unwrap_vector( &cen_flux_vect);
00316 xsh_unwrap_vector( &cen_flux_pos_vect);
00317 xsh_free_image( &result);
00318 }
00319 xsh_pre_free( &masterflat_pre);
00320 XSH_FREE( cen_flux);
00321 XSH_FREE( cen_flux_pos);
00322 return result;
00323 }
00324
00325