Night commit. Added rich text feature to Huffman tree encoding and decoding. Fixed minor bugs.

Author: JonKPowers

Lab_3/HuffmanTree.java

@@ -5,12 +5,13 @@ class HuffmanTree
    private HuffmanNode treeRoot;
    private HuffmanCode[] codes;
    private HuffmanCode[] binaryCodeTree;
+   private boolean richText;
 
    /////////////////////////
    // Constructors
    /////////////////////////
 
-   HuffmanTree(PriorityQueue queue){
+   HuffmanTree(PriorityQueue queue, boolean richText){
       /**
       ** Constructor for HuffmanTree. The HuffmanTree must be initialized with a PriorityQueue
       ** that is seeded with the characters and frequencies to be used in the Huffman
@@ -23,6 +24,7 @@ class HuffmanTree
       buildTree(queue);
       this.codes = generateCodes();
       this.binaryCodeTree = buildSearchTree();
+      this.richText = richText;
 
    }
 
@@ -36,6 +38,20 @@ public String encodeString(StringStack data){
          String character = data.pop();
          String encodedCharacter = encode(character);
          encodedString += encodedCharacter;
+         
+         // Add richText enhancements
+         if(!encodedCharacter.equals("") && richText){
+            // Add the capiatlization flag
+            encodedString += character.toUpperCase().equals(character) ? "1" : "0";
+            // Check if the next character is a space; if so, add a flag and delete the space
+            if(!data.isEmpty() && data.peek().equals(" ")){
+               encodedString += "1";
+               data.pop();
+            } else{
+               encodedString += "0";
+            }
+         }
+         
       }
       return encodedString;
    }
@@ -51,18 +67,38 @@ public String decode(StringStack codeString){
       **/
       String decodedString = "";
       while(!codeString.isEmpty()){
+         String decodedCharacter;
          HuffmanNode currentNode = treeRoot;
+         boolean capitalizeCharacter = false;
+         boolean addSpace = false;
+         
          while(!currentNode.isLeaf()){
             try{
                currentNode = codeString.pop().equals("0") ? currentNode.getLeftChild() : currentNode.getRightChild();
             } catch (EmptyStackException except) {
-               EncodingException exception = new EncodingException("The encoded string is invalid--does not match code tree");
-               throw exception;
+               throw new EncodingException("The encoded string is invalid--does not match code tree");
             }
          }
-         decodedString += currentNode.getChars();
-
-         // TODO ADD HANDLING FOR SPACES AND/OR CAPITALIZATION      
+         decodedCharacter = currentNode.getChars();
+         
+         // Make richText adjustments if enabled
+         if(richText){
+            try{
+               capitalizeCharacter = codeString.pop().equals("1") ? true : false;
+               addSpace = codeString.pop().equals("1") ? true : false;
+            } catch (EmptyStackException except){
+               throw new EncodingException("The encoded string is invalid--does not match code tree");
+            }
+            if(!capitalizeCharacter){
+               decodedCharacter = decodedCharacter.toLowerCase();
+            } 
+         }
+         
+         // Append new character to decodedString
+         decodedString += decodedCharacter;
+         if(addSpace){
+            decodedString += " ";
+         }   
       }
 
       return decodedString;
@@ -93,7 +129,7 @@ private HuffmanCode[] buildSearchTree(){
       **
       ** @return HuffmanCode[] A binary tree of HuffmanCode objects contained in an array.
       **/
-      HuffmanCode[] tree = new HuffmanCode[(int) Math.pow(2, leafNodes.length) + 1];
+      HuffmanCode[] tree = new HuffmanCode[(int) Math.pow(2, leafNodes.length /2 ) + 1];
       int midNode = codes.length / 2;
       tree[1] = codes[midNode];
       for(int i=0; i<codes.length; i++){

Lab_3/JPowers_Lab3_Analysis.odt

@@ -12,7 +12,9 @@ public static void main( String[] args ){
       File encodingFile;
       File inputFile;
       String outputFile;
-      HuffmanTree tree;
+      HuffmanTree plainTree;
+      HuffmanTree richTree;
+      HuffmanTree currentTree;
       StringStackDataPack[] inputData;
 
 
@@ -29,9 +31,31 @@ public static void main( String[] args ){
       inputFile = getInputFile(args);
       outputFile = args[3];
       richText = getRichText(args);
+      
+      // Build the plainTree
+      plainTree = new HuffmanTree(FreqTableHandler.getFrequencies(encodingFile), false);
+      
+      // Build the richTree--Generate the queue, inject punctuation into it, then build the tree
+      PriorityQueue queue = FreqTableHandler.getFrequencies(encodingFile);
+      queue.push(new HuffmanNode(".", 13));
+      queue.push(new HuffmanNode(",", 20));
+      queue.push(new HuffmanNode(";", 7));
+      queue.push(new HuffmanNode(":", 29));
+      queue.push(new HuffmanNode("-", 3));
+      queue.push(new HuffmanNode("/", 11));
+      queue.push(new HuffmanNode("\\", 7));
+      queue.push(new HuffmanNode("(", 4));
+      queue.push(new HuffmanNode(")", 27));
+      queue.push(new HuffmanNode("[", 18));
+      queue.push(new HuffmanNode("]", 21));
+      queue.push(new HuffmanNode("{", 7));
+      queue.push(new HuffmanNode("}", 9));
+      queue.push(new HuffmanNode("?", 13));
+      queue.push(new HuffmanNode("!", 16));
+      queue.push(new HuffmanNode("'", 22));
 
       // Build Huffman tree
-      tree = new HuffmanTree(FreqTableHandler.getFrequencies(encodingFile));
+      richTree = new HuffmanTree(queue, true);
       // Get data from input file
       inputData = InputFileHandler.getLinesFromFileAsStacks(inputFile);
 
@@ -47,6 +71,7 @@ public static void main( String[] args ){
             richText = data.turnRichTextOn() ? true : richText;
             richText = data.turnRichTextOff() ? false : richText;
 
+            currentTree = richText ? richTree : plainTree;
 
             // Setup variables and output boilerplate
             StringStack inputDataStack = data.stack;
@@ -61,14 +86,14 @@ public static void main( String[] args ){
             // Encode the input file
             if(mode.equals("encode")){
                try{
-                  String encodedString = tree.encodeString(inputDataStack);
+                  String encodedString = currentTree.encodeString(inputDataStack);
                   int rawSize = inputString.getBytes("UTF-8").length;
                   double compressedSize = encodedString.length() / 8.0;
 
                   outputWriter.write("Original size: " + inputString.length() + " characters (" + rawSize + " bytes using UTF-8)\n");
                   outputWriter.write("Encoded size: " + encodedString.length() + " bits (" + compressedSize + " bytes)\n");
                   outputWriter.write("Compression: " + (compressedSize / rawSize * 100) + "%\n");
-                  outputWriter.write("\nPreorder traversal: " + tree.getPreorderTraversal() + "\n");
+                  outputWriter.write("\nPreorder traversal: " + currentTree.getPreorderTraversal() + "\n");
                   outputWriter.write("\nEncoded string: " + encodedString + "\n\n\n");
                } catch (EncodingException except){
                   outputWriter.write("Error during encoding: " + except.getMessage() + "\n");
@@ -77,13 +102,13 @@ public static void main( String[] args ){
             // Or decode the input file
             else{
                try{
-                  String decodedString = tree.decode(inputDataStack);
+                  String decodedString = currentTree.decode(inputDataStack);
                   int rawSize = decodedString.getBytes("UTF-8").length;
                   double compressedSize = inputString.length() / 8.0;
                   outputWriter.write("Encoded size: " + inputString.length() + " bits (" + compressedSize + " bytes)\n");
                   outputWriter.write("Decoded size: " + decodedString.length() + " characters (" + rawSize + " bytes)\n");
                   outputWriter.write("Compression: " + (compressedSize / rawSize * 100) + "%\n");
-                  outputWriter.write("\nPreorder traversal: " + tree.getPreorderTraversal() + "\n");
+                  outputWriter.write("\nPreorder traversal: " + currentTree.getPreorderTraversal() + "\n");
                   outputWriter.write("\nDecoded string: " + decodedString +"\n\n\n");
                } catch (EncodingException except){
                   outputWriter.write("Error during decoding: " + except.getMessage() + "\n");

Lab_3/Lab3Main.java

@@ -22,9 +22,12 @@ class PriorityQueue
        ** the arithmetic methods of calculating parents and children do not work
        ** with an input index of 0.
        **
+       ** In additio, I've added 20 extra spaces into the heap for any enhancement
+       ** characters added that need to be added to the PriorityQueue
+       **
        ** @param maxQueueSize Integer specifying the maximum number of items in the priority queue.
        **/
-      heap = new HuffmanNode[maxQueueSize + 1];
+      heap = new HuffmanNode[maxQueueSize + 1 + 20];
       heapSize = 0;
    }