Move the DIS benchmarks up a directory and update hardcoded paths

Note that this repo does not attempt to keep a copy of the original
DIS benchmark distributions. UNC real-time has another repo for that.

3 files changed, 656 insertions, 0 deletions

diff --git a/dis/Neighborhood/DISstressmarkRNG.h b/dis/Neighborhood/DISstressmarkRNG.h
new file mode 100644
index 0000000..4aa2620
--- /dev/null
+++ b/dis/Neighborhood/DISstressmarkRNG.h
@@ -0,0 +1,190 @@
+#include <math.h>
+
+#define IA 16807
+#define IM 2147483647
+#define AM (1.0/IM)
+#define IQ 127773
+#define IR 2836
+#define NTAB 32
+#define NDIV (1+(IM-1)/NTAB)
+#define EPS 1.2e-7
+#define RNMX (1.0-EPS)
+
+static long iy=0;
+static long iv[NTAB];
+static long iseed;
+
+int ABS(int x){
+  if (x>= 0) return x;
+  else
+    return (-x);
+}
+
+int sign(int x){
+  if (x >= 0) return 1;
+  else
+    return (-1);
+}
+
+int MAX(int x, int y){
+  if (x>= y) return x;
+  else
+    return y;
+}
+
+int MIN(int x, int y){
+  if (x<= y) return x;
+  else
+    return y;
+}
+
+void randInit(long idum)
+{
+  long j;
+  long k;
+
+  assert (idum <= 0);
+  assert (iy == 0);
+
+  iseed = idum;
+  if (-(iseed)<1){
+    iseed = 1;
+  }
+  else {
+    iseed = -(iseed);
+  }
+  for (j=NTAB+7; j>=0; j--){
+    k = (iseed)/IQ;
+    iseed = IA*(iseed-k*IQ)-IR*k;
+    if (iseed < 0){
+      iseed += IM;
+    }
+    if (j < NTAB){
+      iv[j] = iseed;
+    }
+  }
+  iy = iv[0];
+}
+
+float randNum()
+{
+  long j;
+  long k;
+  float temp;
+
+  assert (iy != 0);
+  
+  k = (iseed)/IQ;
+  iseed = IA*(iseed-k*IQ)-IR*k;
+
+  if (iseed < 0){
+    iseed += IM;
+  }
+  j = iy/NDIV; 
+  iy = iv[j];
+  iv[j] = iseed;
+
+  temp = AM * iy;
+
+  if (temp > RNMX){
+    return RNMX;
+  }
+  else {
+    return temp;
+  }
+}
+
+
+float randomFloat(float lowest_float, float highest_float)
+{
+ float value;
+ float range;
+
+assert (lowest_float < highest_float);
+
+range = highest_float - lowest_float;
+value = randNum()*(highest_float - lowest_float) + lowest_float;
+assert(value >= lowest_float);
+assert(value <= highest_float);
+
+return value;
+
+}
+
+float randomNonZeroFloat(float lowest_float, float highest_float, float epsilon)
+{
+
+  double range;
+  float value;
+
+
+  assert (lowest_float < 0);
+  assert (highest_float > 0);
+  assert (epsilon > 0);
+  assert ((epsilon < -lowest_float) && (epsilon < highest_float));
+  
+  range = highest_float - lowest_float;
+  value = (randNum() * range)+lowest_float;
+  
+  if (ABS(value) < epsilon) 
+    {
+      if (value > 0) value = value + epsilon;
+      else if (value < 0) value = value - epsilon;
+      
+    }
+
+  assert (value >= lowest_float);
+  assert (value <= highest_float);
+
+  return value;
+}
+
+unsigned int randomUInt(int lowest_uint, int highest_uint)
+{
+  float range;
+  unsigned int value;
+  float temp;
+
+  range =(float)(highest_uint - lowest_uint + 1);
+  temp = randNum();
+  value =(unsigned int)( floor(temp * range) + lowest_uint); 
+
+  assert (value >= lowest_uint);
+  assert (value <= highest_uint);
+
+  return value;
+}
+
+unsigned int randomNonZeroUInt(int lowest_uint, int highest_uint)
+{
+  float range;
+  unsigned int value;
+  float temp;
+
+  range =(float)(highest_uint - lowest_uint + 1);
+  value = 0;
+  while(value == 0){
+  temp = randNum();
+
+  value =(unsigned int)( floor(temp * range) + lowest_uint); 
+  }
+  
+  assert (value >= lowest_uint);
+  assert (value <= highest_uint);
+
+  return value;
+}
+
+int randInt(int lowest_uint,  int highest_uint)
+{
+  float range;
+  int value;
+  
+  range = highest_uint - lowest_uint + 1;
+  value = (int)(floor(randNum() * range) + lowest_uint);
+  
+  assert (value >= lowest_uint);
+  assert (value <= highest_uint);
+
+  return value;
+}                            
diff --git a/dis/Neighborhood/neighborhood.c b/dis/Neighborhood/neighborhood.c
new file mode 100644
index 0000000..1736d38
--- /dev/null
+++ b/dis/Neighborhood/neighborhood.c
@@ -0,0 +1,103 @@
+/*
+ *  Sample code for the DIS Neighborhood 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 <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include<assert.h>
+#include "DISstressmarkRNG.h"
+#include "utili.h"
+#include "extra.h"
+
+/* 
+ * main()
+ */
+int main(int argc, char** argv)
+{
+  long int seed;
+  int dimension;
+  int numberLines;
+  int minThickness;
+  int maxThickness;
+  int distanceShort;
+  int distanceLong;
+  int bitDepth;
+  int maxPixel;
+  Pixel *image;
+  Neighborhood values;
+
+  time_t beginTime;
+  time_t endTime;
+  SET_UP
+
+  assert(fscanf(stdin, "%ld %d %d %d %d %d %d %d", 
+        &seed, &bitDepth, &dimension, &numberLines,
+        &minThickness, &maxThickness,
+        &distanceShort, &distanceLong) == 8);
+
+  assert((seed >= MIN_SEED) && (seed <= MAX_SEED));
+  assert((dimension > 0) && (dimension <= MAX_DIMENSION));
+  assert((numberLines > 0) && (numberLines <= MAX_NUMBER_LINES));
+  assert((minThickness > 0) && (minThickness < dimension));
+  assert((maxThickness >= minThickness) && (maxThickness < dimension));
+  assert((distanceShort > 0) && (distanceShort < dimension));
+  assert((distanceLong > 0) && (distanceLong < dimension));
+  assert((bitDepth >= MIN_BIT_DEPTH) && (bitDepth <= MAX_BIT_DEPTH));
+
+  randInit(seed);
+  maxPixel = (1 << bitDepth) - 1;
+  image = createImage(dimension, maxPixel, numberLines,
+                      minThickness, maxThickness);
+  assert (image != NULL);
+
+  beginTime = time(NULL);
+  START_LOOP
+  neighborhoodCalculation(image, dimension,
+                          distanceShort, distanceLong, &values, maxPixel);
+  STOP_LOOP
+  endTime = time(NULL);
+  WRITE_TO_FILE
+
+//  printf(" end time is %d\n", endTime);
+
+  fprintf(stdout, "%9.4e %9.4e %9.4e %9.4e %9.4e %9.4e %9.4e %9.4e", 
+          values.distShort.deg0.entropy,
+          values.distShort.deg0.energy,
+          values.distShort.deg45.entropy,
+          values.distShort.deg45.energy,
+          values.distShort.deg90.entropy,
+          values.distShort.deg90.energy,
+          values.distShort.deg135.entropy,
+          values.distShort.deg135.energy);
+
+  fprintf(stdout,"%9.4e %9.4e %9.4e %9.4e %9.4e %9.4e %9.4e %9.4e",
+          values.distLong.deg0.entropy,
+          values.distLong.deg0.energy,values.distShort.deg45.entropy,
+          values.distLong.deg45.energy,
+          values.distLong.deg90.entropy,
+          values.distLong.deg90.energy,
+          values.distLong.deg135.entropy,
+          values.distLong.deg135.energy);
+
+  fprintf(stderr, "time for neghborhood stressmark = %f\n",
+          difftime(endTime, beginTime));
+          
+  free((Pixel *)image);
+  return (SUCCESS);
+  }
+
+
+
+   
diff --git a/dis/Neighborhood/utili.h b/dis/Neighborhood/utili.h
new file mode 100644
index 0000000..2a8e2a0
--- /dev/null
+++ b/dis/Neighborhood/utili.h
@@ -0,0 +1,363 @@
+/*
+ *  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;*/
+
+
+void drawLineSegment(Pixel *image,
+                     Coord startPoint,
+                     Coord endPoint,
+                     int startValue,
+                     int endValue,
+                     int thickness,
+                     int dimension)
+  {
+    int changeColumn, changeRow;
+    int delta;
+    int column, row;
+    float value, valueDelta;
+    int t;
+
+    changeColumn = endPoint.column - startPoint.column;
+    changeRow = endPoint.row - startPoint.row;
+    
+    assert((changeRow != 0) || (changeColumn != 0));
+
+    column = startPoint.column;
+    row = startPoint.row;
+    value = startValue;
+
+    if (ABS(changeColumn) > ABS(changeRow)){
+      valueDelta = ((float) endValue - startValue)/
+                    ((float) ABS(changeColumn));
+      delta = 2*ABS(row) - ABS(column);
+      for (column = startPoint.column;
+           column == endPoint.column+sign(changeColumn);
+           column += sign(changeColumn)){
+        for (t = MAX(0, row-thickness/2);
+             t < MIN(dimension, row+thickness - thickness/2);
+             t++)
+          image[t*dimension + column] = (int)value;
+        value += valueDelta;
+        if (delta >= 0){
+          row += sign(changeRow);
+          delta -= 2*ABS(changeColumn);
+        }
+        column += sign(changeColumn);
+        delta += 2*ABS(changeRow);
+      }
+    }
+    else {
+      valueDelta = ((float) endValue - startValue)/
+                   ((float) ABS(changeRow));
+      delta = 2* ABS(column) - ABS(row);
+      for (row = startPoint.row;
+           row == endPoint.row + sign(changeRow);
+           row += sign(changeRow)){
+        for (t = MAX(0, column-thickness/2);
+             t < MIN(dimension, row + thickness - thickness/2);
+             t++)
+          image[row*dimension + t] = (int)value;
+        if (delta >= 0){
+          column += sign(changeColumn);
+            delta -= 2*ABS(changeRow);
+        }
+        row += sign(changeRow);
+        delta += 2*ABS(changeColumn);
+      }
+    }
+    return;
+  }
+
+
+
+Pixel *createImage (int dimension,
+                    Pixel maxPixel,
+                    int numberLines,
+                    int minThickness,
+                    int maxThickness)
+  {
+    Pixel *image;
+    int i;
+    
+    Coord startPoint;
+    Coord endPoint;
+    int thickness;
+    int startValue;
+    int endValue;
+
+    image = (Pixel *)malloc(sizeof(Pixel) * dimension * dimension);
+    assert (image != NULL);
+    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;
+
+      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(image, startPoint, endPoint,
+                      startValue, endValue, thickness, dimension);
+    }
+    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);
+    
+    printf(" before short calc deg0\n"); 
+    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;
+  }
+