/* $Id: cpl_image_io-test.c,v 1.24 2007/11/13 13:13:02 llundin Exp $
 *
 * This file is part of the ESO Common Pipeline Library
 * Copyright (C) 2001-2004 European Southern Observatory
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 * $Author: llundin $
 * $Date: 2007/11/13 13:13:02 $
 * $Revision: 1.24 $
 * $Name:  $
 */

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

#include <math.h>

#include "cpl_image_io.h"
#include "cpl_image_gen.h"
#include "cpl_image_bpm.h"
#include "cpl_tools.h"
#include "cpl_memory.h"

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

#define IMAGESZ            512    
#define MAGIC_PIXEL        42

/*-----------------------------------------------------------------------------
                                  Main
 -----------------------------------------------------------------------------*/
int main(void)
{
    cpl_image       *   imf1 ;
    cpl_image       *   imf2 ;
    cpl_image       *   imd1 ;
    cpl_image       *   imd2 ;
    cpl_image       *   imi1 ;
    cpl_image       *   imi2 ;
    float           *   fbuf ;
    double          *   dbuf ;
    int             *   ibuf ;
    void            *   vbuf ;
    const int           nbad = 5;
    int                 bad_pos_x[nbad];
    int                 bad_pos_y[nbad];
    int                 i;

    cpl_test_init(PACKAGE_BUGREPORT, CPL_MSG_WARNING);

    /* Insert tests below */

    /* First create cpl_image_test.fits */
    cpl_msg_info(cpl_func,"Create cpl_image_test.fits on disk.");
    imd1 = cpl_image_fill_test_create(IMAGESZ, IMAGESZ);

    /* Must be positive */
    cpl_image_add_scalar(imd1, 1.00)  ;
    
    /* Normal image */
    cpl_image_save(imd1, "cpl_image_test.fits", CPL_BPP_IEEE_FLOAT, NULL,
                   CPL_IO_DEFAULT);

    /* Append extension */
    cpl_image_save(imd1, "cpl_image_test.fits", CPL_BPP_16_UNSIGNED, NULL,
                   CPL_IO_EXTEND);

    /* Append NULL */
    cpl_image_save(NULL, "cpl_image_test.fits", CPL_BPP_IEEE_FLOAT, NULL,
                   CPL_IO_EXTEND);

    /* Append extension */
    cpl_image_save(imd1, "cpl_image_test.fits", CPL_BPP_16_SIGNED, NULL,
                   CPL_IO_EXTEND);
    
    /* Append extension */
    cpl_image_save(imd1, "cpl_image_test.fits", CPL_BPP_IEEE_DOUBLE, NULL,
            CPL_IO_EXTEND);

    /* Check */
    cpl_assert (cpl_error_get_code() == CPL_ERROR_NONE) ; 
    
    /* Check the image type size */
    cpl_assert( cpl_type_get_sizeof(CPL_TYPE_DOUBLE) == (int)sizeof(double) );

    /* Test cpl_image_get_data() */
    cpl_assert( (vbuf=cpl_image_get_data(imd1)) );

    /* Create a bad pixel map for this image */
    bad_pos_x[0] =  20 ;
    bad_pos_y[0] =  30 ;
    bad_pos_x[1] = 200 ;
    bad_pos_y[1] = 100 ;
    bad_pos_x[2] = 300 ;
    bad_pos_y[2] = 200 ;
    bad_pos_x[3] = 301 ;
    bad_pos_y[3] = 200 ;
    bad_pos_x[4] = 100 ;
    bad_pos_y[4] = 220 ;

    for (i=0 ; i<nbad-1 ; i++) 
        cpl_image_reject(imd1, bad_pos_x[i], bad_pos_y[i]) ;

    cpl_assert( nbad-1 == cpl_image_count_rejected(imd1) );

    cpl_assert(!cpl_image_reject(imd1,bad_pos_x[nbad-1],bad_pos_y[nbad-1]));

    cpl_assert( nbad == cpl_image_count_rejected(imd1) );

    cpl_assert( !cpl_image_reject(imd1, bad_pos_x[0], bad_pos_y[0]) );

    cpl_assert( nbad == cpl_image_count_rejected(imd1) );

    /* INFOS on imd1 */
    cpl_msg_info(cpl_func,"Create a DOUBLE image and fill it with cpl_image_test.fits");
    cpl_msg_info(cpl_func,"nx   = %d", cpl_image_get_size_x(imd1)) ;
    cpl_msg_info(cpl_func,"ny   = %d", cpl_image_get_size_y(imd1)) ;
    switch (cpl_image_get_type(imd1)) {
        case CPL_TYPE_DOUBLE:      cpl_msg_info(cpl_func,"type = double") ;   break ;
        case CPL_TYPE_FLOAT:       cpl_msg_info(cpl_func,"type = float") ;    break ;
        case CPL_TYPE_INT:         cpl_msg_info(cpl_func,"type = int") ;      break ;
        default:
	  cpl_assert( 0 );
    }
    cpl_msg_info(cpl_func,"bp_nb = %d", cpl_image_count_rejected(imd1)) ;
    
    /* Test cpl_image_fill_rejected() */
    cpl_assert( !cpl_image_fill_rejected(imd1, 0.0) );

    /* Verify nb of bad pixels */
    cpl_assert( cpl_image_count_rejected(imd1) == nbad);
    
    cpl_image_delete(imd1) ;
    
    /* CREATE FLOAT IMAGES imf1 and imf2 */
    /* Create imf1 as a float empty image */
    cpl_assert( (imf1 = cpl_image_new(IMAGESZ, IMAGESZ, CPL_TYPE_FLOAT)) );
    
    /* Fill imf1 with MAGIC_PIXEL */
    cpl_assert( (fbuf = cpl_image_get_data_float(imf1)) );
    for (i=0 ; i < IMAGESZ*IMAGESZ ; i++) fbuf[i] = (float)MAGIC_PIXEL ;

    /* Copy imf1 into imf2  */
    cpl_assert( (imf2 = cpl_image_duplicate(imf1)) );

    /* Delete imf1 and imf2 */
    cpl_image_delete(imf1) ;
    cpl_image_delete(imf2) ;

    /* Read a FITS image from disk as a float image imf2 */
    cpl_assert( (imf2 = cpl_image_load("cpl_image_test.fits", CPL_TYPE_FLOAT,
                    0, 0)) );

    /* INFOS on imf2 */
    cpl_msg_info(cpl_func,"Load cpl_image_test.fits as a FLOAT image");
    cpl_msg_info(cpl_func,"nx   = %d", cpl_image_get_size_x(imf2)) ;
    cpl_msg_info(cpl_func,"ny   = %d", cpl_image_get_size_y(imf2)) ;
    switch (cpl_image_get_type(imf2)) {
        case CPL_TYPE_DOUBLE:      cpl_msg_info(cpl_func,"type = double") ;   break ;
        case CPL_TYPE_FLOAT:       cpl_msg_info(cpl_func,"type = float") ;    break ;
        case CPL_TYPE_INT:         cpl_msg_info(cpl_func,"type = int") ;      break ;
        default:
	  cpl_assert( 0 );
    }
    cpl_msg_info(cpl_func,"bp_nb = %d", cpl_image_count_rejected(imf2)) ;

    cpl_image_delete(imf2) ;

    /* CREATE DOUBLE IMAGES imd1 and imd2 */
    /* Create imd1 as a double empty image */
    cpl_assert( (imd1 = cpl_image_new(IMAGESZ, IMAGESZ, CPL_TYPE_DOUBLE)) );
    
    /* Fill imd1 with MAGIC_PIXEL */
    cpl_assert( (dbuf = cpl_image_get_data_double(imd1)) );
    for (i=0 ; i < IMAGESZ*IMAGESZ ; i++) dbuf[i] = (double)MAGIC_PIXEL ;

    /* Copy imd1 into imd2  */
    cpl_assert( (imd2 = cpl_image_duplicate(imd1)) ) ;

    /* Delete imd1 and imd2 */
    cpl_image_delete(imd1) ;
    cpl_image_delete(imd2) ;

    /* Read a FITS image from disk as a double image imd2 */
    cpl_assert( (imd2 = cpl_image_load("cpl_image_test.fits", CPL_TYPE_DOUBLE, 
                    0, 0)) ) ;

    /* INFOS on imd2 */
    cpl_msg_info(cpl_func,"Load cpl_image_test.fits as a DOUBLE image");
    cpl_msg_info(cpl_func,"nx   = %d", cpl_image_get_size_x(imd2)) ;
    cpl_msg_info(cpl_func,"ny   = %d", cpl_image_get_size_y(imd2)) ;
    switch (cpl_image_get_type(imd2)) {
        case CPL_TYPE_DOUBLE:      cpl_msg_info(cpl_func,"type = double") ;   break ;
        case CPL_TYPE_FLOAT:       cpl_msg_info(cpl_func,"type = float") ;    break ;
        case CPL_TYPE_INT:         cpl_msg_info(cpl_func,"type = int") ;      break ;
        default:
	  cpl_assert( 0 );
    }
    cpl_msg_info(cpl_func,"bp_nb = %d", cpl_image_count_rejected(imd2)) ;
    
    cpl_image_delete(imd2) ;
    
    /* CREATE INTEGER IMAGES imi1 and imi2 */
    /* Create imi1 as an integer empty image */
    cpl_assert( (imi1 = cpl_image_new(IMAGESZ, IMAGESZ, CPL_TYPE_INT)) );
    
    /* Fill imi1 with MAGIC_PIXEL */
    cpl_assert( (ibuf = cpl_image_get_data_int(imi1)) );
    for (i=0 ; i < IMAGESZ*IMAGESZ ; i++) ibuf[i] = (int)MAGIC_PIXEL ;

    /* Copy imi1 into imi2  */
    cpl_assert( (imi2 = cpl_image_duplicate(imi1)) );

    /* Delete imi1 and imi2 */
    cpl_image_delete(imi1) ;
    cpl_image_delete(imi2) ;

    /* Read a FITS image from disk as a double image imi2 */
    cpl_assert( (imi2 = cpl_image_load("cpl_image_test.fits", CPL_TYPE_INT, 0,0)) );

    /* INFOS on imi2 */
    cpl_msg_info(cpl_func,"Load cpl_image_test.fits as a INTEGER image");
    cpl_msg_info(cpl_func,"nx   = %d", cpl_image_get_size_x(imi2)) ;
    cpl_msg_info(cpl_func,"ny   = %d", cpl_image_get_size_y(imi2)) ;
    switch (cpl_image_get_type(imi2)) {
        case CPL_TYPE_DOUBLE:      cpl_msg_info(cpl_func,"type = double") ;   break ;
        case CPL_TYPE_FLOAT:       cpl_msg_info(cpl_func,"type = float") ;    break ;
        case CPL_TYPE_INT:         cpl_msg_info(cpl_func,"type = int") ;      break ;
        default:
	  cpl_assert( 0 );
    }
    cpl_msg_info(cpl_func,"bp_nb = %d", cpl_image_count_rejected(imi2)) ;

    /* Test save with CPL_BPP_16_UNSIGNED */
    cpl_image_save(imi2, "cpl_image_test2.fits", CPL_BPP_16_UNSIGNED,
            NULL, CPL_IO_DEFAULT) ;
    cpl_assert( !remove("cpl_image_test2.fits") );

    /* Test cpl_image_cast() */
    cpl_assert( (imi1 = cpl_image_cast(imi2, CPL_TYPE_INT)) );
    cpl_image_delete(imi2) ;
    
    /* Test cpl_image_save() */
    cpl_assert( !cpl_image_save(imi1, "cpl_image_io-tmp.fits", CPL_BPP_IEEE_FLOAT, 
                NULL, CPL_IO_DEFAULT) );
    cpl_image_delete(imi1) ;

    /* Read a FITS image from disk as a double image imd2 */
    cpl_assert( (imd1 = cpl_image_load_window("cpl_image_test.fits",CPL_TYPE_DOUBLE,
                    0,0, IMAGESZ/4, IMAGESZ/4, 3*IMAGESZ/4, 3*IMAGESZ/4)) );

    /* INFOS on imd2 */
    cpl_msg_info(cpl_func,"Load a part of cpl_image_test.fits as a DOUBLE image");
    cpl_msg_info(cpl_func,"nx   = %d", cpl_image_get_size_x(imd1)) ;
    cpl_msg_info(cpl_func,"ny   = %d", cpl_image_get_size_y(imd1)) ;
    switch (cpl_image_get_type(imd1)) {
        case CPL_TYPE_DOUBLE:      cpl_msg_info(cpl_func,"type = double") ;   break ;
        case CPL_TYPE_FLOAT:       cpl_msg_info(cpl_func,"type = float") ;    break ;
        case CPL_TYPE_INT:         cpl_msg_info(cpl_func,"type = int") ;      break ;
        default:
	  cpl_assert( 0 );
    }
    cpl_msg_info(cpl_func,"bp_nb = %d", cpl_image_count_rejected(imd1)) ;

    cpl_image_delete(imd1) ;

    cpl_assert( !remove("cpl_image_io-tmp.fits") );
    cpl_assert( !remove("cpl_image_test.fits") );

    /* End of tests */
    return cpl_test_end(0);
}