2011-08-10 10:14:49 +02:00
/*
2012-11-15 16:22:29 +01:00
* Copyright ( c ) 2011 - 2012 , Centre National d ' Etudes Spatiales ( CNES ) , France
2011-08-10 10:14:49 +02:00
* All rights reserved .
*
* Redistribution and use in source and binary forms , with or without
* modification , are permitted provided that the following conditions
* are met :
* 1. Redistributions of source code must retain the above copyright
* notice , this list of conditions and the following disclaimer .
* 2. Redistributions in binary form must reproduce the above copyright
* notice , this list of conditions and the following disclaimer in the
* documentation and / or other materials provided with the distribution .
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ` AS IS '
* AND ANY EXPRESS OR IMPLIED WARRANTIES , INCLUDING , BUT NOT LIMITED TO , THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED . IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT , INDIRECT , INCIDENTAL , SPECIAL , EXEMPLARY , OR
* CONSEQUENTIAL DAMAGES ( INCLUDING , BUT NOT LIMITED TO , PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES ; LOSS OF USE , DATA , OR PROFITS ; OR BUSINESS
* INTERRUPTION ) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY , WHETHER IN
* CONTRACT , STRICT LIABILITY , OR TORT ( INCLUDING NEGLIGENCE OR OTHERWISE )
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE , EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE .
*/
2011-07-21 17:23:31 +02:00
/*
2014-03-07 17:24:24 +01:00
* compare_images . c
2011-07-21 17:23:31 +02:00
*
* Created on : 8 juil . 2011
* Author : mickael
*/
# include <stdio.h>
# include <stdlib.h>
# include <math.h>
# include <string.h>
2011-07-26 11:30:54 +02:00
# include <ctype.h>
2014-02-28 14:59:59 +01:00
# include <assert.h>
2011-07-21 17:23:31 +02:00
2013-03-03 18:55:35 +01:00
# include "opj_apps_config.h"
2011-09-01 13:24:08 +02:00
# include "opj_getopt.h"
2011-07-21 17:23:31 +02:00
# include "openjpeg.h"
# include "format_defs.h"
# include "convert.h"
2014-03-07 10:14:39 +01:00
# ifdef OPJ_HAVE_LIBTIFF
# include <tiffio.h> /* TIFFSetWarningHandler */
# endif /* OPJ_HAVE_LIBTIFF */
2014-02-28 14:19:03 +01:00
/*******************************************************************************
* Parse MSE and PEAK input values (
* separator = " : "
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static double * parseToleranceValues ( char * inArg , const int nbcomp )
{
2014-03-06 16:16:44 +01:00
double * outArgs = malloc ( ( size_t ) nbcomp * sizeof ( double ) ) ;
2014-02-28 14:19:03 +01:00
int it_comp = 0 ;
2014-02-28 14:59:59 +01:00
const char delims [ ] = " : " ;
char * result = strtok ( inArg , delims ) ;
2014-02-28 14:19:03 +01:00
while ( ( result ! = NULL ) & & ( it_comp < nbcomp ) )
{
2014-02-28 14:59:59 +01:00
outArgs [ it_comp ] = atof ( result ) ;
result = strtok ( NULL , delims ) ;
it_comp + + ;
2014-02-28 14:19:03 +01:00
}
if ( it_comp ! = nbcomp )
2014-02-28 14:59:59 +01:00
{
free ( outArgs ) ;
2014-02-28 14:19:03 +01:00
return NULL ;
2014-02-28 14:59:59 +01:00
}
2014-03-03 11:41:13 +01:00
/* else */
2014-02-28 14:59:59 +01:00
return outArgs ;
2014-02-28 14:19:03 +01:00
}
/*******************************************************************************
* Command line help function
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2014-03-07 17:24:24 +01:00
static void compare_images_help_display ( void )
2014-02-28 14:59:59 +01:00
{
2014-03-07 17:24:24 +01:00
fprintf ( stdout , " \n List of parameters for the compare_images function \n " ) ;
2014-02-28 14:19:03 +01:00
fprintf ( stdout , " \n " ) ;
2014-03-10 13:20:55 +01:00
fprintf ( stdout , " -b \t REQUIRED \t filename to the reference/baseline PGX/TIF/PNM image \n " ) ;
fprintf ( stdout , " -t \t REQUIRED \t filename to the test PGX/TIF/PNM image \n " ) ;
2015-09-10 00:39:23 +02:00
fprintf ( stdout , " -n \t REQUIRED \t number of component of the image (used to generate correct filename, not used when both input files are TIF) \n " ) ;
2014-02-28 14:19:03 +01:00
fprintf ( stdout , " -m \t OPTIONAL \t list of MSE tolerances, separated by : (size must correspond to the number of component) of \n " ) ;
fprintf ( stdout , " -p \t OPTIONAL \t list of PEAK tolerances, separated by : (size must correspond to the number of component) \n " ) ;
2014-03-10 13:20:55 +01:00
fprintf ( stdout , " -s \t OPTIONAL \t 1 or 2 filename separator to take into account PGX/PNM image with different components, "
2014-02-28 14:19:03 +01:00
" please indicate b or t before separator to indicate respectively the separator "
" for ref/base file and for test file. \n " ) ;
fprintf ( stdout , " -d \t OPTIONAL \t indicate if you want to run this function as conformance test or as non regression test \n " ) ;
fprintf ( stdout , " \n " ) ;
}
2014-03-10 13:20:55 +01:00
static int get_decod_format_from_string ( const char * filename )
{
const int dot = ' . ' ;
char * ext = strrchr ( filename , dot ) ;
if ( strcmp ( ext , " .pgx " ) = = 0 ) return PGX_DFMT ;
if ( strcmp ( ext , " .tif " ) = = 0 ) return TIF_DFMT ;
if ( strcmp ( ext , " .ppm " ) = = 0 ) return PXM_DFMT ;
return - 1 ;
}
2014-02-28 14:19:03 +01:00
/*******************************************************************************
2014-03-04 10:14:47 +01:00
* Create filenames from a filename using separator and nb components
* ( begin from 0 )
2014-02-28 14:19:03 +01:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static char * createMultiComponentsFilename ( const char * inFilename , const int indexF , const char * separator )
{
char s [ 255 ] ;
char * outFilename , * ptr ;
2014-02-28 14:59:59 +01:00
const char token = ' . ' ;
2014-03-10 14:05:20 +01:00
size_t posToken = 0 ;
2014-03-10 13:20:55 +01:00
int decod_format ;
2014-02-28 14:19:03 +01:00
/*printf("inFilename = %s\n", inFilename);*/
if ( ( ptr = strrchr ( inFilename , token ) ) ! = NULL )
{
2014-03-10 14:05:20 +01:00
posToken = strlen ( inFilename ) - strlen ( ptr ) ;
2014-02-28 14:19:03 +01:00
/*printf("Position of %c character inside inFilename = %d\n", token, posToken);*/
}
else
{
/*printf("Token %c not found\n", token);*/
outFilename = ( char * ) malloc ( 1 ) ;
outFilename [ 0 ] = ' \0 ' ;
return outFilename ;
}
2014-03-10 14:05:20 +01:00
outFilename = ( char * ) malloc ( ( posToken + 7 ) * sizeof ( char ) ) ; /*6*/
2014-02-28 14:19:03 +01:00
2014-03-10 14:05:20 +01:00
strncpy ( outFilename , inFilename , posToken ) ;
2014-03-10 14:51:16 +01:00
outFilename [ posToken ] = ' \0 ' ;
2014-02-28 14:19:03 +01:00
strcat ( outFilename , separator ) ;
sprintf ( s , " %i " , indexF ) ;
strcat ( outFilename , s ) ;
2014-03-10 13:20:55 +01:00
decod_format = get_decod_format_from_string ( inFilename ) ;
if ( decod_format = = PGX_DFMT )
{
strcat ( outFilename , " .pgx " ) ;
}
else if ( decod_format = = PXM_DFMT )
{
strcat ( outFilename , " .pgm " ) ;
}
2014-02-28 14:19:03 +01:00
/*printf("outfilename: %s\n", outFilename);*/
return outFilename ;
}
/*******************************************************************************
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2014-03-07 18:18:13 +01:00
static opj_image_t * readImageFromFilePPM ( const char * filename , int nbFilenamePGX , const char * separator )
{
int it_file ;
opj_image_t * image_read = NULL ;
opj_image_t * image = NULL ;
opj_cparameters_t parameters ;
opj_image_cmptparm_t * param_image_read ;
int * * data ;
/* If separator is empty => nb file to read is equal to one*/
if ( strlen ( separator ) = = 0 )
nbFilenamePGX = 1 ;
/* set encoding parameters to default values */
opj_set_default_encoder_parameters ( & parameters ) ;
parameters . decod_format = PXM_DFMT ;
strcpy ( parameters . infile , filename ) ;
/* Allocate memory*/
param_image_read = malloc ( ( size_t ) nbFilenamePGX * sizeof ( opj_image_cmptparm_t ) ) ;
data = malloc ( ( size_t ) nbFilenamePGX * sizeof ( * data ) ) ;
for ( it_file = 0 ; it_file < nbFilenamePGX ; it_file + + )
{
/* Create the right filename*/
char * filenameComponentPGX ;
if ( strlen ( separator ) = = 0 )
{
filenameComponentPGX = malloc ( ( strlen ( filename ) + 1 ) * sizeof ( * filenameComponentPGX ) ) ;
strcpy ( filenameComponentPGX , filename ) ;
}
else
filenameComponentPGX = createMultiComponentsFilename ( filename , it_file , separator ) ;
/* Read the tif file corresponding to the component */
image_read = pnmtoimage ( filenameComponentPGX , & parameters ) ;
if ( ! image_read )
{
int it_free_data ;
2014-03-14 12:37:44 +01:00
fprintf ( stderr , " Unable to load ppm file: %s \n " , filenameComponentPGX ) ;
2014-03-07 18:18:13 +01:00
free ( param_image_read ) ;
for ( it_free_data = 0 ; it_free_data < it_file ; it_free_data + + ) {
free ( data [ it_free_data ] ) ;
}
free ( data ) ;
free ( filenameComponentPGX ) ;
return NULL ;
}
/* Set the image_read parameters*/
param_image_read [ it_file ] . x0 = 0 ;
param_image_read [ it_file ] . y0 = 0 ;
param_image_read [ it_file ] . dx = 0 ;
param_image_read [ it_file ] . dy = 0 ;
param_image_read [ it_file ] . h = image_read - > comps - > h ;
param_image_read [ it_file ] . w = image_read - > comps - > w ;
param_image_read [ it_file ] . bpp = image_read - > comps - > bpp ;
param_image_read [ it_file ] . prec = image_read - > comps - > prec ;
param_image_read [ it_file ] . sgnd = image_read - > comps - > sgnd ;
/* Copy data*/
data [ it_file ] = malloc ( param_image_read [ it_file ] . h * param_image_read [ it_file ] . w * sizeof ( int ) ) ;
memcpy ( data [ it_file ] , image_read - > comps - > data , image_read - > comps - > h * image_read - > comps - > w * sizeof ( int ) ) ;
/* Free memory*/
opj_image_destroy ( image_read ) ;
free ( filenameComponentPGX ) ;
}
image = opj_image_create ( ( OPJ_UINT32 ) nbFilenamePGX , param_image_read , OPJ_CLRSPC_UNSPECIFIED ) ;
for ( it_file = 0 ; it_file < nbFilenamePGX ; it_file + + )
{
/* Copy data into output image and free memory*/
memcpy ( image - > comps [ it_file ] . data , data [ it_file ] , image - > comps [ it_file ] . h * image - > comps [ it_file ] . w * sizeof ( int ) ) ;
free ( data [ it_file ] ) ;
}
/* Free memory*/
free ( param_image_read ) ;
free ( data ) ;
return image ;
}
2014-03-04 10:14:47 +01:00
static opj_image_t * readImageFromFileTIF ( const char * filename , int nbFilenamePGX , const char * separator )
{
opj_image_t * image_read = NULL ;
opj_cparameters_t parameters ;
2014-03-12 11:50:47 +01:00
( void ) nbFilenamePGX ;
( void ) separator ;
2014-03-04 10:14:47 +01:00
2014-03-07 15:33:03 +01:00
/* conformance test suite produce annoying warning/error:
2014-03-07 10:03:15 +01:00
* TIFFReadDirectory : Warning , / . . . / data / baseline / conformance / jp2_1 . tif : unknown field with tag 37724 ( 0x935c ) encountered .
2014-03-07 15:33:03 +01:00
* TIFFOpen : / . . . / data / baseline / nonregression / opj_jp2_1 . tif : Cannot open .
2014-03-07 10:03:15 +01:00
* On Win32 this open a message box by default , so remove it from the test suite :
*/
2014-03-10 10:36:14 +01:00
# ifdef OPJ_HAVE_LIBTIFF
2014-03-07 10:03:15 +01:00
TIFFSetWarningHandler ( NULL ) ;
2014-03-07 15:33:03 +01:00
TIFFSetErrorHandler ( NULL ) ;
2014-03-10 10:36:14 +01:00
# endif
2014-03-07 10:03:15 +01:00
2014-03-13 13:26:06 +01:00
if ( strlen ( separator ) ! = 0 ) return NULL ;
2014-03-04 10:14:47 +01:00
/* set encoding parameters to default values */
opj_set_default_encoder_parameters ( & parameters ) ;
parameters . decod_format = TIF_DFMT ;
2014-03-06 15:50:42 +01:00
strcpy ( parameters . infile , filename ) ;
2014-03-04 10:14:47 +01:00
2014-03-12 11:50:47 +01:00
/* Read the tif file corresponding to the component */
2014-03-10 10:36:14 +01:00
# ifdef OPJ_HAVE_LIBTIFF
2014-03-12 11:50:47 +01:00
image_read = tiftoimage ( filename , & parameters ) ;
2014-03-10 10:36:14 +01:00
# endif
2014-03-12 11:50:47 +01:00
if ( ! image_read )
2014-03-04 10:14:47 +01:00
{
2014-03-12 11:50:47 +01:00
fprintf ( stderr , " Unable to load TIF file \n " ) ;
return NULL ;
2014-03-04 10:14:47 +01:00
}
2014-03-12 11:50:47 +01:00
return image_read ;
2014-03-04 10:14:47 +01:00
}
2014-02-28 14:59:59 +01:00
static opj_image_t * readImageFromFilePGX ( const char * filename , int nbFilenamePGX , const char * separator )
2014-02-28 14:19:03 +01:00
{
int it_file ;
opj_image_t * image_read = NULL ;
opj_image_t * image = NULL ;
opj_cparameters_t parameters ;
opj_image_cmptparm_t * param_image_read ;
int * * data ;
/* If separator is empty => nb file to read is equal to one*/
if ( strlen ( separator ) = = 0 )
2014-02-28 14:59:59 +01:00
nbFilenamePGX = 1 ;
2014-02-28 14:19:03 +01:00
/* set encoding parameters to default values */
opj_set_default_encoder_parameters ( & parameters ) ;
parameters . decod_format = PGX_DFMT ;
2014-03-07 09:11:49 +01:00
strcpy ( parameters . infile , filename ) ;
2014-02-28 14:19:03 +01:00
/* Allocate memory*/
2014-03-06 16:16:44 +01:00
param_image_read = malloc ( ( size_t ) nbFilenamePGX * sizeof ( opj_image_cmptparm_t ) ) ;
data = malloc ( ( size_t ) nbFilenamePGX * sizeof ( * data ) ) ;
2014-02-28 14:19:03 +01:00
for ( it_file = 0 ; it_file < nbFilenamePGX ; it_file + + )
{
/* Create the right filename*/
char * filenameComponentPGX ;
if ( strlen ( separator ) = = 0 )
{
filenameComponentPGX = malloc ( ( strlen ( filename ) + 1 ) * sizeof ( * filenameComponentPGX ) ) ;
strcpy ( filenameComponentPGX , filename ) ;
}
else
filenameComponentPGX = createMultiComponentsFilename ( filename , it_file , separator ) ;
/* Read the pgx file corresponding to the component */
image_read = pgxtoimage ( filenameComponentPGX , & parameters ) ;
if ( ! image_read )
2014-02-28 14:59:59 +01:00
{
int it_free_data ;
fprintf ( stderr , " Unable to load pgx file \n " ) ;
2014-02-28 14:19:03 +01:00
2014-02-28 14:59:59 +01:00
free ( param_image_read ) ;
2014-02-28 14:19:03 +01:00
2014-02-28 14:59:59 +01:00
for ( it_free_data = 0 ; it_free_data < it_file ; it_free_data + + ) {
free ( data [ it_free_data ] ) ;
}
free ( data ) ;
2014-02-28 14:19:03 +01:00
2014-02-28 14:59:59 +01:00
free ( filenameComponentPGX ) ;
2014-02-28 14:19:03 +01:00
2014-02-28 14:59:59 +01:00
return NULL ;
}
2014-02-28 14:19:03 +01:00
/* Set the image_read parameters*/
param_image_read [ it_file ] . x0 = 0 ;
param_image_read [ it_file ] . y0 = 0 ;
param_image_read [ it_file ] . dx = 0 ;
param_image_read [ it_file ] . dy = 0 ;
param_image_read [ it_file ] . h = image_read - > comps - > h ;
param_image_read [ it_file ] . w = image_read - > comps - > w ;
param_image_read [ it_file ] . bpp = image_read - > comps - > bpp ;
param_image_read [ it_file ] . prec = image_read - > comps - > prec ;
param_image_read [ it_file ] . sgnd = image_read - > comps - > sgnd ;
/* Copy data*/
data [ it_file ] = malloc ( param_image_read [ it_file ] . h * param_image_read [ it_file ] . w * sizeof ( int ) ) ;
memcpy ( data [ it_file ] , image_read - > comps - > data , image_read - > comps - > h * image_read - > comps - > w * sizeof ( int ) ) ;
/* Free memory*/
opj_image_destroy ( image_read ) ;
free ( filenameComponentPGX ) ;
}
2014-03-06 16:16:44 +01:00
image = opj_image_create ( ( OPJ_UINT32 ) nbFilenamePGX , param_image_read , OPJ_CLRSPC_UNSPECIFIED ) ;
2014-02-28 14:19:03 +01:00
for ( it_file = 0 ; it_file < nbFilenamePGX ; it_file + + )
{
/* Copy data into output image and free memory*/
memcpy ( image - > comps [ it_file ] . data , data [ it_file ] , image - > comps [ it_file ] . h * image - > comps [ it_file ] . w * sizeof ( int ) ) ;
free ( data [ it_file ] ) ;
}
/* Free memory*/
free ( param_image_read ) ;
free ( data ) ;
return image ;
}
2014-02-28 15:31:01 +01:00
# if defined(OPJ_HAVE_LIBPNG) && 0 /* remove for now */
2014-02-28 14:19:03 +01:00
/*******************************************************************************
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static int imageToPNG ( const opj_image_t * image , const char * filename , int num_comp_select )
{
opj_image_cmptparm_t param_image_write ;
opj_image_t * image_write = NULL ;
param_image_write . x0 = 0 ;
param_image_write . y0 = 0 ;
param_image_write . dx = 0 ;
param_image_write . dy = 0 ;
param_image_write . h = image - > comps [ num_comp_select ] . h ;
param_image_write . w = image - > comps [ num_comp_select ] . w ;
param_image_write . bpp = image - > comps [ num_comp_select ] . bpp ;
param_image_write . prec = image - > comps [ num_comp_select ] . prec ;
param_image_write . sgnd = image - > comps [ num_comp_select ] . sgnd ;
2014-03-06 16:16:44 +01:00
image_write = opj_image_create ( 1u , & param_image_write , OPJ_CLRSPC_GRAY ) ;
2014-02-28 14:19:03 +01:00
memcpy ( image_write - > comps - > data , image - > comps [ num_comp_select ] . data , param_image_write . h * param_image_write . w * sizeof ( int ) ) ;
imagetopng ( image_write , filename ) ;
opj_image_destroy ( image_write ) ;
return EXIT_SUCCESS ;
}
2011-07-21 17:23:31 +02:00
# endif
typedef struct test_cmp_parameters
{
/** */
char * base_filename ;
/** */
char * test_filename ;
/** Number of components */
int nbcomp ;
/** */
double * tabMSEvalues ;
/** */
double * tabPEAKvalues ;
/** */
int nr_flag ;
/** */
char separator_base [ 2 ] ;
/** */
char separator_test [ 2 ] ;
} test_cmp_parameters ;
2014-03-10 13:20:55 +01:00
/* return decode format PGX / TIF / PPM , return -1 on error */
2014-03-04 10:14:47 +01:00
static int get_decod_format ( test_cmp_parameters * param )
{
2014-03-10 13:20:55 +01:00
int base_format = get_decod_format_from_string ( param - > base_filename ) ;
int test_format = get_decod_format_from_string ( param - > test_filename ) ;
if ( base_format ! = test_format ) return - 1 ;
/* handle case -1: */
return base_format ;
2014-03-04 10:14:47 +01:00
}
2011-07-21 17:23:31 +02:00
/*******************************************************************************
* Parse command line
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2012-03-19 11:00:06 +01:00
static int parse_cmdline_cmp ( int argc , char * * argv , test_cmp_parameters * param )
2011-07-21 17:23:31 +02:00
{
char * MSElistvalues = NULL ; char * PEAKlistvalues = NULL ;
char * separatorList = NULL ;
2014-03-10 14:05:20 +01:00
size_t sizemembasefile , sizememtestfile ;
2011-07-21 17:23:31 +02:00
int index , flagM = 0 , flagP = 0 ;
const char optlist [ ] = " b:t:n:m:p:s:d " ;
int c ;
2012-03-02 16:07:07 +01:00
/* Init parameters*/
2011-07-21 17:23:31 +02:00
param - > base_filename = NULL ;
param - > test_filename = NULL ;
param - > nbcomp = 0 ;
param - > tabMSEvalues = NULL ;
param - > tabPEAKvalues = NULL ;
param - > nr_flag = 0 ;
2014-02-28 14:59:59 +01:00
param - > separator_base [ 0 ] = 0 ;
param - > separator_test [ 0 ] = 0 ;
2011-07-21 17:23:31 +02:00
2011-09-01 13:24:08 +02:00
opj_opterr = 0 ;
2011-07-21 17:23:31 +02:00
2011-09-01 13:24:08 +02:00
while ( ( c = opj_getopt ( argc , argv , optlist ) ) ! = - 1 )
2011-07-21 17:23:31 +02:00
switch ( c )
{
case ' b ' :
2014-03-10 14:05:20 +01:00
sizemembasefile = strlen ( opj_optarg ) + 1 ;
param - > base_filename = ( char * ) malloc ( sizemembasefile ) ;
strcpy ( param - > base_filename , opj_optarg ) ;
2012-03-02 16:07:07 +01:00
/*printf("param->base_filename = %s [%d / %d]\n", param->base_filename, strlen(param->base_filename), sizemembasefile );*/
2011-07-21 17:23:31 +02:00
break ;
case ' t ' :
2014-03-10 14:05:20 +01:00
sizememtestfile = strlen ( opj_optarg ) + 1 ;
param - > test_filename = ( char * ) malloc ( sizememtestfile ) ;
strcpy ( param - > test_filename , opj_optarg ) ;
2012-03-02 16:07:07 +01:00
/*printf("param->test_filename = %s [%d / %d]\n", param->test_filename, strlen(param->test_filename), sizememtestfile);*/
2011-07-21 17:23:31 +02:00
break ;
case ' n ' :
2011-09-01 13:24:08 +02:00
param - > nbcomp = atoi ( opj_optarg ) ;
2011-07-21 17:23:31 +02:00
break ;
case ' m ' :
2011-09-01 13:24:08 +02:00
MSElistvalues = opj_optarg ;
2011-07-21 17:23:31 +02:00
flagM = 1 ;
break ;
case ' p ' :
2011-09-01 13:24:08 +02:00
PEAKlistvalues = opj_optarg ;
2011-07-21 17:23:31 +02:00
flagP = 1 ;
break ;
case ' d ' :
param - > nr_flag = 1 ;
break ;
case ' s ' :
2011-09-01 13:24:08 +02:00
separatorList = opj_optarg ;
2011-07-21 17:23:31 +02:00
break ;
case ' ? ' :
2011-09-01 13:24:08 +02:00
if ( ( opj_optopt = = ' b ' ) | | ( opj_optopt = = ' t ' ) | | ( opj_optopt = = ' n ' ) | | ( opj_optopt = = ' p ' ) | | ( opj_optopt = = ' m ' ) | | ( opj_optopt
2011-07-21 17:23:31 +02:00
= = ' s ' ) )
2011-09-01 13:24:08 +02:00
fprintf ( stderr , " Option -%c requires an argument. \n " , opj_optopt ) ;
2011-07-21 17:23:31 +02:00
else
2011-09-01 13:24:08 +02:00
if ( isprint ( opj_optopt ) ) fprintf ( stderr , " Unknown option `-%c'. \n " , opj_optopt ) ;
else fprintf ( stderr , " Unknown option character ` \\ x%x'. \n " , opj_optopt ) ;
2011-07-21 17:23:31 +02:00
return 1 ;
default :
2011-09-01 13:24:08 +02:00
fprintf ( stderr , " WARNING -> this option is not valid \" -%c %s \" \n " , c , opj_optarg ) ;
2011-07-21 17:23:31 +02:00
break ;
}
2011-09-01 13:24:08 +02:00
if ( opj_optind ! = argc )
2011-07-21 17:23:31 +02:00
{
2011-09-01 13:24:08 +02:00
for ( index = opj_optind ; index < argc ; index + + )
2011-07-21 17:23:31 +02:00
fprintf ( stderr , " Non-option argument %s \n " , argv [ index ] ) ;
2014-02-28 14:59:59 +01:00
return 1 ;
2011-07-21 17:23:31 +02:00
}
if ( param - > nbcomp = = 0 )
{
fprintf ( stderr , " Need to indicate the number of components ! \n " ) ;
2014-02-28 14:59:59 +01:00
return 1 ;
2011-07-21 17:23:31 +02:00
}
2014-03-04 10:14:47 +01:00
/* else */
if ( flagM & & flagP )
2011-07-21 17:23:31 +02:00
{
2014-03-04 10:14:47 +01:00
param - > tabMSEvalues = parseToleranceValues ( MSElistvalues , param - > nbcomp ) ;
param - > tabPEAKvalues = parseToleranceValues ( PEAKlistvalues , param - > nbcomp ) ;
if ( ( param - > tabMSEvalues = = NULL ) | | ( param - > tabPEAKvalues = = NULL ) )
2011-07-21 17:23:31 +02:00
{
2014-03-04 10:14:47 +01:00
fprintf ( stderr , " MSE and PEAK values are not correct (respectively need %d values) \n " , param - > nbcomp ) ;
return 1 ;
2011-07-21 17:23:31 +02:00
}
}
2012-03-02 16:07:07 +01:00
/* Get separators after corresponding letter (b or t)*/
2011-07-21 17:23:31 +02:00
if ( separatorList ! = NULL )
{
if ( ( strlen ( separatorList ) = = 2 ) | | ( strlen ( separatorList ) = = 4 ) )
{
2012-03-02 16:07:07 +01:00
/* keep original string*/
2014-03-10 14:05:20 +01:00
size_t sizeseplist = strlen ( separatorList ) + 1 ;
char * separatorList2 = ( char * ) malloc ( sizeseplist ) ;
strcpy ( separatorList2 , separatorList ) ;
2012-03-02 16:07:07 +01:00
/*printf("separatorList2 = %s [%d / %d]\n", separatorList2, strlen(separatorList2), sizeseplist);*/
2011-07-21 17:23:31 +02:00
2012-03-02 16:07:07 +01:00
if ( strlen ( separatorList ) = = 2 ) /* one separator behind b or t*/
2011-07-21 17:23:31 +02:00
{
char * resultT = NULL ;
resultT = strtok ( separatorList2 , " t " ) ;
2012-03-02 16:07:07 +01:00
if ( strlen ( resultT ) = = strlen ( separatorList ) ) /* didn't find t character, try to find b*/
2011-07-21 17:23:31 +02:00
{
char * resultB = NULL ;
resultB = strtok ( resultT , " b " ) ;
if ( strlen ( resultB ) = = 1 )
{
2014-02-28 14:59:59 +01:00
param - > separator_base [ 0 ] = separatorList [ 1 ] ;
param - > separator_base [ 1 ] = 0 ;
param - > separator_test [ 0 ] = 0 ;
2011-07-21 17:23:31 +02:00
}
2012-03-02 16:07:07 +01:00
else /* not found b*/
2011-07-21 17:23:31 +02:00
{
free ( separatorList2 ) ;
2014-02-28 14:59:59 +01:00
return 1 ;
2011-07-21 17:23:31 +02:00
}
}
2012-03-02 16:07:07 +01:00
else /* found t*/
2011-07-21 17:23:31 +02:00
{
2014-02-28 14:59:59 +01:00
param - > separator_base [ 0 ] = 0 ;
param - > separator_test [ 0 ] = separatorList [ 1 ] ;
param - > separator_test [ 1 ] = 0 ;
2011-07-21 17:23:31 +02:00
}
2012-03-02 16:07:07 +01:00
/*printf("sep b = %s [%d] and sep t = %s [%d]\n",param->separator_base, strlen(param->separator_base), param->separator_test, strlen(param->separator_test) );*/
2011-07-21 17:23:31 +02:00
}
2012-03-02 16:07:07 +01:00
else /* == 4 characters we must found t and b*/
2011-07-21 17:23:31 +02:00
{
char * resultT = NULL ;
resultT = strtok ( separatorList2 , " t " ) ;
2012-03-02 16:07:07 +01:00
if ( strlen ( resultT ) = = 3 ) /* found t in first place*/
2011-07-21 17:23:31 +02:00
{
char * resultB = NULL ;
resultB = strtok ( resultT , " b " ) ;
2012-03-02 16:07:07 +01:00
if ( strlen ( resultB ) = = 1 ) /* found b after t*/
2011-07-21 17:23:31 +02:00
{
2014-02-28 14:59:59 +01:00
param - > separator_test [ 0 ] = separatorList [ 1 ] ;
param - > separator_test [ 1 ] = 0 ;
param - > separator_base [ 0 ] = separatorList [ 3 ] ;
param - > separator_base [ 1 ] = 0 ;
2011-07-21 17:23:31 +02:00
}
2012-03-02 16:07:07 +01:00
else /* didn't find b after t*/
2011-07-21 17:23:31 +02:00
{
free ( separatorList2 ) ;
2014-02-28 14:59:59 +01:00
return 1 ;
2011-07-21 17:23:31 +02:00
}
}
2012-03-02 16:07:07 +01:00
else /* == 2, didn't find t in first place*/
2011-07-21 17:23:31 +02:00
{
char * resultB = NULL ;
resultB = strtok ( resultT , " b " ) ;
2012-03-02 16:07:07 +01:00
if ( strlen ( resultB ) = = 1 ) /* found b in first place*/
2011-07-21 17:23:31 +02:00
{
2014-02-28 14:59:59 +01:00
param - > separator_base [ 0 ] = separatorList [ 1 ] ;
param - > separator_base [ 1 ] = 0 ;
param - > separator_test [ 0 ] = separatorList [ 3 ] ;
param - > separator_test [ 1 ] = 0 ;
2011-07-21 17:23:31 +02:00
}
2012-03-02 16:07:07 +01:00
else /* didn't found b in first place => problem*/
2011-07-21 17:23:31 +02:00
{
free ( separatorList2 ) ;
2014-02-28 14:59:59 +01:00
return 1 ;
2011-07-21 17:23:31 +02:00
}
}
}
free ( separatorList2 ) ;
}
2012-03-02 16:07:07 +01:00
else /* wrong number of argument after -s*/
2011-07-21 17:23:31 +02:00
{
2014-02-28 14:59:59 +01:00
return 1 ;
2011-07-21 17:23:31 +02:00
}
}
else
{
if ( param - > nbcomp = = 1 )
{
2014-02-28 14:59:59 +01:00
assert ( param - > separator_base [ 0 ] = = 0 ) ;
assert ( param - > separator_test [ 0 ] = = 0 ) ;
2011-07-21 17:23:31 +02:00
}
else
{
fprintf ( stderr , " If number of component is > 1, we need separator \n " ) ;
2014-02-28 14:59:59 +01:00
return 1 ;
2011-07-21 17:23:31 +02:00
}
}
if ( ( param - > nr_flag ) & & ( flagP | | flagM ) )
{
fprintf ( stderr , " Wrong input parameters list: it is non-regression test or tolerance comparison \n " ) ;
2014-02-28 14:59:59 +01:00
return 1 ;
2011-07-21 17:23:31 +02:00
}
if ( ( ! param - > nr_flag ) & & ( ! flagP | | ! flagM ) )
{
fprintf ( stderr , " Wrong input parameters list: it is non-regression test or tolerance comparison \n " ) ;
2014-02-28 14:59:59 +01:00
return 1 ;
2011-07-21 17:23:31 +02:00
}
2014-02-28 14:59:59 +01:00
return 0 ;
2011-07-21 17:23:31 +02:00
}
/*******************************************************************************
* MAIN
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int main ( int argc , char * * argv )
{
test_cmp_parameters inParam ;
2012-03-19 11:00:06 +01:00
OPJ_UINT32 it_comp , itpxl ;
2014-02-28 15:17:30 +01:00
int failed = 1 ;
2014-02-28 15:31:01 +01:00
int nbFilenamePGXbase = 0 , nbFilenamePGXtest = 0 ;
2011-07-21 17:23:31 +02:00
char * filenamePNGtest = NULL , * filenamePNGbase = NULL , * filenamePNGdiff = NULL ;
2014-03-12 11:50:47 +01:00
size_t memsizebasefilename , memsizetestfilename ;
2014-02-28 14:19:03 +01:00
size_t memsizedifffilename ;
2011-07-21 17:23:31 +02:00
int valueDiff = 0 , nbPixelDiff = 0 ;
double sumDiff = 0.0 ;
2012-03-02 16:07:07 +01:00
/* Structures to store image parameters and data*/
2011-07-21 17:23:31 +02:00
opj_image_t * imageBase = NULL , * imageTest = NULL , * imageDiff = NULL ;
2014-02-28 15:17:30 +01:00
opj_image_cmptparm_t * param_image_diff = NULL ;
2014-03-04 10:14:47 +01:00
int decod_format ;
2011-07-21 17:23:31 +02:00
2012-03-02 16:07:07 +01:00
/* Get parameters from command line*/
2014-02-28 14:59:59 +01:00
if ( parse_cmdline_cmp ( argc , argv , & inParam ) )
2011-07-21 17:23:31 +02:00
{
2014-03-07 17:24:24 +01:00
compare_images_help_display ( ) ;
2014-02-28 15:17:30 +01:00
goto cleanup ;
2011-07-21 17:23:31 +02:00
}
2012-03-02 16:07:07 +01:00
/* Display Parameters*/
2011-07-21 17:23:31 +02:00
printf ( " ******Parameters********* \n " ) ;
printf ( " base_filename = %s \n "
" test_filename = %s \n "
" nb of Components = %d \n "
" Non regression test = %d \n "
" separator Base = %s \n "
" separator Test = %s \n " ,
inParam . base_filename , inParam . test_filename , inParam . nbcomp ,
inParam . nr_flag , inParam . separator_base , inParam . separator_test ) ;
if ( ( inParam . tabMSEvalues ! = NULL ) & & ( inParam . tabPEAKvalues ! = NULL ) )
2012-03-19 11:00:06 +01:00
{
2014-03-10 09:25:08 +01:00
int it_comp2 ;
2011-07-21 17:23:31 +02:00
printf ( " MSE values = [ " ) ;
2014-03-10 09:25:08 +01:00
for ( it_comp2 = 0 ; it_comp2 < inParam . nbcomp ; it_comp2 + + )
printf ( " %f " , inParam . tabMSEvalues [ it_comp2 ] ) ;
2011-07-21 17:23:31 +02:00
printf ( " ] \n " ) ;
printf ( " PEAK values = [ " ) ;
2014-03-10 09:25:08 +01:00
for ( it_comp2 = 0 ; it_comp2 < inParam . nbcomp ; it_comp2 + + )
printf ( " %f " , inParam . tabPEAKvalues [ it_comp2 ] ) ;
2011-07-21 17:23:31 +02:00
printf ( " ] \n " ) ;
printf ( " Non-regression test = %d \n " , inParam . nr_flag ) ;
}
2014-02-28 15:31:01 +01:00
if ( strlen ( inParam . separator_base ) ! = 0 )
2011-07-21 17:23:31 +02:00
nbFilenamePGXbase = inParam . nbcomp ;
2014-02-28 15:31:01 +01:00
if ( strlen ( inParam . separator_test ) ! = 0 )
2011-07-21 17:23:31 +02:00
nbFilenamePGXtest = inParam . nbcomp ;
printf ( " NbFilename to generate from base filename = %d \n " , nbFilenamePGXbase ) ;
printf ( " NbFilename to generate from test filename = %d \n " , nbFilenamePGXtest ) ;
printf ( " ************************* \n " ) ;
2012-03-02 16:07:07 +01:00
/*----------BASELINE IMAGE--------*/
2014-03-12 11:50:47 +01:00
memsizebasefilename = strlen ( inParam . test_filename ) + 1 + 5 + 2 + 4 ;
memsizetestfilename = strlen ( inParam . test_filename ) + 1 + 5 + 2 + 4 ;
2011-07-21 17:23:31 +02:00
2014-03-04 10:14:47 +01:00
decod_format = get_decod_format ( & inParam ) ;
2014-03-07 18:18:13 +01:00
if ( decod_format = = - 1 )
{
fprintf ( stderr , " Unhandled file format \n " ) ;
goto cleanup ;
}
assert ( decod_format = = PGX_DFMT | | decod_format = = TIF_DFMT | | decod_format = = PXM_DFMT ) ;
2014-03-04 10:14:47 +01:00
if ( decod_format = = PGX_DFMT )
{
imageBase = readImageFromFilePGX ( inParam . base_filename , nbFilenamePGXbase , inParam . separator_base ) ;
if ( imageBase = = NULL )
goto cleanup ;
}
else if ( decod_format = = TIF_DFMT )
{
imageBase = readImageFromFileTIF ( inParam . base_filename , nbFilenamePGXbase , " " ) ;
if ( imageBase = = NULL )
goto cleanup ;
}
2014-03-07 18:18:13 +01:00
else if ( decod_format = = PXM_DFMT )
{
2014-03-10 13:20:55 +01:00
imageBase = readImageFromFilePPM ( inParam . base_filename , nbFilenamePGXbase , inParam . separator_base ) ;
2014-03-07 18:18:13 +01:00
if ( imageBase = = NULL )
goto cleanup ;
}
2014-02-28 15:38:45 +01:00
2014-03-12 11:50:47 +01:00
filenamePNGbase = ( char * ) malloc ( memsizebasefilename ) ;
2014-02-28 15:38:45 +01:00
strcpy ( filenamePNGbase , inParam . test_filename ) ;
strcat ( filenamePNGbase , " .base " ) ;
/*printf("filenamePNGbase = %s [%d / %d octets]\n",filenamePNGbase, strlen(filenamePNGbase),memsizebasefilename );*/
2011-07-21 17:23:31 +02:00
2012-03-02 16:07:07 +01:00
/*----------TEST IMAGE--------*/
2011-07-21 17:23:31 +02:00
2014-03-04 10:14:47 +01:00
if ( decod_format = = PGX_DFMT )
{
imageTest = readImageFromFilePGX ( inParam . test_filename , nbFilenamePGXtest , inParam . separator_test ) ;
if ( imageTest = = NULL )
goto cleanup ;
}
else if ( decod_format = = TIF_DFMT )
{
imageTest = readImageFromFileTIF ( inParam . test_filename , nbFilenamePGXtest , " " ) ;
if ( imageTest = = NULL )
goto cleanup ;
}
2014-03-07 18:18:13 +01:00
else if ( decod_format = = PXM_DFMT )
{
2014-03-10 13:20:55 +01:00
imageTest = readImageFromFilePPM ( inParam . test_filename , nbFilenamePGXtest , inParam . separator_test ) ;
2014-03-07 18:18:13 +01:00
if ( imageTest = = NULL )
goto cleanup ;
}
2014-02-28 15:38:45 +01:00
2014-03-12 11:50:47 +01:00
filenamePNGtest = ( char * ) malloc ( memsizetestfilename ) ;
2014-02-28 15:38:45 +01:00
strcpy ( filenamePNGtest , inParam . test_filename ) ;
strcat ( filenamePNGtest , " .test " ) ;
/*printf("filenamePNGtest = %s [%d / %d octets]\n",filenamePNGtest, strlen(filenamePNGtest),memsizetestfilename );*/
2011-07-21 17:23:31 +02:00
2012-03-02 16:07:07 +01:00
/*----------DIFF IMAGE--------*/
2011-07-21 17:23:31 +02:00
2012-03-02 16:07:07 +01:00
/* Allocate memory*/
2011-07-21 17:23:31 +02:00
param_image_diff = malloc ( imageBase - > numcomps * sizeof ( opj_image_cmptparm_t ) ) ;
2012-03-02 16:07:07 +01:00
/* Comparison of header parameters*/
2011-07-21 17:23:31 +02:00
printf ( " Step 1 -> Header comparison \n " ) ;
2014-03-17 17:18:22 +01:00
/* check dimensions (issue 286)*/
if ( imageBase - > numcomps ! = imageTest - > numcomps )
{
printf ( " ERROR: dim mismatch (%d><%d) \n " , imageBase - > numcomps , imageTest - > numcomps ) ;
goto cleanup ;
}
2011-07-21 17:23:31 +02:00
for ( it_comp = 0 ; it_comp < imageBase - > numcomps ; it_comp + + )
{
param_image_diff [ it_comp ] . x0 = 0 ;
param_image_diff [ it_comp ] . y0 = 0 ;
param_image_diff [ it_comp ] . dx = 0 ;
param_image_diff [ it_comp ] . dy = 0 ;
2014-02-28 15:31:01 +01:00
param_image_diff [ it_comp ] . sgnd = 0 ;
param_image_diff [ it_comp ] . prec = 8 ;
param_image_diff [ it_comp ] . bpp = 1 ;
param_image_diff [ it_comp ] . h = imageBase - > comps [ it_comp ] . h ;
param_image_diff [ it_comp ] . w = imageBase - > comps [ it_comp ] . w ;
2011-07-21 17:23:31 +02:00
if ( imageBase - > comps [ it_comp ] . sgnd ! = imageTest - > comps [ it_comp ] . sgnd )
{
printf ( " ERROR: sign mismatch [comp %d] (%d><%d) \n " , it_comp , ( ( imageBase - > comps ) [ it_comp ] ) . sgnd , ( ( imageTest - > comps ) [ it_comp ] ) . sgnd ) ;
2014-02-28 15:17:30 +01:00
goto cleanup ;
2011-07-21 17:23:31 +02:00
}
if ( ( ( imageBase - > comps ) [ it_comp ] ) . prec ! = ( ( imageTest - > comps ) [ it_comp ] ) . prec )
{
printf ( " ERROR: prec mismatch [comp %d] (%d><%d) \n " , it_comp , ( ( imageBase - > comps ) [ it_comp ] ) . prec , ( ( imageTest - > comps ) [ it_comp ] ) . prec ) ;
2014-02-28 15:17:30 +01:00
goto cleanup ;
2011-07-21 17:23:31 +02:00
}
if ( ( ( imageBase - > comps ) [ it_comp ] ) . bpp ! = ( ( imageTest - > comps ) [ it_comp ] ) . bpp )
{
printf ( " ERROR: byte per pixel mismatch [comp %d] (%d><%d) \n " , it_comp , ( ( imageBase - > comps ) [ it_comp ] ) . bpp , ( ( imageTest - > comps ) [ it_comp ] ) . bpp ) ;
2014-02-28 15:17:30 +01:00
goto cleanup ;
2011-07-21 17:23:31 +02:00
}
if ( ( ( imageBase - > comps ) [ it_comp ] ) . h ! = ( ( imageTest - > comps ) [ it_comp ] ) . h )
{
printf ( " ERROR: height mismatch [comp %d] (%d><%d) \n " , it_comp , ( ( imageBase - > comps ) [ it_comp ] ) . h , ( ( imageTest - > comps ) [ it_comp ] ) . h ) ;
2014-02-28 15:17:30 +01:00
goto cleanup ;
2011-07-21 17:23:31 +02:00
}
if ( ( ( imageBase - > comps ) [ it_comp ] ) . w ! = ( ( imageTest - > comps ) [ it_comp ] ) . w )
{
printf ( " ERROR: width mismatch [comp %d] (%d><%d) \n " , it_comp , ( ( imageBase - > comps ) [ it_comp ] ) . w , ( ( imageTest - > comps ) [ it_comp ] ) . w ) ;
2014-02-28 15:17:30 +01:00
goto cleanup ;
2011-07-21 17:23:31 +02:00
}
}
2012-11-15 14:38:35 +01:00
imageDiff = opj_image_create ( imageBase - > numcomps , param_image_diff , OPJ_CLRSPC_UNSPECIFIED ) ;
2012-03-02 16:07:07 +01:00
/* Free memory*/
2014-02-28 15:17:30 +01:00
free ( param_image_diff ) ; param_image_diff = NULL ;
2011-07-21 17:23:31 +02:00
2012-03-02 16:07:07 +01:00
/* Measurement computation*/
2011-07-21 17:23:31 +02:00
printf ( " Step 2 -> measurement comparison \n " ) ;
memsizedifffilename = strlen ( inParam . test_filename ) + 1 + 5 + 2 + 4 ;
filenamePNGdiff = ( char * ) malloc ( memsizedifffilename ) ;
2014-02-28 15:31:01 +01:00
strcpy ( filenamePNGdiff , inParam . test_filename ) ;
2011-07-21 17:23:31 +02:00
strcat ( filenamePNGdiff , " .diff " ) ;
2012-03-02 16:07:07 +01:00
/*printf("filenamePNGdiff = %s [%d / %d octets]\n",filenamePNGdiff, strlen(filenamePNGdiff),memsizedifffilename );*/
2011-07-21 17:23:31 +02:00
2012-03-02 16:07:07 +01:00
/* Compute pixel diff*/
2011-07-21 17:23:31 +02:00
for ( it_comp = 0 ; it_comp < imageDiff - > numcomps ; it_comp + + )
{
double SE = 0 , PEAK = 0 ;
2011-07-25 18:33:52 +02:00
double MSE = 0 ;
2011-07-21 17:23:31 +02:00
for ( itpxl = 0 ; itpxl < ( ( imageDiff - > comps ) [ it_comp ] ) . w * ( ( imageDiff - > comps ) [ it_comp ] ) . h ; itpxl + + )
{
if ( abs ( ( ( imageBase - > comps ) [ it_comp ] ) . data [ itpxl ] - ( ( imageTest - > comps ) [ it_comp ] ) . data [ itpxl ] ) > 0 )
{
valueDiff = ( ( imageBase - > comps ) [ it_comp ] ) . data [ itpxl ] - ( ( imageTest - > comps ) [ it_comp ] ) . data [ itpxl ] ;
( ( imageDiff - > comps ) [ it_comp ] ) . data [ itpxl ] = abs ( valueDiff ) ;
2014-02-28 15:31:01 +01:00
sumDiff + = valueDiff ;
2011-07-21 17:23:31 +02:00
nbPixelDiff + + ;
2014-02-28 15:31:01 +01:00
SE + = ( double ) valueDiff * valueDiff ;
2011-07-21 17:23:31 +02:00
PEAK = ( PEAK > abs ( valueDiff ) ) ? PEAK : abs ( valueDiff ) ;
}
else
( ( imageDiff - > comps ) [ it_comp ] ) . data [ itpxl ] = 0 ;
2012-03-02 16:07:07 +01:00
} /* h*w loop */
2011-07-21 17:23:31 +02:00
MSE = SE / ( ( ( imageDiff - > comps ) [ it_comp ] ) . w * ( ( imageDiff - > comps ) [ it_comp ] ) . h ) ;
if ( ! inParam . nr_flag & & ( inParam . tabMSEvalues ! = NULL ) & & ( inParam . tabPEAKvalues ! = NULL ) )
2012-03-02 16:07:07 +01:00
{ /* Conformance test*/
2011-07-21 17:23:31 +02:00
printf ( " <DartMeasurement name= \" PEAK_%d \" type= \" numeric/double \" > %f </DartMeasurement> \n " , it_comp , PEAK ) ;
printf ( " <DartMeasurement name= \" MSE_%d \" type= \" numeric/double \" > %f </DartMeasurement> \n " , it_comp , MSE ) ;
if ( ( MSE > inParam . tabMSEvalues [ it_comp ] ) | | ( PEAK > inParam . tabPEAKvalues [ it_comp ] ) )
{
printf ( " ERROR: MSE (%f) or PEAK (%f) values produced by the decoded file are greater "
2014-02-28 15:17:30 +01:00
" than the allowable error (respectively %f and %f) \n " ,
MSE , PEAK , inParam . tabMSEvalues [ it_comp ] , inParam . tabPEAKvalues [ it_comp ] ) ;
goto cleanup ;
2011-07-21 17:23:31 +02:00
}
}
2012-03-02 16:07:07 +01:00
else /* Non regression-test */
2011-07-21 17:23:31 +02:00
{
if ( nbPixelDiff > 0 )
{
char it_compc [ 255 ] ;
2014-02-28 15:17:30 +01:00
it_compc [ 0 ] = 0 ;
2011-07-21 17:23:31 +02:00
printf ( " <DartMeasurement name= \" NumberOfPixelsWithDifferences_%d \" type= \" numeric/int \" > %d </DartMeasurement> \n " , it_comp , nbPixelDiff ) ;
printf ( " <DartMeasurement name= \" ComponentError_%d \" type= \" numeric/double \" > %f </DartMeasurement> \n " , it_comp , sumDiff ) ;
2016-04-30 17:58:04 +02:00
printf ( " <DartMeasurement name= \" PEAK_%d \" type= \" numeric/double \" > %f </DartMeasurement> \n " , it_comp , PEAK ) ;
printf ( " <DartMeasurement name= \" MSE_%d \" type= \" numeric/double \" > %f </DartMeasurement> \n " , it_comp , MSE ) ;
2011-07-21 17:23:31 +02:00
2013-03-03 18:55:35 +01:00
# ifdef OPJ_HAVE_LIBPNG
2014-02-28 15:17:30 +01:00
{
char * filenamePNGbase_it_comp , * filenamePNGtest_it_comp , * filenamePNGdiff_it_comp ;
2014-03-12 12:32:44 +01:00
filenamePNGbase_it_comp = ( char * ) malloc ( memsizebasefilename ) ;
2014-02-28 15:23:30 +01:00
strcpy ( filenamePNGbase_it_comp , filenamePNGbase ) ;
2014-02-28 15:17:30 +01:00
2014-03-12 12:32:44 +01:00
filenamePNGtest_it_comp = ( char * ) malloc ( memsizetestfilename ) ;
2014-02-28 15:23:30 +01:00
strcpy ( filenamePNGtest_it_comp , filenamePNGtest ) ;
2014-02-28 15:17:30 +01:00
filenamePNGdiff_it_comp = ( char * ) malloc ( memsizedifffilename ) ;
2014-02-28 15:23:30 +01:00
strcpy ( filenamePNGdiff_it_comp , filenamePNGdiff ) ;
2014-02-28 15:17:30 +01:00
sprintf ( it_compc , " _%i " , it_comp ) ;
strcat ( it_compc , " .png " ) ;
strcat ( filenamePNGbase_it_comp , it_compc ) ;
/*printf("filenamePNGbase_it = %s [%d / %d octets]\n",filenamePNGbase_it_comp, strlen(filenamePNGbase_it_comp),memsizebasefilename );*/
strcat ( filenamePNGtest_it_comp , it_compc ) ;
/*printf("filenamePNGtest_it = %s [%d / %d octets]\n",filenamePNGtest_it_comp, strlen(filenamePNGtest_it_comp),memsizetestfilename );*/
strcat ( filenamePNGdiff_it_comp , it_compc ) ;
/*printf("filenamePNGdiff_it = %s [%d / %d octets]\n",filenamePNGdiff_it_comp, strlen(filenamePNGdiff_it_comp),memsizedifffilename );*/
/*
if ( imageToPNG ( imageBase , filenamePNGbase_it_comp , it_comp ) = = EXIT_SUCCESS )
2011-07-21 17:23:31 +02:00
{
printf ( " <DartMeasurementFile name= \" BaselineImage_%d \" type= \" image/png \" > %s </DartMeasurementFile> \n " , it_comp , filenamePNGbase_it_comp ) ;
}
2014-02-28 15:17:30 +01:00
if ( imageToPNG ( imageTest , filenamePNGtest_it_comp , it_comp ) = = EXIT_SUCCESS )
2011-07-21 17:23:31 +02:00
{
printf ( " <DartMeasurementFile name= \" TestImage_%d \" type= \" image/png \" > %s </DartMeasurementFile> \n " , it_comp , filenamePNGtest_it_comp ) ;
}
2014-02-28 15:17:30 +01:00
if ( imageToPNG ( imageDiff , filenamePNGdiff_it_comp , it_comp ) = = EXIT_SUCCESS )
2011-07-21 17:23:31 +02:00
{
printf ( " <DartMeasurementFile name= \" DiffferenceImage_%d \" type= \" image/png \" > %s </DartMeasurementFile> \n " , it_comp , filenamePNGdiff_it_comp ) ;
}
2014-02-28 15:17:30 +01:00
*/
2014-01-23 17:33:13 +01:00
2014-02-28 15:17:30 +01:00
free ( filenamePNGbase_it_comp ) ;
free ( filenamePNGtest_it_comp ) ;
free ( filenamePNGdiff_it_comp ) ;
}
2011-07-21 17:23:31 +02:00
# endif
2014-02-28 15:17:30 +01:00
goto cleanup ;
2011-07-21 17:23:31 +02:00
}
}
2012-03-02 16:07:07 +01:00
} /* it_comp loop */
2011-07-21 17:23:31 +02:00
2014-02-28 15:17:30 +01:00
printf ( " ---- TEST SUCCEED ---- \n " ) ;
2014-02-28 15:31:01 +01:00
failed = 0 ;
2014-02-28 15:17:30 +01:00
cleanup :
2012-03-02 16:07:07 +01:00
/*-----------------------------*/
2014-02-28 15:17:30 +01:00
free ( param_image_diff ) ;
2012-03-02 16:07:07 +01:00
/* Free memory */
2011-07-21 17:23:31 +02:00
opj_image_destroy ( imageBase ) ;
opj_image_destroy ( imageTest ) ;
opj_image_destroy ( imageDiff ) ;
free ( filenamePNGbase ) ;
free ( filenamePNGtest ) ;
free ( filenamePNGdiff ) ;
free ( inParam . tabMSEvalues ) ;
free ( inParam . tabPEAKvalues ) ;
free ( inParam . base_filename ) ;
free ( inParam . test_filename ) ;
2014-02-28 15:17:30 +01:00
return failed ? EXIT_FAILURE : EXIT_SUCCESS ;
2011-07-21 17:23:31 +02:00
}