2020BTEIT00028

2020BTEIT00028/huffman code.txt

@@ -0,0 +1,151 @@
+import re
+import numpy as np
+from PIL import Image
+print("Huffman Compression Program")
+print("=================================================================")
+h = int(input("Enter 1 if you want to input an colour image file, 2 for default gray scale case:"))
+if h == 1:
+    file = input("Enter the filename:")
+    my_string = np.asarray(Image.open(file),np.uint8)
+    shape = my_string.shape
+    a = my_string
+    print ("Enetered string is:",my_string)
+    my_string = str(my_string.tolist())
+elif h == 2:
+    array = np.arange(0, 737280, 1, np.uint8)
+    my_string = np.reshape(array, (1024, 720))
+    print ("Enetered string is:",my_string)
+    a = my_string
+    my_string = str(my_string.tolist())
+
+else:
+    print("You entered invalid input")                    # taking user input
+
+letters = []
+only_letters = []
+for letter in my_string:
+    if letter not in letters:
+        frequency = my_string.count(letter)             #frequency of each letter repetition
+        letters.append(frequency)
+        letters.append(letter)
+        only_letters.append(letter)
+
+nodes = []
+while len(letters) > 0:
+    nodes.append(letters[0:2])
+    letters = letters[2:]                               # sorting according to frequency
+nodes.sort()
+huffman_tree = []
+huffman_tree.append(nodes)                             #Make each unique character as a leaf node
+
+def combine_nodes(nodes):
+    pos = 0
+    newnode = []
+    if len(nodes) > 1:
+        nodes.sort()
+        nodes[pos].append("1")                       # assigning values 1 and 0
+        nodes[pos+1].append("0")
+        combined_node1 = (nodes[pos] [0] + nodes[pos+1] [0])
+        combined_node2 = (nodes[pos] [1] + nodes[pos+1] [1])  # combining the nodes to generate pathways
+        newnode.append(combined_node1)
+        newnode.append(combined_node2)
+        newnodes=[]
+        newnodes.append(newnode)
+        newnodes = newnodes + nodes[2:]
+        nodes = newnodes
+        huffman_tree.append(nodes)
+        combine_nodes(nodes)
+    return huffman_tree                                     # huffman tree generation
+
+newnodes = combine_nodes(nodes)
+
+huffman_tree.sort(reverse = True)
+print("Huffman tree with merged pathways:")
+
+checklist = []
+for level in huffman_tree:
+    for node in level:
+        if node not in checklist:
+            checklist.append(node)
+        else:
+            level.remove(node)
+count = 0
+for level in huffman_tree:
+    print("Level", count,":",level)             #print huffman tree
+    count+=1
+print()
+
+letter_binary = []
+if len(only_letters) == 1:
+    lettercode = [only_letters[0], "0"]
+    letter_binary.append(letter_code*len(my_string))
+else:
+    for letter in only_letters:
+        code =""
+        for node in checklist:
+            if len (node)>2 and letter in node[1]:           #genrating binary code
+                code = code + node[2]
+        lettercode =[letter,code]
+        letter_binary.append(lettercode)
+print(letter_binary)
+print("Binary code generated:")
+for letter in letter_binary:
+    print(letter[0], letter[1])
+
+bitstring =""
+for character in my_string:
+    for item in letter_binary:
+        if character in item:
+            bitstring = bitstring + item[1]
+binary ="0b"+bitstring
+print("Your message as binary is:")
+                                        # binary code generated
+
+uncompressed_file_size = len(my_string)*7
+compressed_file_size = len(binary)-2
+print("Your original file size was", uncompressed_file_size,"bits. The compressed size is:",compressed_file_size)
+print("This is a saving of ",uncompressed_file_size-compressed_file_size,"bits")
+output = open("compressed.txt","w+")
+print("Compressed file generated as compressed.txt")
+output = open("compressed.txt","w+")
+print("Decoding.......")
+output.write(bitstring)
+
+bitstring = str(binary[2:])
+uncompressed_string =""
+code =""
+for digit in bitstring:
+    code = code+digit
+    pos=0                                        #iterating and decoding
+    for letter in letter_binary:
+        if code ==letter[1]:
+            uncompressed_string=uncompressed_string+letter_binary[pos] [0]
+            code=""
+        pos+=1
+
+print("Your UNCOMPRESSED data is:")
+if h == 1:
+    temp = re.findall(r'\d+', uncompressed_string)
+    res = list(map(int, temp))
+    res = np.array(res)
+    res = res.astype(np.uint8)
+    res = np.reshape(res, shape)
+    print(res)
+    print("Observe the shapes and input and output arrays are matching or not")
+    print("Input image dimensions:",shape)
+    print("Output image dimensions:",res.shape)
+    data = Image.fromarray(res)
+    data.save('uncompressed.png')
+    if a.all() == res.all():
+        print("Success")
+if h == 2:
+    temp = re.findall(r'\d+', uncompressed_string)
+    res = list(map(int, temp))
+    print(res)
+    res = np.array(res)
+    res = res.astype(np.uint8)
+    res = np.reshape(res, (1024, 720))
+    print(res)
+    data = Image.fromarray(res)
+    data.save('uncompressed.png')
+    print("Success")

2020BTEIT00028/lbg.py

@@ -0,0 +1,129 @@
+
+
+import numpy as np
+from collections import defaultdict
+
+_size_data = 0
+_dim = 0
+
+
+def generate_codebook(data, size_codebook, epsilon=0.00005):
+
+    global _size_data, _dim
+
+    _size_data = len(data)
+    assert _size_data > 0
+
+    _dim = len(data[0])
+    assert _dim > 0
+
+    codebook = []
+    codebook_abs = [_size_data]
+    codebook_rel = [1.0]
+
+    c0 = avg_all_vectors(data, _dim, _size_data)
+    codebook.append(c0)
+
+    avg_dist = initial_avg_distortion(c0, data)
+
+    while len(codebook) < size_codebook:
+        codebook, codebook_abs, codebook_rel, avg_dist = split_codebook(data, codebook,
+                                                                        epsilon, avg_dist)
+
+    return codebook, codebook_abs, codebook_rel
+
+
+def split_codebook(data, codebook, epsilon, initial_avg_dist):
+
+    new_cv = []
+    for c in codebook:
+
+        c1 = new_codevector(c, epsilon)
+        c2 = new_codevector(c, -epsilon)
+        new_cv.extend((c1, c2))
+
+    codebook = new_cv
+    len_codebook = len(codebook)
+    abs_weights = [0] * len_codebook
+    rel_weights = [0.0] * len_codebook
+
+    avg_dist = 0
+    err = epsilon + 1
+    num_iter = 0
+    while err > epsilon:
+        # Get nearest codevector.
+        closest_c_list = [None] * _size_data
+        vecs_near_c = defaultdict(list)
+        vec_idxs_near_c = defaultdict(list)
+        for i, vec in enumerate(data):
+            min_dist = None
+            closest_c_index = None
+            for i_c, c in enumerate(codebook):
+                d = get_mse(vec, c)
+
+                if min_dist is None or d < min_dist:
+                    min_dist = d
+                    closest_c_list[i] = c
+                    closest_c_index = i_c
+            vecs_near_c[closest_c_index].append(vec)
+            vec_idxs_near_c[closest_c_index].append(i)
+
+        for i_c in range(len_codebook):
+            vecs = vecs_near_c.get(i_c) or []
+            num_vecs_near_c = len(vecs)
+            if num_vecs_near_c > 0:
+
+                new_c = avg_all_vectors(vecs, _dim)
+                codebook[i_c] = new_c
+                for i in vec_idxs_near_c[i_c]:
+                    closest_c_list[i] = new_c
+
+                abs_weights[i_c] = num_vecs_near_c
+                rel_weights[i_c] = num_vecs_near_c / _size_data
+
+        prev_avg_dist = avg_dist if avg_dist > 0 else initial_avg_dist
+        avg_dist = avg_codevector_dist(closest_c_list, data)
+
+        err = (prev_avg_dist - avg_dist) / prev_avg_dist
+        num_iter += 1
+
+    return codebook, abs_weights, rel_weights, avg_dist
+
+
+def avg_all_vectors(vecs, dim=None, size=None):
+
+    size = size or len(vecs)
+    nvec = np.array(vecs)
+    nvec = nvec / size
+    navg = np.sum(nvec, axis=0)
+    return navg.tolist()
+
+
+def new_codevector(c, e):
+
+    nc = np.array(c)
+    return (nc * (1.0 + e)).tolist()
+
+
+def initial_avg_distortion(c0, data, size=None):
+
+    size = size or _size_data
+    nc = np.array(c0)
+    nd = np.array(data)
+    f = np.sum(((nc-nd)**2)/size)
+    return f
+
+
+def avg_codevector_dist(c_list, data, size=None):
+    size = size or _size_data
+    nc = np.array(c_list)
+    nd = np.array(data)
+    f = np.sum(((nc-nd)**2)/size)
+    return f
+
+
+def get_mse(a, b):
+
+    na = np.array(a)
+    nb = np.array(b)
+    return np.sum((na-nb)**2)