/*----------------------------------------------------------------------------
   
   File name    :   strehl.c
   Author       :	N. Devillard
   Created on   :	July 2001
   Description  :	CONICA strehl ratio computation

 ---------------------------------------------------------------------------*/

/*
   $Id: strehl.c,v 1.7 2002/01/30 04:21:01 yjung Exp $
   $Author: yjung $
   $Date: 2002/01/30 04:21:01 $
   $Revision: 1.7 $
 */

/*----------------------------------------------------------------------------
                                Includes
 ---------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "eclipse.h"
#include "conicap_lib.h"

/*----------------------------------------------------------------------------
                                Defines
 ---------------------------------------------------------------------------*/

#define	STREHL_VLT_M1	8.0
/*#define STREHL_VLT_M2 	1.1*/
#define STREHL_IMAGE_SIZE 64
#define STREHL_VLT_M2 0.0
/*----------------------------------------------------------------------------
                            Private functions
 ---------------------------------------------------------------------------*/

static int conica_strehl_engine(
	char * name_i,
	conica_filter_id f_id,
	double * bg_data,
char * backg
);

/*----------------------------------------------------------------------------
                            Main code
 ---------------------------------------------------------------------------*/

int conica_strehl_main(void * dict)
{
	dictionary  *   d ;
	char        *   name_i ;
	int				errors ;
	int				i ;
	int				nfiles ;
	char			argname[10];
	char		*	sval ;
	conica_filter_id	f_id ;
	double			bg_data[2] ;	
	double		*	bg_ptr ;
	char * backg ;
	
	d = (dictionary*)dict ;

	backg = dictionary_get(d, "arg.back");

	/* Get input/output file names */
	nfiles = dictionary_getint(d, "arg.n", -1) ;
	if (nfiles<0) {
		e_error("missing input file name(s): aborting");
		return -1 ;
	}

	/* Get reference filter ID if any */
	f_id = conica_filter_invalid ;
	sval = dictionary_get(d, "arg.filter");

	if (sval!=NULL) {
		f_id = conica_get_filterid(sval);
		if (f_id==conica_filter_invalid) {
			e_error("unknown filter ID: %s", sval);
			conica_filters_dump(stderr);
			return -1 ;
		}
	}

	/* Get background value if provided */
	sval = dictionary_get(d, "arg.background");
	if (sval!=NULL) {
		if (sscanf(sval, "%lg %lg", &bg_data[0], &bg_data[1])!=2) {
			e_error("expecting 2 values for -b/--background");
			return -1 ;
		}
		bg_ptr = bg_data ;
	} else {
		bg_ptr = NULL ;
	}

	/* Loop on input file names */
    errors = 0 ;
    for (i=1 ; i<nfiles ; i++) {
        sprintf(argname, "arg.%d", i);
        name_i = dictionary_get(d, argname) ;
        errors += conica_strehl_engine(name_i, f_id, bg_ptr, backg);
    }
    return errors ;
}

static int conica_strehl_engine(
	char * name_i,
	conica_filter_id f_id,
	double * bg,
	char * backg
)
{
	cube_t	*	in ;
	int			i ;
	strehl_parm	spar ;
	char	*	firstname ;
	char * sval ;
	char	*	filtname ;
	image_t * backgr ;
	image_t * input ;
	/* Retrieve filter settings if necessary */
	if (f_id==conica_filter_invalid) {
		/* Retrieve first name in input list */
		if (is_fits_file(name_i)==1) {
			firstname = name_i ;
		} else if (is_ascii_list(name_i)==1) {
			firstname = framelist_firstname(name_i);
			if (firstname==NULL) {
				e_error("getting name of first frame: aborting");
				return 1 ;
			}
		} else {
			e_error("unsupported format for input file: %s", name_i);
			return 1 ;
		}
		/* Retrieve filter name */
		filtname = conica_get_filter(firstname);
		if (filtname==NULL) {
			e_error("cannot get filter settings for frame %s", firstname);
			return 1 ;
		}
		f_id = conica_get_filterid(filtname);
		if (f_id==conica_filter_invalid) {
			e_error("illegal filter ID (%s) in header of frame %s",
					filtname,
					firstname);
			return 1 ;
		}
		e_comment(0, "working with filter: %s", filtname);
	}

	/* Load input cube */
	in = cube_load(name_i);
	if (in==NULL) {
		e_error("cannot load [%s]: aborting strehl computation", name_i);
		return 1 ;
	}


	/* Hardcoded VLT constants */
	spar.m1 = STREHL_VLT_M1 ;
	spar.m2 = STREHL_VLT_M2 ;

	/* Retrieve central wavelength and width from database */
	conica_get_filterdef(f_id, &spar.l0, &spar.dl);

	/* Get pixel scale */
	if ((sval = conica_get_pixscale(firstname)) == NULL) {
	  e_error("cannot get the pixel scale - abort") ;
	  return -1 ;
	}
	spar.pscale = (double)atof(sval) ;
	/*spar.pscale = 0.01325 ;*/

	/* Further default values */
	spar.psf_save = 1 ;
	spar.psf_filename = NULL ;
	spar.size = STREHL_IMAGE_SIZE ;

	spar.pos_x = -1 ;
	spar.pos_y = -1 ;

	/* Background estimate */
	if (bg!=NULL) {
		spar.estim_bg = 0 ;
		spar.star_bg = bg[0] ;
		spar.star_bg_err = bg[1];
	} else {
		spar.estim_bg = 1 ;
	}

	backgr = image_load(backg) ;

	/* Compute Strehl on all planes in this cube */
	printf("file: %s\n", name_i);
	for (i=0 ; i<in->np ; i++) {
	  input = image_sub(in->plane[i], backgr) ;
	        
	  image_save_fits(input, "diff.fits", BPP_DEFAULT) ;
image_compute_strehl(input, &spar);
		printf("plane %d strehl %4.2f err=%g (%4.2f %4.2f) bg %g\n",
				i+1,
				spar.strehl,
				spar.strehl_err,
				spar.strehl - spar.strehl * spar.strehl_err,
				spar.strehl + spar.strehl * spar.strehl_err,
				spar.star_bg);
		image_del(input) ;
	}
	image_del(backgr) ;
	cube_del(in);
	return 0 ;
}