Save raw difference data plus absolute values.

src/main/java/compression/benchmark/ScalarQuantizationBenchmark.java

@@ -57,16 +57,26 @@ public class ScalarQuantizationBenchmark {
         return true;
     }
 
-    private boolean saveDifference(final short[] originalData, final short[] transformedData, final String filename) {
-        final int[] differenceData = Utils.getAbsoluteDifference(originalData, transformedData);
-        final String path = getFileNamePath(filename);
+    private boolean saveDifference(final short[] originalData,
+                                   final short[] transformedData,
+                                   final String diffFile,
+                                   final String absDiffFile) {
+
+        final int[] differenceData = Utils.getDifference(originalData, transformedData);
+        final int[] absDifferenceData = Utils.applyAbsToValues(differenceData);
+        final String diffFilePath = getFileNamePath(diffFile);
+        final String absDiffFilePath = getFileNamePath(absDiffFile);
+
         ImageU16 img = new ImageU16(rawImageDims.getX(),
                                     rawImageDims.getY(),
-                                    TypeConverter.intArrayToShortArray(differenceData));
+                                    TypeConverter.intArrayToShortArray(absDifferenceData));
         try {
             // NOTE(Moravec): Use little endian so that gnuplot can read the array.
-            RawDataIO.writeImageU16(path, img, true);
-            System.out.println("Saved difference to: " + path);
+            RawDataIO.writeImageU16(absDiffFilePath, img, true);
+            System.out.println("Saved absolute difference to: " + absDiffFilePath);
+
+            RawDataIO.writeDataI32(diffFilePath, differenceData, true);
+            System.out.println("Saved difference to: " + absDiffFilePath);
         } catch (Exception e) {
             e.printStackTrace();
             System.err.println("Failed to save difference.");
@@ -118,10 +128,8 @@ public class ScalarQuantizationBenchmark {
 
                 final String quantizedFile = String.format("p%d_cb%d%s.raw", planeIndex, codebookSize, method);
 
-                final String absoluteDiffFile = String.format("p%d_cb%d%s_diff.raw",
-                                                              planeIndex,
-                                                              codebookSize,
-                                                              method);
+                final String diffFile = String.format("p%d_cb%d%s_diff.raw", planeIndex, codebookSize, method);
+                final String absoluteDiffFile = String.format("p%d_cb%d%s_adiff.raw", planeIndex, codebookSize, method);
 
                 final short[] quantizedData = quantizer.quantize(planeData);
 
@@ -130,7 +138,7 @@ public class ScalarQuantizationBenchmark {
                     return;
                 }
 
-                saveDifference(planeData, quantizedData, absoluteDiffFile);
+                saveDifference(planeData, quantizedData, diffFile, absoluteDiffFile);
             }
         }
     }

src/main/java/compression/quantization/vector/LBGVectorQuantizer.java

@@ -10,15 +10,11 @@ import java.util.stream.Stream;
 
 public class LBGVectorQuantizer {
     private final double EPSILON = 0.005;
-    private final double PERTURBATION_FACTOR_MIN = 0.10;
-    private final double PERTURBATION_FACTOR_MAX = 0.60;
     private final int vectorSize;
     private final int codebookSize;
     private final int[][] trainingVectors;
     private final VectorDistanceMetric metric = VectorDistanceMetric.Euclidean;
 
-    private Random random = new Random();
-
     public LBGVectorQuantizer(final int[][] trainingVectors, final int codebookSize) {
 
         assert (trainingVectors.length > 0) : "No training vectors provided";
@@ -57,11 +53,12 @@ public class LBGVectorQuantizer {
 
         for (int vecIndex = 0; vecIndex < quantizedVectors.length; vecIndex++) {
             for (int vecValIndex = 0; vecValIndex < vectorSize; vecValIndex++) {
-                mse += Math.pow(((double) trainingVectors[vecIndex][vecValIndex] - (double) quantizedVectors[vecIndex][vecValIndex]), 2);
+                mse += Math.pow(((double) trainingVectors[vecIndex][vecValIndex] - (double) quantizedVectors[vecIndex][vecValIndex]),
+                                2);
             }
         }
-        mse /= (double) (trainingVectors.length * vectorSize);
-        return mse;
+        final double avgMse = mse / (double) (trainingVectors.length * vectorSize);
+        return avgMse;
     }
 
     private double[] getPerturbationVector(final Stream<int[]> vectors) {
@@ -71,7 +68,6 @@ public class LBGVectorQuantizer {
         // We have to initialize min to Max values.
         int[] min = new int[vectorSize];
         Arrays.fill(min, U16.Max);
-        boolean executed = false;
 
         vectors.forEach(v -> {
             for (int i = 0; i < vectorSize; i++) {
@@ -126,14 +122,7 @@ public class LBGVectorQuantizer {
                     assert (trainingVectors.length > 0) :
                             "There are no vectors from which to create perturbation " + "vector";
                     prtV = getPerturbationVector(Arrays.stream(trainingVectors));
-                }
-                //                else if (entryToSplit.getTrainingVectors().size() == 1) {
-                //                    prtV = new double[vectorSize];
-                //                    for (int i = 0; i < vectorSize; i++) {
-                //                        prtV[i] = (double) (entryToSplit.getVector()[i] * 0.5);
-                //                    }
-                //                }
-                else {
+                } else {
                     assert (entryToSplit.getTrainingVectors().size() > 0) : "There are no vectors from which to " +
                             "create perturbation vector";
 
@@ -156,9 +145,6 @@ public class LBGVectorQuantizer {
                     continue;
                 }
 
-                // NOTE(Moravec):   Maybe we just create one new entry and bring the "original" one to the next
-                //                  iteration as stated in Sayood's book (p. 302)
-
                 int[] left = new int[prtV.length];
                 int[] right = new int[prtV.length];
                 for (int i = 0; i < prtV.length; i++) {
@@ -185,9 +171,13 @@ public class LBGVectorQuantizer {
             assert (codebook.size() == (k * 2));
             System.out.println(String.format("Split from %d -> %d", k, k * 2));
             k *= 2;
+
             // Execute LBG Algorithm on current codebook to improve it.
             System.out.println("Improving current codebook...");
             LBG(codebook);
+
+            // TODO(Moravec):   The MSE metric is super broken. We are getting really bad values, even though
+            //                  we are getting quite good results.
             final double avgMse = averageMse(codebook);
             System.out.println(String.format("Average MSE: %.4f", avgMse));
         }
@@ -225,9 +215,12 @@ public class LBGVectorQuantizer {
                         closestEntry = entry;
                     }
                 }
-                assert (closestEntry != null) : "Did not found closest entry.";
+
                 if (closestEntry != null) {
                     closestEntry.addTrainingVector(trainingVec, minDist);
+                } else {
+                    assert (false) : "Did not found closest entry.";
+                    System.err.println("Did not found closest entry.");
                 }
             }
 
@@ -261,8 +254,6 @@ public class LBGVectorQuantizer {
 
 
     private void fixEmptyEntries(final ArrayList<LearningCodebookEntry> codebook) {
-        final int originalSize = codebook.size();
-
         LearningCodebookEntry emptyEntry = null;
         for (final LearningCodebookEntry potentiallyEmptyEntry : codebook) {
             if (potentiallyEmptyEntry.getTrainingVectors().size() < 2) { // < 2

src/main/java/compression/utilities/Utils.java

@@ -58,24 +58,22 @@ public class Utils {
     }
 
 
-    public static int[] getAbsoluteDifference(final short[] original, final short[] transformed) {
+    public static int[] getDifference(final short[] original, final short[] transformed) {
         assert (original.length == transformed.length) : "Array lengths doesn't match";
 
         int[] difference = new int[original.length];
         for (int i = 0; i < original.length; i++) {
-            difference[i] = Math.abs( TypeConverter.shortToInt(original[i]) - TypeConverter.shortToInt(transformed[i]));
+            difference[i] = (TypeConverter.shortToInt(original[i]) - TypeConverter.shortToInt(transformed[i]));
         }
         return difference;
     }
 
-    public static int[] getSquaredDifference(final short[] original, final short[] transformed) {
-        assert (original.length == transformed.length) : "Array lengths doesn't match";
-
-        int[] difference = new int[original.length];
-        for (int i = 0; i < original.length; i++) {
-            difference[i] = (int) Math.pow((TypeConverter.shortToInt(original[i]) - TypeConverter.shortToInt(transformed[i])), 2);
+    public static int[] applyAbsToValues(int[] values) {
+        int[] absValues = new int[values.length];
+        for (int i = 0; i < values.length; i++) {
+            absValues[i] = Math.abs(values[i]);
         }
-        return difference;
+        return absValues;
     }