/*
 *  Sample code for the DIS Pointer Stressmark
 *
 * This source code is the completely correct source code based on 
 * the example codes provided by Atlantic Aerospace Division, Titan 
 * Systems Corporation, 2000.
 * 
 * If you just compile and generate the executables from this source 
 * code, this code would be enough. However, if you wish to get a complete 
 * understanding of this stressmark, it is strongly suggested that you
 * read the Benchmark Analysis and Specifications Document Version 1.0
 * before going on since the detailed comments are given in this documents.
 * the comments are not repeated here.
 */

#include <math.h>

#define TRUE 1
#define FALSE !TRUE
#define SUCCESS TRUE
#define ERROR FLASE

#define MIN_PIXEL 0
#define MAX_DIMENSION 32768
#define MIN_SEED  -2147483647
#define MAX_SEED  -1
#define MAX_NUMBER_LINES 65536
#define MIN_BIT_DEPTH    7
#define MAX_BIT_DEPTH    15

typedef struct {
  int column;
  int row;
}Coord;

/* 
 * Neighborhood structure consists of the GLCM descriptors entropy and
 * energy for each of 2 distance and 4 angels 
 */
typedef struct {
  float entropy;
  float energy;
}Descriptors;

typedef struct {
  Descriptors deg0;
  Descriptors deg45;
  Descriptors deg90;
  Descriptors deg135;
}Angeles;

typedef struct {
  Angeles distShort;
  Angeles distLong;
}Neighborhood;

typedef short int Pixel; /* short int;*/

typedef struct {
  int           numColumns;     /* number of columns in image */
  int           numRows;        /* number of rows in image */
  Pixel         maxImageValue;  /* max legal image value */
  Pixel         *data;          /* data pointer */
} Image;

// For correct implementation of drawLineSegment
#include "initializeImage.c"

Pixel *createImage (Pixel *image,
            int dimension,
		    Pixel maxPixel,
		    int numberLines,
		    int minThickness,
		    int maxThickness)
  {
    int i;
    
    Coord startPoint;
    Coord endPoint;
    int thickness;
    int startValue;
    int endValue;
    Image img;
    img.numColumns = dimension;
    img.numRows = dimension;
    img.maxImageValue = maxPixel;
    img.data = image;

    for (i=0; i<dimension*dimension; i++){
      image[i] = 0;
    }

    for (i=0; i<numberLines; i++){
      float temp;
      float prev;

      temp = randomUInt(0, dimension*dimension - 1);
      startPoint.row = (int) temp/dimension;
      startPoint.column = (int) temp % dimension;
      prev = temp;

      // Make sure that the end is different than the start
      while((temp = randomUInt(0, dimension*dimension -1)) == prev);

      endPoint.row = (int) temp/dimension;
      endPoint.column = (int) temp% dimension;

      thickness = randomUInt(minThickness, maxThickness);
      startValue = randomUInt(MIN_PIXEL, maxPixel);
      endValue = randomUInt(MIN_PIXEL, maxPixel);

      drawLineSegment(&startPoint, &endPoint,
		      startValue, endValue, thickness, &img);
    }
    return(image);
}


void calcEntropyEnergy(
		       int *sumHist,
		       int *diffHist,
		       Pixel *image,
		       int numBins,
		       int dx,
		       int dy,
		       float *entropy,
		       float *energy,
		       int dimension,
		        Pixel maxPixel)
  {
    int index;
    int totalNumPixels;
    int rowIndex;
    int rowLow, rowHigh;
    int columnIndex;
    int columnLow, columnHigh;
    int columnForPixelAtDistance;
    int rowForPixelAtDistance;
    int value0RowOffset;
    int value1RowOffset;

    *entropy = 0.0;
    *energy = 0.0;
    
    for (index = 0; index < numBins; index++){
      sumHist[index] = 0;
      diffHist[index] = 0;
    }
    
    if (dy < 0){
      rowLow = -dy;
      rowHigh = dimension;
    }
    else {
      rowLow = 0;
      rowHigh = dimension - dy;
    }
    if (dx < 0){
      columnLow = -dx;
      columnHigh = dimension;
    }
    else
    {
      columnLow = 0;
      columnHigh = dimension - dx;
    }

    totalNumPixels = 0;
    value0RowOffset = rowLow * dimension;
    value1RowOffset = (rowLow + dy) * dimension;

    for (rowIndex = rowLow; rowIndex<rowHigh; rowIndex++){
      for (columnIndex= columnLow; columnIndex<columnHigh;
           columnIndex++){
        int value0;
        int value1;
        int binIndex;

        rowForPixelAtDistance = rowIndex + dy;
        columnForPixelAtDistance = columnIndex + dx;

        value0 = *(image + value0RowOffset + columnIndex);
        value1 = *(image + value1RowOffset + 
               columnForPixelAtDistance);

        binIndex = value0 + value1 - 2*MIN_PIXEL;
        assert((binIndex >= 0) && (binIndex < numBins));
        sumHist[binIndex] += 1;
        binIndex = value0 - value1 + maxPixel - MIN_PIXEL;

        assert((binIndex >= 0) && (binIndex < numBins));

        diffHist[binIndex] += 1;
        totalNumPixels += 1;

      }
      
      value0RowOffset += dimension;
      value1RowOffset += dimension;

    }
    

    if (totalNumPixels > 0){
      int index;
      double energySum;
      double energyDifference;
      double entropyValue;
      double sumNormalized;
      double diffNormalized;
      double scale;

      energySum = (double) 0;
      energyDifference = (double) 0;
      entropyValue = (double) 0;
      scale = 1.e0/totalNumPixels;
      for (index = 0; index<numBins; index++){
        if (sumHist[index] > 0){
          sumNormalized = (double) sumHist[index]*scale;
          entropyValue = entropyValue - sumNormalized * 
            log((double)sumNormalized);
          energySum = energySum + sumNormalized * sumNormalized ;
        }
        if (diffHist[index] > 0){
          diffNormalized = (double)diffHist[index]*scale;
          entropyValue = entropyValue - diffNormalized * log(diffNormalized);
          energyDifference = energyDifference +
            diffNormalized * diffNormalized;
        }
      }
      *energy = energySum * energyDifference;
      *entropy = entropyValue;
    }
    return;
}


void neighborhoodCalculation
  (Pixel *image,
   int dimension,
   int distanceShort,
   int distanceLong,
   Neighborhood *neighborhood,
   Pixel maxPixel)
  {
    int *sumHist, *diffHist;
    int numBins;

    numBins = (2 * (maxPixel - MIN_PIXEL + 1) -1);
    sumHist = (int *) malloc(numBins * sizeof(int));
    assert (sumHist != NULL);
    diffHist = (int *)malloc(numBins * sizeof(int));
    assert(diffHist != NULL);
    
    calcEntropyEnergy(sumHist, diffHist, image, numBins,
		      distanceShort, 0,
		      &(neighborhood->distShort.deg0.entropy),
		      &(neighborhood->distShort.deg0.energy), dimension,
		      maxPixel);
  
    calcEntropyEnergy(sumHist, diffHist, image, numBins,
		      distanceShort, distanceShort,
		      &(neighborhood->distShort.deg45.entropy),
		      &(neighborhood->distShort.deg45.energy), dimension,
		      maxPixel);
   
    calcEntropyEnergy(sumHist, diffHist, image, numBins,
		      0, distanceShort,
		      &(neighborhood->distShort.deg90.entropy),
		      &(neighborhood->distShort.deg90.energy), dimension,
		      maxPixel);
   
    calcEntropyEnergy(sumHist, diffHist, image, numBins,
		      -distanceShort, distanceShort,
		      &(neighborhood->distShort.deg135.entropy),
		      &(neighborhood->distShort.deg135.energy), dimension,
		      maxPixel);

    calcEntropyEnergy(sumHist, diffHist, image, numBins,
		      distanceLong, 0,
		      &(neighborhood->distLong.deg0.entropy),
		      &(neighborhood->distLong.deg0.energy), dimension,
		      maxPixel);
  
    calcEntropyEnergy(sumHist, diffHist, image, numBins,
		      distanceLong, distanceLong,
		      &(neighborhood->distLong.deg45.entropy),
		      &(neighborhood->distLong.deg45.energy), dimension,
		      maxPixel);
      
    calcEntropyEnergy(sumHist, diffHist, image, numBins,
		      0, distanceLong,
		      &(neighborhood->distLong.deg90.entropy),
		      &(neighborhood->distLong.deg90.energy), dimension,
		      maxPixel);

    calcEntropyEnergy(sumHist, diffHist, image, numBins,
		      -distanceLong, distanceLong,
		      &(neighborhood->distLong.deg135.entropy),
		      &(neighborhood->distLong.deg135.energy), dimension,
		      maxPixel);

    free(sumHist);
    free(diffHist);
    
    return;
  }