Implemented basic inspect and added output file option.

src/main/java/DataCompressor.java

@@ -33,11 +33,11 @@ public class DataCompressor {
             return;
         }
 
-        System.out.println(parsedCliOptions.report());
+//        System.out.println(parsedCliOptions.report());
 
         switch (parsedCliOptions.getMethod()) {
 
-            case Compress:
+            case Compress: {
                 ImageCompressor compressor = new ImageCompressor(parsedCliOptions);
                 try {
                     compressor.compress();
@@ -47,19 +47,30 @@ public class DataCompressor {
                     e.printStackTrace();
                 }
                 return;
-            case Decompress:
+            }
+            case Decompress: {
                 ImageDecompressor decompressor = new ImageDecompressor(parsedCliOptions);
                 if (decompressor.decompress()) {
                 } else {
                     System.err.println("Errors occurred during decompression.");
                 }
                 return;
-            case PrintHelp:
+            }
+            case PrintHelp: {
                 formatter.printHelp("ijava -jar DataCompressor.jar", options);
-                break;
-            case InspectFile:
-                System.err.println("Not supported yet.");
-                break;
+            }
+            break;
+            case InspectFile: {
+                ImageDecompressor decompressor = new ImageDecompressor(parsedCliOptions);
+                try {
+                    System.out.println(decompressor.inspectCompressedFile());
+                } catch (IOException e) {
+                    System.err.println("Errors occurred during inspecting file.");
+                    System.err.println(e.getMessage());
+                    e.printStackTrace();
+                }
+                return;
+            }
         }
         return;
     }
@@ -107,7 +118,7 @@ public class DataCompressor {
                           true,
                           "Reference plane index");
         //        options.addRequiredOption(INPUT_SHORT, INPUT_LONG, true, "Input file");
-        options.addOption(CliConstants.OUTPUT_SHORT, CliConstants.OUTPUT_LONG, true, "Custom output directory");
+        options.addOption(CliConstants.OUTPUT_SHORT, CliConstants.OUTPUT_LONG, true, "Custom output file");
         return options;
     }
 }

src/main/java/cli/ParsedCliOptions.java

 package cli;
 
+import compression.CompressorDecompressorBase;
 import compression.data.V2i;
 import compression.data.V3i;
 import compression.fileformat.QuantizationType;
 import org.apache.commons.cli.CommandLine;
 
+import java.io.File;
 import java.nio.file.Paths;
 
 public class ParsedCliOptions {
@@ -15,7 +17,7 @@ public class ParsedCliOptions {
     private QuantizationType quantizationType;
 
     private String inputFile;
-    private String outputDirectory;
+    private String outputFile;
 
     private int bitsPerPixel;
     private V2i vectorDimension = new V2i(0);
@@ -36,6 +38,13 @@ public class ParsedCliOptions {
         parseCLI(cmdInput);
     }
 
+    private String getDefaultOutputFilePath(final String inputPath) {
+        final File inputFile = new File(inputPath);
+        final File outputFile = new File(Paths.get("").toAbsolutePath().toString(),
+                                         inputFile.getName() + CompressorDecompressorBase.EXTENSTION);
+        return (outputFile.getAbsolutePath());
+    }
+
     private void parseCLI(final CommandLine cmd) {
         StringBuilder errorBuilder = new StringBuilder("Errors:\n");
         errorOccurred = false;
@@ -48,8 +57,6 @@ public class ParsedCliOptions {
 
         parseBitsPerPixel(cmd, errorBuilder);
 
-        // Default output directory to current directory.
-        outputDirectory = cmd.getOptionValue(CliConstants.OUTPUT_LONG, Paths.get("").toAbsolutePath().toString());
 
         parseReferencePlaneIndex(cmd, errorBuilder);
 
@@ -58,6 +65,10 @@ public class ParsedCliOptions {
 
         verbose = cmd.hasOption(CliConstants.VERBOSE_LONG);
 
+        if (!errorOccurred) {
+            outputFile = cmd.getOptionValue(CliConstants.OUTPUT_LONG, getDefaultOutputFilePath(inputFile));
+        }
+
         error = errorBuilder.toString();
     }
 
@@ -263,8 +274,8 @@ public class ParsedCliOptions {
         return inputFile;
     }
 
-    public String getOutputDirectory() {
-        return outputDirectory;
+    public String getOutputFile() {
+        return outputFile;
     }
 
     public int getBitsPerPixel() {
@@ -343,7 +354,7 @@ public class ParsedCliOptions {
 
 
         sb.append("BitsPerPixel: ").append(bitsPerPixel).append('\n');
-        sb.append("OutputDirectory: ").append(outputDirectory).append('\n');
+        sb.append("OutputDirectory: ").append(outputFile).append('\n');
         sb.append("InputFile: ").append(inputFile).append('\n');
 
         if (method == ProgramMethod.Compress) {

src/main/java/compression/ImageCompressor.java

@@ -9,7 +9,6 @@ import compression.quantization.scalar.LloydMaxU16ScalarQuantization;
 import compression.quantization.scalar.ScalarQuantizer;
 
 import java.io.DataOutputStream;
-import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 
@@ -25,7 +24,7 @@ public class ImageCompressor extends CompressorDecompressorBase {
 
     public void compress() throws Exception {
 
-        FileOutputStream fos = new FileOutputStream(getOutputFilePath(), false);
+        FileOutputStream fos = new FileOutputStream(options.getOutputFile(), false);
         DataOutputStream dataOutputStream = new DataOutputStream(fos);
 
         // Create and write header to output stream.
@@ -53,12 +52,6 @@ public class ImageCompressor extends CompressorDecompressorBase {
         fos.close();
     }
 
-    protected String getOutputFilePath() {
-        final File inputFile = new File(options.getInputFile());
-        final File file = new File(options.getOutputDirectory(), inputFile.getName() + EXTENSTION);
-        return file.getAbsolutePath();
-    }
-
     private QCMPFileHeader createHeader() {
         QCMPFileHeader header = new QCMPFileHeader();
 

src/main/java/compression/ImageDecompressor.java

 package compression;
 
 import cli.ParsedCliOptions;
+import compression.fileformat.QCMPFileHeader;
+
+import java.io.DataInputStream;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
 
 public class ImageDecompressor extends CompressorDecompressorBase {
     public ImageDecompressor(ParsedCliOptions options) {
@@ -10,4 +16,84 @@ public class ImageDecompressor extends CompressorDecompressorBase {
     public boolean decompress() {
         return true;
     }
+
+    private DataInputStream openCompressedFile() throws FileNotFoundException {
+        FileInputStream fis = new FileInputStream(options.getInputFile());
+        return new DataInputStream(fis);
+    }
+
+    private QCMPFileHeader readQCMPFileHeader(DataInputStream inputStream) throws IOException {
+        QCMPFileHeader header = new QCMPFileHeader();
+        if (!header.readHeader(inputStream)) {
+            // Not valid QCMP file.
+            return null;
+        }
+        return header;
+    }
+
+    public String inspectCompressedFile() throws IOException {
+        StringBuilder logBuilder = new StringBuilder();
+        DataInputStream inputStream = openCompressedFile();
+        final QCMPFileHeader header = readQCMPFileHeader(inputStream);
+        if (header == null) {
+            logBuilder.append("Input file is not valid QCMPFile\n");
+        } else {
+
+
+            final boolean validHeader = header.validateHeader();
+            logBuilder.append("Header is:\t\t").append(validHeader ? "valid" : "invalid").append('\n');
+
+            logBuilder.append("Magic value:\t\t").append(header.getMagicValue()).append('\n');
+            logBuilder.append("Quantization type\t");
+            switch (header.getQuantizationType()) {
+                case Scalar:
+                    logBuilder.append("Scalar\n");
+                    break;
+                case Vector1D:
+                    logBuilder.append("Vector1D\n");
+                    break;
+                case Vector2D:
+                    logBuilder.append("Vector2D\n");
+                    break;
+                case Vector3D:
+                    logBuilder.append("Vector3D\n");
+                    break;
+                case Invalid:
+                    logBuilder.append("INVALID\n");
+                    break;
+            }
+            logBuilder.append("Bits per pixel:\t\t").append(header.getBitsPerPixel()).append('\n');
+            logBuilder.append("Codebook:\t\t").append(header.isCodebookPerPlane() ? "one per plane\n" : "one for all\n");
+
+            logBuilder.append("Image size X:\t\t").append(header.getImageSizeX()).append('\n');
+            logBuilder.append("Image size Y:\t\t").append(header.getImageSizeY()).append('\n');
+            logBuilder.append("Image size Z:\t\t").append(header.getImageSizeZ()).append('\n');
+
+            logBuilder.append("Vector size X:\t\t").append(header.getVectorSizeX()).append('\n');
+            logBuilder.append("Vector size Y:\t\t").append(header.getVectorSizeY()).append('\n');
+            logBuilder.append("Vector size Z:\t\t").append(header.getVectorSizeZ()).append('\n');
+        }
+        return logBuilder.toString();
+    }
 }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/main/java/compression/fileformat/QCMPFileHeader.java

@@ -9,6 +9,7 @@ import java.io.DataOutputStream;
 import java.io.IOException;
 
 public class QCMPFileHeader {
+    public static final int QCMP_HEADER_SIZE = 23;
     public static final String QCMP_MAGIC_VALUE = "QCMPFILE";
 
     private String magicValue = QCMP_MAGIC_VALUE;
@@ -70,8 +71,17 @@ public class QCMPFileHeader {
         outputStream.writeInt(vectorSizeZ);
     }
 
-    public void readHeader(DataInputStream inputStream) throws IOException {
+    public boolean readHeader(DataInputStream inputStream) throws IOException {
+
+        if (inputStream.available() < QCMP_HEADER_SIZE) {
+            return false;
+        }
+
+
         magicValue = new String(inputStream.readNBytes(8));
+        if (!magicValue.equals(QCMP_MAGIC_VALUE)) {
+            return false;
+        }
 
         quantizationType = QuantizationType.fromByte(inputStream.readByte());
         bitsPerPixel = inputStream.readByte();
@@ -84,6 +94,8 @@ public class QCMPFileHeader {
         vectorSizeX = inputStream.readInt();
         vectorSizeY = inputStream.readInt();
         vectorSizeZ = inputStream.readInt();
+
+        return true;
     }
 
     public QuantizationType getQuantizationType() {
@@ -158,6 +170,10 @@ public class QCMPFileHeader {
         this.vectorSizeZ = vectorSizeZ;
     }
 
+    public String getMagicValue() {
+        return magicValue;
+    }
+
     public void setImageDimension(final V3i imageDims) {
         imageSizeX = imageDims.getX();
         imageSizeY = imageDims.getY();