test-xsh_data_image_3d.c

Go to the documentation of this file.

/*                                                                            *
 *   This file is part of the ESO X-shooter Pipeline                          *
 *   Copyright (C) 2006 European Southern Observatory                         *
 *                                                                            *
 *   This library 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, 51 Franklin St, Fifth Floor, Boston, MA  02111-1307  USA     *
 *                                                                            */
 
/*
 * $Author: amodigli $
 * $Date: 2012-01-16 21:09:42 $
 * $Revision: 1.4 $
*/
 
#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif
 
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
#include <xsh_data_pre.h>
#include <xsh_data_image_3d.h>
#include <xsh_error.h>
#include <xsh_msg.h>
#include <xsh_data_instrument.h>
#include <xsh_dfs.h>
#include <xsh_pfits.h>
#include <tests.h>
 
#include <cpl.h>
#include <math.h>
#include <getopt.h>
 
/*---------------------------------------------------------------------------
                            Defines
 ---------------------------------------------------------------------------*/
#define MODULE_ID "XSH_DATA_IMAGE_3D"
 
enum {
  DBG_OPT, HELP_OPT, NX_OPT, NY_OPT, NZ_OPT
} ;
 
static const char *Options = "?" ;
static struct option LongOptions[] = {
  {"nx", required_argument, 0, NX_OPT},
  {"ny", required_argument, 0, NY_OPT},
  {"nz", required_argument, 0, NZ_OPT},
  {"debug", required_argument, 0, DBG_OPT},
  {"help", 0, 0, HELP_OPT },
  {0, 0, 0, 0}
} ;
 
static int dbg_level = XSH_DEBUG_LEVEL_MEDIUM ;
static int Nx = 3, Ny =4, Nz = 3 ;
 
static int Help( void ) ;
 
static int Help( void )
{
  printf( "Test 3D images handling\n" ) ;
  printf( "Options:\n" ) ;
  printf( " --nx=<size>   : X size of images (default 3)" ) ;
  printf( " --ny=<size>   : Y size of images (default 4)" ) ;
  printf( " --nz=<size>   : X size of images (default 3)" ) ;
  printf( " --dbg=<level> : Set debug level. <level> is one of:\n" ) ;
  printf( "                 none, low, high, medium.\n" ) ;
  printf( "                 Default is medium.\n" ) ;
  return 0 ;
}
 
static void HandleOptions( int argc, char **argv )
{
  int opt ;
  int opt_idx = 0 ;
 
  while (( opt = getopt_long( argc, argv, Options,
                  LongOptions, &opt_idx )) != EOF )
    switch( opt ) {
    case NX_OPT:
      sscanf( optarg, "%64d", &Nx ) ;
      break ;
    case NY_OPT:
      sscanf( optarg, "%64d", &Ny ) ;
      break ;
    case NZ_OPT:
      sscanf( optarg, "%64d", &Nz ) ;
      break ;
    case DBG_OPT:
      if ( strcmp( optarg, "none" ) == 0 ) dbg_level = XSH_DEBUG_LEVEL_NONE ;
      else if ( strcmp( optarg, "low" ) == 0 )
    dbg_level = XSH_DEBUG_LEVEL_LOW ;
      else if ( strcmp( optarg, "medium" ) == 0 )
    dbg_level = XSH_DEBUG_LEVEL_MEDIUM ;
      else if ( strcmp( optarg, "high" ) == 0 )
    dbg_level = XSH_DEBUG_LEVEL_HIGH ;
      break ;
    default:
      Help() ;
      exit( 0 ) ;
    }
}
 
static void fill_image( cpl_image * img, int first )
{
  int ix, iy ;
  int * pixels = NULL ;
 
  XSH_ASSURE_NOT_NULL( img ) ;
 
  check( pixels = cpl_image_get_data_int( img ) ) ;
  xsh_msg( "fill image with %d", first ) ;
 
  for( iy = 0 ; iy < Ny ; iy++, first++ )
    for( ix = 0 ; ix < Nx ; ix++ ) {
      *(pixels + ix + iy*Nx) = first ;
    }
 cleanup:
  return ;
}
 
static int compare_img_3d( xsh_image_3d * one, xsh_image_3d * two )
{
  if ( one->nx != two->nx || one->ny != two->ny || one->nz != two->nz ) {
    xsh_msg( "Sizes not equal (nx: %d-%d, ny: %d-%d, nz: %d-%d",
         one->nx, two->nx, one->ny, two->ny, one->nz, two->nz ) ;
    return 1 ;
  }
  return 0 ;
}
 
int main( int argc, char** argv)
{
  int ret = 1 ;
  int iz ;
  cpl_image * img = NULL ;
  xsh_image_3d * img_3d = NULL ;
  xsh_image_3d * new_3d = NULL ;
  cpl_propertylist * header = NULL ;
  const char * img_name = "TEST_3D_IMAGE.fits" ;
 
  /* Initialize libraries */
  TESTS_INIT( MODULE_ID);
  cpl_msg_set_level( CPL_MSG_DEBUG);
  xsh_debug_level_set( XSH_DEBUG_LEVEL_MEDIUM) ;
 
  HandleOptions( argc, argv ) ;
 
  /* Create the 3D image */
  check( img_3d = xsh_image_3d_new( Nx, Ny, Nz, CPL_TYPE_INT ) ) ;
  xsh_msg( "Img 3D: axis: %dx%dx%d, type: %d", img_3d->nx, img_3d->ny,
       img_3d->nz, img_3d->type ) ;
 
  /* Loop over the Z axis */
  for( iz = 0 ; iz < Nz ; iz++ ) {
    cpl_error_code err = CPL_ERROR_NONE ;
    char i_name[128] ;
 
    /* Create one image */
    check( img = cpl_image_new( Nx, Ny, CPL_TYPE_INT ) ) ;
    /* Fill it */
    fill_image( img, iz*100 ) ;
    sprintf( i_name, "TEST_3D_IMG_%d.fits", iz ) ;
    cpl_image_save( img, i_name, CPL_BPP_32_SIGNED, NULL, CPL_IO_DEFAULT ) ;
    /* Insert the image into 3D image */
    err = xsh_image_3d_insert( img_3d, img, iz ) ;
    xsh_msg( " Insert Image err=%d", err ) ;
    //xsh_free_image( &img ) ;
  }
 
  /* Save 3D image */
  check( xsh_image_3d_save(img_3d, img_name,
               header, CPL_IO_DEFAULT ) ) ;
  xsh_msg( "Image Saved" ) ;
 
  ret = 0 ;
 
  /* Now reload the image and compare */
  new_3d = xsh_image_3d_load( img_name, CPL_TYPE_INT, 0 ) ;
  if( compare_img_3d( img_3d, new_3d ) != 0 ) {
    xsh_msg( "Finished BADLY" ) ;
    ret = 1 ;
  }
  else xsh_msg( "Finished OK" ) ;
 
 cleanup:
  return ret ;
}