void HuffmanCompressor::getHuffmanCode(Node *node, std::string code, std::string &encodedHuffmanTree)
{
if (node->left == NULL && node->right == NULL) {
// Leaf node
encodedHuffmanTree += "1";
encodedHuffmanTree += getBinary(node->value);
huffmanCodes[node->value] = code;
} else {
// Internal node
encodedHuffmanTree += "0";
if (node->left != NULL)
getHuffmanCode(node->left, code + "0", encodedHuffmanTree);
if (node->right != NULL)
getHuffmanCode(node->right, code + "1", encodedHuffmanTree);
}
}
void getHuffmanCode(HuffmanTree *Tree){
HuffmanTree *leftnode(Tree->left);
HuffmanTree *rightnode(Tree->right);
QString key,code;
if(leftnode==NULL && rightnode==NULL)
Tree->Code="1";
if(Tree->root==true)
{
if(leftnode!=NULL)
leftnode->Code="0";
if(rightnode!=NULL)
rightnode->Code="1";
}
else{
if(leftnode!=NULL)
leftnode->Code=leftnode->parent->Code+"0";
if(rightnode!=NULL)
rightnode->Code=rightnode->parent->Code+"1";
}
if(leftnode!=NULL){
if(!leftnode->isLeaf)
getHuffmanCode(leftnode);
else{
key=leftnode->karakter;
code=leftnode->Code;
encode::CodeHash.insert(key,code);
}
}
if(rightnode!=NULL){
if(!rightnode->isLeaf)
getHuffmanCode(rightnode);
else{
key=rightnode->karakter;
code=rightnode->Code;
encode::CodeHash.insert(key,code);
}
}
}
void HuffmanCompressor::compress(int size, const INT16 *data, Bitset &transmitData)
{
// Find frequency of each value
for (UINT i = 0; i < size; ++i)
++dataFrequency[data[i]];
dataFrequency[INT16_MAX] = 1; // use max value as the pseudo EOF
// Store each frequency as a (leaf) node in minimum heap
for (auto it = dataFrequency.begin(); it != dataFrequency.end(); ++it) {
Node *node = new Node(it->first, it->second);
minHeap.push(node);
}
// Generate Huffman tree
while (minHeap.size() != 1) {
Node *right = minHeap.top();
minHeap.pop();
Node *left = minHeap.top();
minHeap.pop();
minHeap.push(new Node(left->frequency + right->frequency, left, right)); // Create internal node
}
Node *huffmanTree = minHeap.top();
// Get Huffman codes for each value and generate encoded Huffman tree
std::string code("");
std::string encodedHuffmanTree("");
getHuffmanCode(huffmanTree, code, encodedHuffmanTree);
std::reverse(encodedHuffmanTree.begin(), encodedHuffmanTree.end()); // TODO: try encodedHuffmanTree = bit + encodedHuffmanTree to see if performance is better
// Encode data values
std::string encodedData("");
for (UINT i = 0; i < size; ++i) {
encodedData += huffmanCodes[data[i]];
}
encodedData += huffmanCodes[INT16_MAX]; // add pseudo EOF
std::reverse(encodedData.begin(), encodedData.end());
// Convert data to bit array
transmitData = Bitset(encodedData + encodedHuffmanTree);
// Deallocate memory
deallocateTree(huffmanTree);
minHeap.pop();
dataFrequency.clear();
huffmanCodes.clear();
}
