Measure input dataset plane entropies in custom function.

src/main/java/azgracompress/DataCompressor.java

@@ -4,7 +4,7 @@ import azgracompress.benchmark.CompressionBenchmark;
 import azgracompress.cli.CliConstants;
 import azgracompress.cli.CustomFunctionBase;
 import azgracompress.cli.ParsedCliOptions;
-import azgracompress.cli.functions.MeasurePlaneErrorFunction;
+import azgracompress.cli.functions.EntropyCalculation;
 import azgracompress.compression.ImageCompressor;
 import azgracompress.compression.ImageDecompressor;
 import org.apache.commons.cli.*;
@@ -69,7 +69,8 @@ public class DataCompressor {
             case CustomFunction: {
                 // NOTE(Moravec): Custom function class here |
                 //                                           V
-                CustomFunctionBase customFunction = new MeasurePlaneErrorFunction(parsedCliOptions);
+                //CustomFunctionBase customFunction = new MeasurePlaneErrorFunction(parsedCliOptions);
+                CustomFunctionBase customFunction = new EntropyCalculation(parsedCliOptions);
                 if (!customFunction.run()) {
                     System.err.println("Errors occurred during custom function.");
                 }

src/main/java/azgracompress/cli/functions/EntropyCalculation.java

+package azgracompress.cli.functions;
+
+import azgracompress.cli.CustomFunctionBase;
+import azgracompress.cli.ParsedCliOptions;
+import azgracompress.data.ImageU16;
+import azgracompress.io.RawDataIO;
+import azgracompress.utilities.Utils;
+
+import java.io.IOException;
+
+public class EntropyCalculation extends CustomFunctionBase {
+    /**
+     * Base constructor with parsed CLI options.
+     *
+     * @param options Parsed cli options.
+     */
+    public EntropyCalculation(ParsedCliOptions options) {
+        super(options);
+    }
+
+    @Override
+    public boolean run() {
+        ImageU16 plane = null;
+        System.out.println(String.format("Input file: %s", options.getInputFile()));
+
+        for (int planeIndex = 0; planeIndex < options.getImageDimension().getZ(); planeIndex++) {
+            try {
+                plane = RawDataIO.loadImageU16(options.getInputFile(),
+                                               options.getImageDimension(),
+                                               planeIndex);
+            } catch (IOException e) {
+                e.printStackTrace();
+                return false;
+            }
+            final double planeEntropy = Utils.calculateEntropy(plane.getData());
+
+            System.out.println(String.format("%d\t%.4f", planeIndex, planeEntropy));
+        }
+        return true;
+    }
+}

src/main/java/azgracompress/utilities/Utils.java

 package azgracompress.utilities;
 
+import azgracompress.U16;
+
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -99,6 +101,43 @@ public class Utils {
         return new MinMaxResult<Integer>(min, max);
     }
 
+    /**
+     * Calculate individual pixel values frequencies.
+     * Same result as of histogram of bin width = 1
+     *
+     * @param data Pixel data.
+     * @return Pixel value frequencies.
+     */
+    public static double[] calculatePixelFrequencies(final int[] data) {
+        double[] frequencies = new double[U16.Max + 1];
+        for (final int pixelValue : data) {
+            ++frequencies[pixelValue];
+        }
+        return frequencies;
+    }
+
+    public static double log2(final double v) {
+        return (Math.log(v) / Math.log(2));
+    }
+
+    public static double calculateEntropy(final int[] pixelData) {
+        final double pixelCount = pixelData.length;
+        final double[] pixelFrequencies = Utils.calculatePixelFrequencies(pixelData);
+        final double[] pixelProbabilities = new double[pixelFrequencies.length];
+
+        for (int i = 0; i < pixelFrequencies.length; i++) {
+            pixelProbabilities[i] = pixelFrequencies[i] / pixelCount;
+        }
+
+        double entropy = 0.0;
+
+        for (double pixelProbability : pixelProbabilities) {
+            if (pixelProbability > 0.0) {
+                entropy += pixelProbability * log2(pixelProbability);
+            }
+        }
+        return (-entropy);
+    }
 
     public static double calculateMse(final int[] difference) {
         double sum = 0.0;