Add code

Author: yezea mm

decoder_lzss.py

@@ -0,0 +1,61 @@
+"""
+Name: Hew Ye Zea
+Student ID: 29035546
+Date Created : 16/6/2020
+Date Last Edited : 26/6/2020
+"""
+import sys
+from huffman import *
+from elias import *
+from bitarray import bitarray
+
+
+def decode(filename):
+    """
+    Decode a file
+    :param filename: file to be decoded
+    :return: a file that contains the decoded string
+    """
+
+    bitcode = bitarray()
+    file = open(filename, 'rb')
+    bitcode.fromfile(file)
+
+    # build a huffman tree to decode characters
+    huffman_decoder = HuffmanTree()
+    start_index = huffman_decoder.buildTree(bitcode)
+
+    # decode the number of formats
+    num_of_format, start_index = eliasDecode(bitcode,start_index)
+
+    retval = ''
+    # decode all formats
+    for i in range(num_of_format):
+        start_index += 1
+
+        # match length > 3 : format starts with "0"
+        if not bitcode[start_index - 1]:
+            offset, start_index = eliasDecode(bitcode,start_index)  # decode the offset
+            matched_length, start_index = eliasDecode(bitcode,start_index)  # decode match length
+
+            offset_start = len(retval) - offset
+
+            for j in range(matched_length):
+                retval += retval[j + offset_start]  # copy the characters
+
+        # match length < 3 , format starts with "1"
+        else:
+            char_ascii,start_index = huffman_decoder.decodeHuffman(bitcode,start_index)
+            retval += chr(char_ascii)       # decode the character
+
+    output = open('output_decoder_lzss.txt', 'w')
+    output.write(retval)
+    output.close()
+    file.close()
+
+
+if __name__ == '__main__':
+    _, filename = sys.argv
+    decode(filename)
+
+    #decode('output_encoder_lzss.bin')

elias.py

@@ -0,0 +1,95 @@
+"""
+Name: Hew Ye Zea
+Student ID: 29035546
+Date Created : 11/6/2020
+Date Last Edited : 26/6/2020
+"""
+
+from bitarray import bitarray
+
+
+def fromDecToBinary(num):
+    """
+    Generate binary representation of num
+    :param num: the number
+    :return: a bitarray that represents num
+    """
+    temp = []
+    while num > 0:
+        temp.append(num & 1)
+        num = num >> 1
+    temp = temp[::-1]  # reverse the array to get the correct binary representation
+    return bitarray(temp)
+
+
+def fromBinaryToDec(binary, start, end, flipBit=False):
+    """
+    Convert a portion of the bitarray to its respective decimal value
+    :param binary: bitarray
+    :param start: staring index
+    :param end: ending index
+    :param flipBit : boolean, true = flip starting bit
+    :return: binary[start:end] as decimal value
+    """
+    bin = ""
+    if flipBit :
+        binary[start] = "1"
+    for bit_index in range(start,end):
+        if binary[bit_index]:
+            bin += "1"
+        else:
+            bin += "0"
+
+    return int(bin,2)
+
+
+def eliasEncode(num):
+    """
+    Encode an integer using Elias Encoding method
+    :param num: the integer to be elias encoded
+    :return: the elias encoded integer
+    """
+    binary_num = fromDecToBinary(num)
+    encoded = []
+    encoded.append(binary_num)
+    length_bin = len(binary_num)
+
+    while length_bin > 1 :
+        # encode all length code
+        new_length = fromDecToBinary(length_bin-1)
+        new_length[0] = 0  # flip the first bit to 0 , to denote that this is a length code
+        encoded.append(new_length)
+        length_bin = len(new_length)
+
+    result = bitarray('')
+    for i in range(len(encoded)-1,-1,-1):
+        result += encoded[i]  # reverse the whole thing
+
+    return result
+
+
+def eliasDecode(code,current_i = 0):
+    """
+    Decode an elias encoded integer
+    :param code: a bitstring that is elias encoded
+    :param current_i: current index of i
+    :return:
+    """
+
+    # if the current bit == "1" , that denotes the smallest possible integer , return 1 straight away
+    if code[current_i]:
+        return 1,current_i + 1
+
+    else:
+        index = 1
+        length = 2
+        # "0" denotes the length
+        # while the next bit is "0" , keep finding the new length
+        while not code[current_i+index]:
+            new_length = fromBinaryToDec(code, current_i+index, current_i+index+length,True)
+            index += length # increment index
+            length = new_length + 1
+
+        decoded_num = fromBinaryToDec(code,current_i+index, current_i+index+length)  # decode the number
+
+        return decoded_num, index + current_i + length

encoder_lzss.py

@@ -0,0 +1,127 @@
+"""
+Name: Hew Ye Zea
+Student ID: 29035546
+Date Created : 16/6/2020
+Date Last Edited : 26/6/2020
+""" 
+import sys
+from huffman import *
+from elias import *
+from z_algo import *
+from bitarray import bitarray
+
+
+def encode(filename,w,l):
+
+    # read file
+    string = readfile(filename)
+
+    # encode the string using huffman
+    encoded , uniq_char = encodeHuffman(string)
+
+    # encode header and data
+    header = encode_header(uniq_char,encoded)
+    data = encode_data(string,w,l,encoded)
+
+    # concat header and data
+    result = header + data
+
+    # output result to file
+    output = open('output_encoder_lzss.bin', 'wb')
+    result.tofile(output)
+    output.close()
+
+
+def encode_header(uniq_char, encoded):
+    """
+    Encode the header
+    :param uniq_char: number of unique characters
+    :param encoded: the huffman code of each unique character
+    :return: an encoded header
+    """
+    # header consists of
+    # 1. unique char - elias coded
+    # 2. ascii code of each char - elias coded
+    # 3. length of huffman code - elias coded
+    # 4. huffman code
+    result = bitarray()
+    result += eliasEncode(uniq_char)  # add elias encoded # of unique char to header [1]
+
+    for ascii,huffman_code in enumerate(encoded):
+        if huffman_code is not None :
+            ascii_in_binary = fromDecToBinary(ascii)
+            ascii_encoded = bitarray('0' * (7 - len(ascii_in_binary))) + ascii_in_binary  # elias coded ascii code [2]
+            huffman_code_length = eliasEncode(len(huffman_code))  # elias coded - length of huffman code [3]
+            result = result + ascii_encoded + huffman_code_length + huffman_code  # concat huffman code
+
+    return result
+
+
+def encode_data(string,w,l,encoded):
+    """
+    Encode the data part
+    :param string: string to be encoded
+    :param w: window size
+    :param l: lookahead buffer size
+    :param encoded: the huffman code of each unique character
+    :return: a bitstring that contains the encoded data
+    """
+    result = bitarray()
+    number_of_formats = 0
+    index = 0
+
+    while index < len(string):
+        # increment the number of formats
+        number_of_formats += 1
+
+        # run z algorithm on string to calculate the matched length
+        z_arr = z_algo(string,w,l,index)
+
+        maximum_length = -1
+        maximum_offset = -1
+
+        # obtain the maximum match length
+        for i in range(len(z_arr)):
+            if z_arr[i] >= maximum_length:
+                maximum_offset = i
+                maximum_length = z_arr[i]
+
+        # matched length > 3 , encode data in the format of :
+        # 0 +  offset [1]  + matched length [2]
+        if maximum_length >= 3 :
+            zero = bitarray('0')
+            offset = eliasEncode(len(z_arr) - maximum_offset)  # [1]
+            length = eliasEncode(maximum_length)  # [2]
+            result = result + zero + offset + length
+            index += maximum_length  # increment index
+
+        # matched length < 3 , encode data in the format of :
+        # 1 + ascii huffman code [1]
+        else:
+            one = bitarray('1')
+            char = string[index]
+            ascii_huffman = encoded[ord(char)]  # [1]
+
+            result = result + one + ascii_huffman
+            index += 1  # increment index
+
+    elias_format = eliasEncode(number_of_formats)  # elias encode the total number of format
+    result = elias_format + result  # prepend the elias encoded format to result
+
+    return result
+
+
+def readfile(filename):
+    file = open(filename,"r")
+    lines = []
+    for line in file:
+        lines.append(line)
+    file.close()
+    return ''.join(lines)
+
+
+if __name__ == '__main__':
+    _, filename, w, l = sys.argv
+    encode(filename, int(w), int(l))
+
+