コード例 #1
0
ファイル: Program.cs プロジェクト: D-Burkey/HuffmanEncoding
        }//end BuildEncTree method

        //
        //
        //Decompression #3
        //This method traverses the binary tree that was created based off of input from the file. It reads a byte from the file and finds that bytes character encoding.
        //It then traverses the binary tree based on the encoding (moving left if 1, moving right if 0). If the current node in the tree is a leaf node, it writes the node character value to the output file (decompressed file) and returns to the root.
        //This method stops when the number of decompressed characters matches the number of characters in the original file (this is found at the top of the encoding table file).
        static void DecodeFile(BinaryTree <char> encodingTree, string inputFilePath, string outputFilePath, string EncodingTablePath)
        {
            try
            {
                //determins the number of characters to be decoded.
                StreamReader encFile          = new StreamReader(EncodingTablePath);
                int          encodedCharCount = Convert.ToInt32(encFile.ReadLine()); //The first line in the EncodingTable file is the count of characters to be decoded.
                encFile.Close();

                FileStream inFile  = new FileStream(inputFilePath, FileMode.Open);
                FileStream outFile = new FileStream(outputFilePath, FileMode.Create);

                //Move to the root
                encodingTree.Current = encodingTree.Root;

                byte by = 0;
                //if input file is not empty
                if (inFile.Length != 0)
                {
                    by = Convert.ToByte(inFile.ReadByte()); //convert the first character in the file to a byte
                }
                //if input file is empty throw exception
                else
                {
                    throw new Exception("File being decompressed is empty.");
                }
                int bit;
                int bitPosition      = 7; //Start from the left of the bit
                int decodedCharCount = 0; //Number of decoded characters

                //While there are bits to decode
                while (decodedCharCount < encodedCharCount)
                {
                    //Check to see if we are still within the limits of the byte (i.e. bit positions 7 - 0)
                    if (bitPosition < 0)
                    {
                        //If not
                        //Read next byte from the file
                        by = Convert.ToByte(inFile.ReadByte());
                        //Start at the left of the byte
                        bitPosition = 7;
                    }

                    //Check to see if the current bit is on or off
                    bit = by & (int)Math.Pow(2, bitPosition); //if on, returns [value > 0]. if off, returns [0];

                    //If bit is on (bit > 0) - move left
                    if (bit > 0)
                    {
                        //Move left
                        encodingTree.moveTo(BinaryTree <char> .Relative.leftChild);
                        //If node is a leaf node
                        if (encodingTree.Current.isLeaf())
                        {
                            //Add the character to the file
                            outFile.WriteByte(Convert.ToByte(encodingTree.Current.Data));
                            //Move back to the root of the tree
                            encodingTree.moveTo(BinaryTree <char> .Relative.root);
                            //Increase the decoded character count
                            ++decodedCharCount;
                        }
                    }

                    //If bit is off (bit == 0) - move right
                    else if (bit == 0)
                    {
                        //Move right
                        encodingTree.moveTo(BinaryTree <char> .Relative.rightChild);
                        //If node is a leaf node
                        if (encodingTree.Current.isLeaf())
                        {
                            //Add the character to the file
                            outFile.WriteByte(Convert.ToByte(encodingTree.Current.Data));
                            //Move back to the root of the tree
                            encodingTree.moveTo(BinaryTree <char> .Relative.root);
                            //Increase the decoded character count
                            ++decodedCharCount;
                        }
                    }

                    //move to the next bit in the byte
                    --bitPosition;
                }

                inFile.Close();
                outFile.Close();
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: file(s) corrupted. Decompression failed.");
                Console.WriteLine(e.Message);
            }
        } //end DecodeFile method
コード例 #2
0
ファイル: Program.cs プロジェクト: D-Burkey/HuffmanEncoding
        }//end BuildEncTable method

        //
        //
        //Decompression #2
        //This method creates the binary tree based on the character encoding. Basically, if the current character in the character encoding is a 1, move left in the tree. If it is a 0, move right in the tree.
        //If the node doesn't exist, create it.
        static BinaryTree <char> BuildEncTree(List <CharacterEncoding> encodingTable)
        {
            BinaryTree <char> encodingTree = new BinaryTree <char>('\0'); //the new binary tree that will be developed later in this method.

            //for every CharacterEncoding object in the encoding table
            foreach (CharacterEncoding charEnc in encodingTable)
            {
                //each object being worked with to build the tree has to be instantiated, otherwise it is skipped.
                if (!(charEnc == null))
                {
                    encodingTree.Current = encodingTree.Root;     //start at the top of the tree
                    int encLength = charEnc.GetEncoding().Length; //the length of the encoding string

                    //use every encoding character (i.e. string of 1s and 0s) in the current CharacterEncoding object to create the tree.
                    for (int i = 0; i + 1 <= encLength; ++i) //for loop executes for every character in the encoding string
                    {
                        char c = charEnc.GetEncoding()[i];   //the current character in the encoding string.

                        //1 - move left in the tree.
                        if (c == '1')
                        {
                            //if left doesn't exist, create it.
                            if (encodingTree.Current.Left == null)
                            {
                                //If the node should be a root node (i.e. if the end of the character encoding string has been reached)
                                if (i + 1 == encLength)
                                {
                                    encodingTree.Insert(charEnc.GetCharacter(), BinaryTree <char> .Relative.leftChild);
                                }
                                //If node shouldn't be a root node
                                else
                                {
                                    encodingTree.Insert('\0', BinaryTree <char> .Relative.leftChild);
                                }
                            }
                            //move left
                            encodingTree.moveTo(BinaryTree <char> .Relative.leftChild);
                        }

                        //0 - move right in the tree.
                        else if (c == '0')
                        {
                            //if right doesn't exist, create it.
                            if (encodingTree.Current.Right == null)
                            {
                                //If the node should be a root node (i.e. if the end of the character encoding string has been reached)
                                if (i + 1 == encLength)
                                {
                                    encodingTree.Insert(charEnc.GetCharacter(), BinaryTree <char> .Relative.rightChild);
                                }
                                //If node shouldn't be a root node
                                else
                                {
                                    encodingTree.Insert('\0', BinaryTree <char> .Relative.rightChild);
                                }
                            }
                            //move right
                            encodingTree.moveTo(BinaryTree <char> .Relative.rightChild);
                        }
                    } //end charEncoding.GetEncoding() for loop
                }
            }         //end encodingTable foreach loop

            return(encodingTree);
        }//end BuildEncTree method