/*---------------------------------------------------------------------------*/
/* Program:  avediff.c                                                       */
/*                                                                           */
/* Purpose:  This program calculates the average difference between two      */
/*           images in KUIM format.  Both absolute and squared differences   */
/*           are calculated and printed.                                     */
/*                                                                           */
/* Author:   John Gauch, Edu Metz                                            */
/*                                                                           */
/* Date:     October 11, 1994 - Original program.                            */
/*           July    23, 1996 - Color support added.                         */
/*                                                                           */
/* Note:     Copyright (C) The University of Kansas, 1994-1996               */
/*---------------------------------------------------------------------------*/
#include <IM.h>

/* Image variables */
char Name1[50];
char Name2[50];
IM_TYPE *Image1;
IM_TYPE *Image2;
int PixType, Xdim, Ydim, Zdim, DimCnt;


/*---------------------------------------------------------------------------*/
/* Purpose:  Calculate the average difference between two grey images.       */
/*---------------------------------------------------------------------------*/
void GreyAvediff()
{
   FLOAT_TYPE *Data1;
   FLOAT_TYPE *Data2;
   int Count, i;
   double Diff, Total, Total2;

   /* Read input image1 */
   Data1 = (FLOAT_TYPE *) im_alloc1D(Image1, FLOAT);
   im_read(Image1, FLOAT, (char *) Data1);

   /* Read input image2 */
   Image2 = im_open(Name2, &PixType, &Xdim, &Ydim, &Zdim, &DimCnt);
   Data2 = (FLOAT_TYPE *) im_alloc1D(Image2, FLOAT);
   im_read(Image2, FLOAT, (char *) Data2);

   Total = 0.0;
   Total2 = 0.0;
   Count = Xdim * Ydim * Zdim;

   /* Calculate average differences */
   for (i = 0; i < Count; i++)
   {

      Diff = (double) (Data1[i] - Data2[i]);

      if (Diff < 0)
	 Diff = -Diff;

      Total += Diff;
      Total2 += Diff * Diff;
   }

   /* Output results */
   printf("Average absolute difference = %lf\n", Total / Count);
   printf("Average squared difference  = %lf\n", Total2 / Count);

   /* Free memory */
   im_free1D((char *) Data1);
   im_free1D((char *) Data2);
}


/*---------------------------------------------------------------------------*/
/* Purpose:  Calculate the average difference between two color images.      */
/*---------------------------------------------------------------------------*/
void ColorAvediff()
{
   COLOR_TYPE **Data1;
   COLOR_TYPE **Data2;
   double RedDiff, GreenDiff, BlueDiff;
   double Total, TotalRed, TotalBlue, TotalGreen;
   double Total2, Total2Red, Total2Blue, Total2Green;
   int x, y;

   /* Read input image1 */
   Data1 = (COLOR_TYPE **) im_alloc2D(Image1, COLOR);
   im_read(Image1, COLOR, (char *) &(Data1[0][0]));

   /* Read input image2 */
   Image2 = im_open(Name2, &PixType, &Xdim, &Ydim, &Zdim, &DimCnt);
   Data2 = (COLOR_TYPE **) im_alloc2D(Image2, COLOR);
   im_read(Image2, COLOR, (char *) &(Data2[0][0]));

   TotalRed = TotalBlue = TotalGreen = 0.0;
   Total2Red = Total2Blue = Total2Green = 0.0;

   /* Calculate average differences */
   for (y = 0; y < Ydim; y++)
      for (x = 0; x < Xdim; x++)
      {

	 RedDiff = (double) (Data1[y][x].r - Data2[y][x].r);
	 GreenDiff = (double) (Data1[y][x].g - Data2[y][x].g);
	 BlueDiff = (double) (Data1[y][x].b - Data2[y][x].b);

	 if (RedDiff < 0)
	    RedDiff = -RedDiff;
	 if (GreenDiff < 0)
	    GreenDiff = -GreenDiff;
	 if (BlueDiff < 0)
	    BlueDiff = -BlueDiff;

	 TotalRed += RedDiff;
	 TotalGreen += GreenDiff;
	 TotalBlue += BlueDiff;

	 Total2Red += RedDiff * RedDiff;
	 Total2Green += GreenDiff * GreenDiff;
	 Total2Blue += BlueDiff * BlueDiff;
      }

   Total = TotalRed + TotalGreen + TotalBlue;
   Total2 = Total2Red + Total2Green + Total2Blue;

   /* Output results */
   printf("Average absolute difference red   = %lf\n",
	  TotalRed / (Xdim * Ydim));
   printf("Average absolute difference green = %lf\n",
	  TotalGreen / (Xdim * Ydim));
   printf("Average absolute difference blue  = %lf\n",
	  TotalBlue / (Xdim * Ydim));
   printf("                                  --------------\n");
   printf("                            Total:  %lf\n\n",
	  Total / (Xdim * Ydim));

   printf("Average squared difference red    = %lf\n",
	  Total2Red / (Xdim * Ydim));
   printf("Average squared difference green  = %lf\n",
	  Total2Green / (Xdim * Ydim));
   printf("Average squared difference blue   = %lf\n",
	  Total2Blue / (Xdim * Ydim));
   printf("                                  --------------\n");
   printf("                            Total:  %lf\n",
	  Total2 / (Xdim * Ydim));

   /* Free memory */
   im_free2D((char **) Data1);
   im_free2D((char **) Data2);
}


/*---------------------------------------------------------------------------*/
/* Purpose:  This is the main program.                                       */
/*---------------------------------------------------------------------------*/
void main(int argc, char *argv[])
{

/* Program variables */
   int Debug = FALSE;
   int i = 0;

   /* Interpret program options */
   printf("AVEDIFF Program - KUIM Version 2.0\n\n");
   while ((++i < argc) && (argv[i][0] == '-'))
      switch (argv[i][1])
      {
      case 'd':
	 Debug = TRUE;
	 break;
      default:
	 Error("Invalid option encountered");
	 break;
      }

   /* Check number of file names */
   if (argc - i != 2)
   {
      fprintf(stderr, "Usage: avediff [options] infile1 infile2\n");
      fprintf(stderr, "       [-d]    Print debugging information\n");
      exit(1);
   }

   /* Get image file names from argument list */
   if (sscanf(argv[i++], "%s", Name1) == 0)
      Error("Could not get input file name");
   if (sscanf(argv[i++], "%s", Name2) == 0)
      Error("Could not get input file name");

   /* Determine PixType */
   Image1 = im_open(Name1, &PixType, &Xdim, &Ydim, &Zdim, &DimCnt);

   /* Process input images */
   if (PixType == COLOR || PixType == PSEUDO || PixType == JPEG_RGB)
      ColorAvediff();
   else
      GreyAvediff();

   exit(0);
}