Loading .DS_Store (8 KiB) File changed.No diff preview for this file type. View original file View changed file .ipynb_checkpoints/Encoding_decoding-checkpoint.ipynb +112 −61 Original line number Diff line number Diff line Loading @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", "execution_count": 12, "execution_count": 59, "id": "14f74f21", "metadata": {}, "outputs": [], Loading @@ -19,12 +19,13 @@ "from sklearn.neighbors import KernelDensity\n", "import pandas as pd\n", "from collections import Counter\n", "import time" "import time\n", "import numpy.linalg as la" ] }, { "cell_type": "code", "execution_count": 13, "execution_count": 49, "id": "c16af61f", "metadata": {}, "outputs": [], Loading Loading @@ -78,12 +79,12 @@ }, { "cell_type": "code", "execution_count": 14, "id": "aceba613", "execution_count": 61, "id": "8172fa41", "metadata": {}, "outputs": [], "source": [ "def predict_pix(tiff_image):\n", "def predict_pix(tiff_image, difference = True):\n", " \"\"\"\n", " This function predict the pixel values excluding the boundary.\n", " Using the 4 neighbor pixel values and MSE to predict the next pixel value\n", Loading @@ -99,16 +100,15 @@ " \n", " Return:\n", " image (512 X 640): original image \n", " predict (325380,): predicted image exclude the boundary\n", " diff. (325380,): difference between the min and max of four neighbors exclude the boundary\n", " predict (325380,): predicted image excluding the boundary\n", " diff. (325380,): IF difference = TRUE, difference between the min and max of four neighbors exclude the boundary\n", " ELSE: the residuals of the four nearest pixels to a fitted hyperplane\n", " error (325380,): difference between the original image and predicted image\n", " A (3 X 3): system of equation\n", " \"\"\"\n", " image = Image.open(tiff_image) #Open the image and read it as an Image object\n", " image = np.array(image)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data\n", " image = image.astype(int) \n", " print(image.shape)\n", " # use \n", " A = np.array([[3,0,-1],[0,3,3],[1,-3,-4]]) # the matrix for system of equation\n", " # where z0 = (-1,1), z1 = (0,1), z2 = (1,1), z3 = (-1,0)\n", " z0 = image[0:-2,0:-2] # get all the first pixel for the entire image\n", Loading @@ -123,23 +123,37 @@ " # use numpy solver to solve the system of equations all at once\n", " #predict = np.floor(np.linalg.solve(A,y)[-1])\n", " predict = np.round(np.round((np.linalg.solve(A,y)[-1]),1))\n", " \n", " #Matrix system of points that will be used to solve the least squares fitting hyperplane\n", " points = np.array([[-1,-1,1], [-1,0,1], [-1,1,1], [0,-1,1]])\n", " \n", " # flatten the neighbor pixlels and stack them together\n", " z0 = np.ravel(z0)\n", " z1 = np.ravel(z1)\n", " z2 = np.ravel(z2)\n", " z3 = np.ravel(z3)\n", " neighbor = np.vstack((z0,z1,z2,z3)).T\n", " \n", " if difference:\n", " # calculate the difference\n", " diff = np.max(neighbor,axis = 1) - np.min(neighbor, axis=1)\n", " \n", " else:\n", " #Compute the best fitting hyperplane using least squares\n", " #The res is the residuals of the four points used to fit the hyperplane (summed distance of each of the \n", " #points to the hyperplane), it is a measure of gradient\n", " f, diff, rank, s = la.lstsq(points, neighbor.T, rcond=None) \n", " diff = diff.astype(int)\n", " \n", " # calculate the error\n", " error = np.ravel(image[1:-1,1:-1])-predict\n", " \n", " return image, predict, diff, error, A\n" " return image, predict, diff, error, A" ] }, { "cell_type": "code", "execution_count": 15, "execution_count": 62, "id": "6b965751", "metadata": {}, "outputs": [], Loading Loading @@ -192,12 +206,12 @@ }, { "cell_type": "code", "execution_count": 24, "execution_count": 63, "id": "b7561883", "metadata": {}, "outputs": [], "source": [ "def huffman(image, num_bins=4):\n", "def huffman(image, num_bins=4, difference = True):\n", " \"\"\"\n", " This function is used to encode the error based on the difference\n", " and split the difference into different bins\n", Loading @@ -218,7 +232,7 @@ " \n", " \"\"\"\n", " # get the prediction error and difference\n", " image, predict, diff, error, A = predict_pix(image)\n", " image, predict, diff, error, A = predict_pix(image, difference)\n", " \n", " # get the number of points in each bins\n", " data_points_per_bin = len(diff) // num_bins\n", Loading Loading @@ -300,18 +314,23 @@ }, { "cell_type": "code", "execution_count": 17, "execution_count": 64, "id": "2eb774d2", "metadata": {}, "outputs": [], "source": [ "def encoder(error, list_dic, diff, bound, bins):\n", " \"\"\"\n", <<<<<<< HEAD " This function en\n", ======= " This function \n", >>>>>>> a352868acf14cebeaa7ea2a58e879b1d36b066ad " This function encode the matrix with huffman coding tables\n", " \n", " Input:\n", " error (512, 640): a matrix with all the errors\n", " list_dic (num_dic + 1,): a list of huffman coding table \n", " bound (2300,): the boundary values after subtracting the very first pixel value\n", " bins (num_bins - 1,): a list of threshold to cut the bins\n", " \n", " Return:\n", " encoded (512, 640): encoded matrix\n", " \"\"\"\n", " # copy the error matrix (including the boundary)\n", " encoded = np.copy(error).astype(int).astype(str).astype(object)\n", Loading @@ -335,15 +354,22 @@ }, { "cell_type": "code", "execution_count": 23, "execution_count": 79, "id": "8eeb40d0", "metadata": {}, "outputs": [], "source": [ "def decoder(A, encoded_matrix, list_dic, bins):\n", "def decoder(A, encoded_matrix, list_dic, bins, use_diff):\n", " \"\"\"\n", " Function that accecpts the prediction matrix A for the linear system,\n", " the encoded matrix of error values, and the encoding dicitonary.\n", " This function decodes the encoded_matrix.\n", " Input:\n", " A (3 X 3): system of equation\n", " list_dic (num_dic + 1,): a list of huffman coding table \n", " encoded_matrix (512, 640): encoded matrix\n", " bins (num_bins - 1,): a list of threshold to cut the bins\n", " \n", " Return:\n", " decode_matrix (512, 640): decoded matrix\n", " \"\"\"\n", " # change the dictionary back to list\n", " # !!!!!WARNING!!!! has to change this part, eveytime you change the number of bins\n", Loading @@ -362,62 +388,85 @@ " the_keys4 = list(list_dic[4].keys())\n", " the_values4 = list(list_dic[4].values())\n", " \n", " error_matrix = np.zeros((512,640))\n", " #Matrix system of points that will be used to solve the least squares fitting hyperplane\n", " points = np.array([[-1,-1,1], [-1,0,1], [-1,1,1], [0,-1,1]])\n", " \n", " decode_matrix = np.zeros((512,640))\n", " # loop through all the element in the matrix\n", " for i in range(error_matrix.shape[0]):\n", " for j in range(error_matrix.shape[1]):\n", " for i in range(decode_matrix.shape[0]):\n", " for j in range(decode_matrix.shape[1]):\n", " # if it's the very first pixel on the image\n", " if i == 0 and j == 0:\n", " error_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])])\n", " decode_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])])\n", " # if it's on the boundary\n", " elif i == 0 or i == error_matrix.shape[0]-1 or j == 0 or j == error_matrix.shape[1]-1:\n", " error_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])]) + error_matrix[0][0]\n", " elif i == 0 or i == decode_matrix.shape[0]-1 or j == 0 or j == decode_matrix.shape[1]-1:\n", " decode_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])]) + decode_matrix[0][0]\n", " # if not the boundary\n", " else:\n", " # predict the image with the known pixel value\n", " z0 = error_matrix[i-1][j-1]\n", " z1 = error_matrix[i-1][j]\n", " z2 = error_matrix[i-1][j+1]\n", " z3 = error_matrix[i][j-1]\n", " z0 = decode_matrix[i-1][j-1]\n", " z1 = decode_matrix[i-1][j]\n", " z2 = decode_matrix[i-1][j+1]\n", " z3 = decode_matrix[i][j-1]\n", " y0 = int(-z0+z2-z3)\n", " y1 = int(z0+z1+z2)\n", " y2 = int(-z0-z1-z2-z3)\n", " y = np.vstack((y0,y1,y2))\n", " if use_diff:\n", " difference = max(z0,z1,z2,z3) - min(z0,z1,z2,z3)\n", " else:\n", " \n", " f, difference, rank, s = la.lstsq(points, [z0,z1,z2,z3], rcond=None) \n", " difference = difference.astype(int)\n", " \n", " predict = np.round(np.round(np.linalg.solve(A,y)[-1][0],1))\n", " \n", " # add on the difference by searching the dictionary\n", " # !!!!!WARNING!!!! has to change this part, eveytime you change the number of bins\n", " if difference <= bins[0]:\n", " error_matrix[i][j] = int(the_keys1[the_values1.index(encoded_matrix[i,j])]) + int(predict)\n", " decode_matrix[i][j] = int(the_keys1[the_values1.index(encoded_matrix[i,j])]) + int(predict)\n", " elif difference <= bins[1] and difference > bins[0]:\n", " error_matrix[i][j] = int(the_keys2[the_values2.index(encoded_matrix[i,j])]) + int(predict)\n", " decode_matrix[i][j] = int(the_keys2[the_values2.index(encoded_matrix[i,j])]) + int(predict)\n", " elif difference <= bins[2] and difference > bins[1]:\n", " error_matrix[i][j] = int(the_keys3[the_values3.index(encoded_matrix[i,j])]) + int(predict)\n", " decode_matrix[i][j] = int(the_keys3[the_values3.index(encoded_matrix[i,j])]) + int(predict)\n", " else:\n", " error_matrix[i][j] = int(the_keys4[the_values4.index(encoded_matrix[i,j])]) + int(predict)\n", " decode_matrix[i][j] = int(the_keys4[the_values4.index(encoded_matrix[i,j])]) + int(predict)\n", " \n", " \n", " return error_matrix.astype(int)" " return decode_matrix.astype(int)" ] }, { "cell_type": "code", "execution_count": 19, "execution_count": 74, "id": "f959fe93", "metadata": {}, "outputs": [], "source": [ "def compress_rate(image, error, diff, bound, list_dic, bins):\n", "def compress_rate(image, new_error, diff, bound, list_dic, bins):\n", " '''\n", " This function is used to calculate the compression rate.\n", " Input:\n", " image (512, 640): original image\n", " new_error (512, 640): error that includes the boundary\n", " diff (510, 638): difference of min and max of the 4 neighbors\n", " bound (2300,): the boundary values after subtracting the very first pixel value\n", " list_dic (num_dic + 1,): a list of huffman coding table \n", " bins (num_bins - 1,): a list of threshold to cut the bins\n", " \n", " Return:\n", " compression rate\n", " '''\n", " # the bits for the original image\n", " o_len = 0\n", " # the bits for the compressed image\n", " c_len = 0\n", " # initializing the varible \n", " im = np.reshape(image,(512, 640))\n", " real_b = np.hstack((im[0,:],im[-1,:],im[1:-1,0],im[1:-1,-1]))\n", " original = im[1:-1,1:-1].reshape(-1)\n", " real_b = np.hstack((image[0,:],image[-1,:],image[1:-1,0],image[1:-1,-1]))\n", " original = image[1:-1,1:-1].reshape(-1)\n", " diff = diff.reshape(-1)\n", " error = new_error[1:-1,1:-1].reshape(-1)\n", " \n", " # calculate the bit for boundary\n", " for i in range(0,len(bound)):\n", Loading @@ -426,6 +475,7 @@ " \n", " # calculate the bit for the pixels inside the boundary\n", " for i in range(0,len(original)):\n", "\n", " # for the original image\n", " o_len += len(bin(original[i])[2:])\n", " \n", Loading @@ -441,14 +491,14 @@ " c_len += len(list_dic[3][str(int(error[i]))])\n", "\n", " else: \n", " c_len += len(list_dic[5][str(int(error[i]))])\n", " c_len += len(list_dic[4][str(int(error[i]))])\n", "\n", " return c_len/o_len" ] }, { "cell_type": "code", "execution_count": 25, "execution_count": 80, "id": "3e0e9742", "metadata": {}, "outputs": [ Loading @@ -456,7 +506,6 @@ "name": "stdout", "output_type": "stream", "text": [ "(512, 640)\n", "True\n", "5\n" ] Loading @@ -465,30 +514,32 @@ "source": [ "scenes = file_extractor()\n", "images = image_extractor(scenes)\n", "list_dic, image, new_error, diff, bound, predict, bins, A = huffman(images[0], 4)\n", "list_dic, image, new_error, diff, bound, predict, bins, A = huffman(images[0], 4, False)\n", "encoded_matrix = encoder(new_error, list_dic, diff, bound, bins)\n", "reconstruct_image = decoder(A, encoded_matrix, list_dic, bins)\n", "reconstruct_image = decoder(A, encoded_matrix, list_dic, bins, False)\n", "print(np.allclose(image, reconstruct_image))\n", "print(len(list_dic))" ] }, { "cell_type": "code", "execution_count": 32, "execution_count": 81, "id": "004e8ba8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[26, 40, 62]\n" "data": { "text/plain": [ "0.4437662760416667" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\n", "print(bins)" "compress_rate(image, new_error, diff, bound, list_dic, bins)" ] }, { Loading Encoding_decoding.ipynb +53 −20 Original line number Diff line number Diff line %% Cell type:code id:14f74f21 tags: ``` python import numpy as np from matplotlib import pyplot as plt from itertools import product import os import sys from PIL import Image from scipy.optimize import minimize,linprog import time import seaborn as sns from sklearn.neighbors import KernelDensity import pandas as pd from collections import Counter import time import numpy.linalg as la ``` %% Cell type:code id:c16af61f tags: ``` python def file_extractor(dirname="images"): files = os.listdir(dirname) scenes = [] for file in files: if file == '.DS_Store': continue else: scenes.append(os.path.join(dirname, file)) return scenes def image_extractor(scenes): image_folder = [] for scene in scenes: files = os.listdir(scene) for file in files: #if file[-4:] == ".jp4" or file[-7:] == "_6.tiff": if file[-5:] != ".tiff" or file[-7:] == "_6.tiff": continue else: image_folder.append(os.path.join(scene, file)) return image_folder #returns a list of file paths to .tiff files in the specified directory given in file_extractor def im_distribution(images, num): """ Function that extracts tiff files from specific cameras and returns a list of all the tiff files corresponding to that camera. i.e. all pictures labeled "_7.tiff" or otherwise specified camera numbers. Parameters: images (list): list of all tiff files, regardless of classification. This is NOT a list of directories but of specific tiff files that can be opened right away. This is the list that we iterate through and divide. num (str): a string designation for the camera number that we want to extract i.e. "14" for double digits of "_1" for single digits. Returns: tiff (list): A list of tiff files that have the specified designation from num. They are the files extracted from the 'images' list that correspond to the given num. """ tiff = [] for im in images: if im[-7:-5] == num: tiff.append(im) return tiff ``` %% Cell type:code id:aceba613 tags: %% Cell type:code id:8172fa41 tags: ``` python def predict_pix(tiff_image): def predict_pix(tiff_image, difference = True): """ This function predict the pixel values excluding the boundary. Using the 4 neighbor pixel values and MSE to predict the next pixel value (-1,1) (0,1) (1,1) => relative position of the 4 other given values (-1,0) (0,0) => (0,0) is the one we want to predict take the derivative of mean square error to solve for the system of equation A = np.array([[3,0,-1],[0,3,3],[1,-3,-4]]) A @ [a, b, c] = [-z0+z2-z3, z0+z1+z2, -z0-z1-z2-z3] where z0 = (-1,1), z1 = (0,1), z2 = (1,1), z3 = (-1,0) and the predicted pixel value is c. Input: tiff_image (string): path to the tiff file Return: image (512 X 640): original image predict (325380,): predicted image exclude the boundary diff. (325380,): difference between the min and max of four neighbors exclude the boundary predict (325380,): predicted image excluding the boundary diff. (325380,): IF difference = TRUE, difference between the min and max of four neighbors exclude the boundary ELSE: the residuals of the four nearest pixels to a fitted hyperplane error (325380,): difference between the original image and predicted image A (3 X 3): system of equation """ image = Image.open(tiff_image) #Open the image and read it as an Image object image = np.array(image)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data image = image.astype(int) print(image.shape) # use A = np.array([[3,0,-1],[0,3,3],[1,-3,-4]]) # the matrix for system of equation # where z0 = (-1,1), z1 = (0,1), z2 = (1,1), z3 = (-1,0) z0 = image[0:-2,0:-2] # get all the first pixel for the entire image z1 = image[0:-2,1:-1] # get all the second pixel for the entire image z2 = image[0:-2,2::] # get all the third pixel for the entire image z3 = image[1:-1,0:-2] # get all the forth pixel for the entire image # calculate the out put of the system of equation y0 = np.ravel(-z0+z2-z3) y1 = np.ravel(z0+z1+z2) y2 = np.ravel(-z0-z1-z2-z3) y = np.vstack((y0,y1,y2)) # use numpy solver to solve the system of equations all at once #predict = np.floor(np.linalg.solve(A,y)[-1]) predict = np.round(np.round((np.linalg.solve(A,y)[-1]),1)) #Matrix system of points that will be used to solve the least squares fitting hyperplane points = np.array([[-1,-1,1], [-1,0,1], [-1,1,1], [0,-1,1]]) # flatten the neighbor pixlels and stack them together z0 = np.ravel(z0) z1 = np.ravel(z1) z2 = np.ravel(z2) z3 = np.ravel(z3) neighbor = np.vstack((z0,z1,z2,z3)).T # calculate the difference diff = np.max(neighbor,axis = 1) - np.min(neighbor, axis=1) if difference: # calculate the difference diff = np.max(neighbor,axis = 1) - np.min(neighbor, axis=1) else: #Compute the best fitting hyperplane using least squares #The res is the residuals of the four points used to fit the hyperplane (summed distance of each of the #points to the hyperplane), it is a measure of gradient f, diff, rank, s = la.lstsq(points, neighbor.T, rcond=None) diff = diff.astype(int) # calculate the error error = np.ravel(image[1:-1,1:-1])-predict return image, predict, diff, error, A ``` %% Cell type:code id:6b965751 tags: ``` python """ this huffman coding code is found online https://favtutor.com/blogs/huffman-coding """ class NodeTree(object): def __init__(self, left=None, right=None): self.left = left self.right = right def children(self): return self.left, self.right def __str__(self): return self.left, self.right def huffman_code_tree(node, binString=''): ''' Function to find Huffman Code ''' if type(node) is str: return {node: binString} (l, r) = node.children() d = dict() d.update(huffman_code_tree(l, binString + '0')) d.update(huffman_code_tree(r, binString + '1')) return d def make_tree(nodes): ''' Function to make tree :param nodes: Nodes :return: Root of the tree ''' while len(nodes) > 1: (key1, c1) = nodes[-1] (key2, c2) = nodes[-2] nodes = nodes[:-2] node = NodeTree(key1, key2) nodes.append((node, c1 + c2)) nodes = sorted(nodes, key=lambda x: x[1], reverse=True) return nodes[0][0] ``` %% Cell type:code id:b7561883 tags: ``` python def huffman(image, num_bins=4): def huffman(image, num_bins=4, difference = True): """ This function is used to encode the error based on the difference and split the difference into different bins Input: image (string): path to the tiff file num_bins (int): number of bins Return: list_dic (num_bins + 1): a list of dictionary image (512, 640): original image new_error (512, 640): error that includes the boundary diff (510, 638): difference of min and max of the 4 neighbors boundary (2300,): the boundary values after subtracting the very first pixel value predict (325380,): the list of predicted values bins (num_bins - 1,): a list of threshold to cut the bins A (3 X 3): system of equation """ # get the prediction error and difference image, predict, diff, error, A = predict_pix(image) image, predict, diff, error, A = predict_pix(image, difference) # get the number of points in each bins data_points_per_bin = len(diff) // num_bins # sort the difference and create the bins sorted_diff = diff.copy() sorted_diff.sort() bins = [sorted_diff[i*data_points_per_bin] for i in range(1,num_bins)] # get the boundary boundary = np.hstack((image[0,:],image[-1,:],image[1:-1,0],image[1:-1,-1])) # take the difference of the boundary with the very first pixel boundary = boundary - image[0,0] boundary[0] = image[0,0] # huffman encode the boundary string = [str(i) for i in boundary] freq = dict(Counter(string)) freq = sorted(freq.items(), key=lambda x: x[1], reverse=True) node = make_tree(freq) encode = huffman_code_tree(node) # create a list of huffman table list_dic = [encode] n = len(bins) # loop through different bins for i in range (0,n): # the fisrt bin if i == 0 : # get the point within the bin and huffman encode mask = diff <= bins[i] string = [str(i) for i in error[mask].astype(int)] freq = dict(Counter(string)) freq = sorted(freq.items(), key=lambda x: x[1], reverse=True) node = make_tree(freq) encode = huffman_code_tree(node) list_dic.append(encode) # the middle bins else: # get the point within the bin and huffman encode mask = diff > bins[i-1] new_error = error[mask] mask2 = diff[mask] <= bins[i] string = [str(i) for i in new_error[mask2].astype(int)] freq = dict(Counter(string)) freq = sorted(freq.items(), key=lambda x: x[1], reverse=True) node = make_tree(freq) encode = huffman_code_tree(node) list_dic.append(encode) # the last bin # get the point within the bin and huffman encode mask = diff > bins[-1] string = [str(i) for i in error[mask].astype(int)] freq = dict(Counter(string)) freq = sorted(freq.items(), key=lambda x: x[1], reverse=True) node = make_tree(freq) encode = huffman_code_tree(node) list_dic.append(encode) # create a error matrix that includes the boundary (used in encoding matrix) new_error = np.copy(image) new_error[1:-1,1:-1] = np.reshape(error,(510, 638)) keep = new_error[0,0] new_error[0,:] = new_error[0,:] - keep new_error[-1,:] = new_error[-1,:] - keep new_error[1:-1,0] = new_error[1:-1,0] - keep new_error[1:-1,-1] = new_error[1:-1,-1] - keep new_error[0,0] = keep diff = np.reshape(diff,(510,638)) # return the huffman dictionary return list_dic, image, new_error, diff, boundary, predict, bins, A ``` %% Cell type:code id:2eb774d2 tags: ``` python def encoder(error, list_dic, diff, bound, bins): """ This function encode the matrix with huffman coding tables Input: error (512, 640): a matrix with all the errors list_dic (num_dic + 1,): a list of huffman coding table bound (2300,): the boundary values after subtracting the very first pixel value bins (num_bins - 1,): a list of threshold to cut the bins Return: encoded (512, 640): encoded matrix """ # copy the error matrix (including the boundary) encoded = np.copy(error).astype(int).astype(str).astype(object) #diff = np.reshape(diff,(510,638)) # loop through all the pixel to encode for i in range(encoded.shape[0]): for j in range(encoded.shape[1]): if i == 0 or i == encoded.shape[0]-1 or j == 0 or j == encoded.shape[1]-1: encoded[i][j] = list_dic[0][encoded[i][j]] elif diff[i-1][j-1] <= bins[0]: encoded[i][j] = list_dic[1][encoded[i][j]] elif diff[i-1][j-1] <= bins[1] and diff[i-1][j-1] > bins[0]: encoded[i][j] = list_dic[2][encoded[i][j]] elif diff[i-1][j-1] <= bins[2] and diff[i-1][j-1] > bins[1]: encoded[i][j] = list_dic[3][encoded[i][j]] else: encoded[i][j] = list_dic[4][encoded[i][j]] return encoded ``` %% Cell type:code id:8eeb40d0 tags: ``` python def decoder(A, encoded_matrix, list_dic, bins): def decoder(A, encoded_matrix, list_dic, bins, use_diff): """ This function decodes the encoded_matrix. Input: A (3 X 3): system of equation list_dic (num_dic + 1,): a list of huffman coding table encoded_matrix (512, 640): encoded matrix bins (num_bins - 1,): a list of threshold to cut the bins Return: decode_matrix (512, 640): decoded matrix """ # change the dictionary back to list # !!!!!WARNING!!!! has to change this part, eveytime you change the number of bins the_keys0 = list(list_dic[0].keys()) the_values0 = list(list_dic[0].values()) the_keys1 = list(list_dic[1].keys()) the_values1 = list(list_dic[1].values()) the_keys2 = list(list_dic[2].keys()) the_values2 = list(list_dic[2].values()) the_keys3 = list(list_dic[3].keys()) the_values3 = list(list_dic[3].values()) the_keys4 = list(list_dic[4].keys()) the_values4 = list(list_dic[4].values()) #Matrix system of points that will be used to solve the least squares fitting hyperplane points = np.array([[-1,-1,1], [-1,0,1], [-1,1,1], [0,-1,1]]) decode_matrix = np.zeros((512,640)) # loop through all the element in the matrix for i in range(decode_matrix.shape[0]): for j in range(decode_matrix.shape[1]): # if it's the very first pixel on the image if i == 0 and j == 0: decode_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])]) # if it's on the boundary elif i == 0 or i == decode_matrix.shape[0]-1 or j == 0 or j == decode_matrix.shape[1]-1: decode_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])]) + decode_matrix[0][0] # if not the boundary else: # predict the image with the known pixel value z0 = decode_matrix[i-1][j-1] z1 = decode_matrix[i-1][j] z2 = decode_matrix[i-1][j+1] z3 = decode_matrix[i][j-1] y0 = int(-z0+z2-z3) y1 = int(z0+z1+z2) y2 = int(-z0-z1-z2-z3) y = np.vstack((y0,y1,y2)) difference = max(z0,z1,z2,z3) - min(z0,z1,z2,z3) if use_diff: difference = max(z0,z1,z2,z3) - min(z0,z1,z2,z3) else: f, difference, rank, s = la.lstsq(points, [z0,z1,z2,z3], rcond=None) difference = difference.astype(int) predict = np.round(np.round(np.linalg.solve(A,y)[-1][0],1)) # add on the difference by searching the dictionary # !!!!!WARNING!!!! has to change this part, eveytime you change the number of bins if difference <= bins[0]: decode_matrix[i][j] = int(the_keys1[the_values1.index(encoded_matrix[i,j])]) + int(predict) elif difference <= bins[1] and difference > bins[0]: decode_matrix[i][j] = int(the_keys2[the_values2.index(encoded_matrix[i,j])]) + int(predict) elif difference <= bins[2] and difference > bins[1]: decode_matrix[i][j] = int(the_keys3[the_values3.index(encoded_matrix[i,j])]) + int(predict) else: decode_matrix[i][j] = int(the_keys4[the_values4.index(encoded_matrix[i,j])]) + int(predict) return decode_matrix.astype(int) ``` %% Cell type:code id:f959fe93 tags: ``` python def compress_rate(image, error, diff, bound, list_dic, bins): def compress_rate(image, new_error, diff, bound, list_dic, bins): ''' This function is used to calculate the compression rate. Input: image (512, 640): original image new_error (512, 640): error that includes the boundary diff (510, 638): difference of min and max of the 4 neighbors bound (2300,): the boundary values after subtracting the very first pixel value list_dic (num_dic + 1,): a list of huffman coding table bins (num_bins - 1,): a list of threshold to cut the bins Return: compression rate ''' # the bits for the original image o_len = 0 # the bits for the compressed image c_len = 0 # initializing the varible im = np.reshape(image,(512, 640)) real_b = np.hstack((image[0,:],image[-1,:],image[1:-1,0],image[1:-1,-1])) original = image[1:-1,1:-1].reshape(-1) diff = diff.reshape(-1) error = new_error[1:-1,1:-1].reshape(-1) # calculate the bit for boundary for i in range(0,len(bound)): o_len += len(bin(real_b[i])[2:]) c_len += len(list_dic[0][str(bound[i])]) # calculate the bit for the pixels inside the boundary for i in range(0,len(original)): # for the original image o_len += len(bin(original[i])[2:]) # check the difference and find the coresponding huffman table # !!!!!WARNING!!!! has to change this part, eveytime you change the number of bins if diff[i] <= bins[0]: c_len += len(list_dic[1][str(int(error[i]))]) elif diff[i] <= bins[1] and diff[i] > bins[0]: c_len += len(list_dic[2][str(int(error[i]))]) elif diff[i] <= bins[2] and diff[i] > bins[1]: c_len += len(list_dic[3][str(int(error[i]))]) else: c_len += len(list_dic[5][str(int(error[i]))]) c_len += len(list_dic[4][str(int(error[i]))]) return c_len/o_len ``` %% Cell type:code id:3e0e9742 tags: ``` python scenes = file_extractor() images = image_extractor(scenes) list_dic, image, new_error, diff, bound, predict, bins, A = huffman(images[0], 4) list_dic, image, new_error, diff, bound, predict, bins, A = huffman(images[0], 4, False) encoded_matrix = encoder(new_error, list_dic, diff, bound, bins) reconstruct_image = decoder(A, encoded_matrix, list_dic, bins) reconstruct_image = decoder(A, encoded_matrix, list_dic, bins, False) print(np.allclose(image, reconstruct_image)) print(len(list_dic)) ``` %% Output (512, 640) True 5 %% Cell type:code id:004e8ba8 tags: ``` python print(encoded_matrix.shape) compress_rate(image, new_error, diff, bound, list_dic, bins) ``` %% Output (512, 640) 0.4437662760416667 %% Cell type:code id:a282f9e6 tags: ``` python ``` Loading
.DS_Store (8 KiB) File changed.No diff preview for this file type. View original file View changed file
.ipynb_checkpoints/Encoding_decoding-checkpoint.ipynb +112 −61 Original line number Diff line number Diff line Loading @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", "execution_count": 12, "execution_count": 59, "id": "14f74f21", "metadata": {}, "outputs": [], Loading @@ -19,12 +19,13 @@ "from sklearn.neighbors import KernelDensity\n", "import pandas as pd\n", "from collections import Counter\n", "import time" "import time\n", "import numpy.linalg as la" ] }, { "cell_type": "code", "execution_count": 13, "execution_count": 49, "id": "c16af61f", "metadata": {}, "outputs": [], Loading Loading @@ -78,12 +79,12 @@ }, { "cell_type": "code", "execution_count": 14, "id": "aceba613", "execution_count": 61, "id": "8172fa41", "metadata": {}, "outputs": [], "source": [ "def predict_pix(tiff_image):\n", "def predict_pix(tiff_image, difference = True):\n", " \"\"\"\n", " This function predict the pixel values excluding the boundary.\n", " Using the 4 neighbor pixel values and MSE to predict the next pixel value\n", Loading @@ -99,16 +100,15 @@ " \n", " Return:\n", " image (512 X 640): original image \n", " predict (325380,): predicted image exclude the boundary\n", " diff. (325380,): difference between the min and max of four neighbors exclude the boundary\n", " predict (325380,): predicted image excluding the boundary\n", " diff. (325380,): IF difference = TRUE, difference between the min and max of four neighbors exclude the boundary\n", " ELSE: the residuals of the four nearest pixels to a fitted hyperplane\n", " error (325380,): difference between the original image and predicted image\n", " A (3 X 3): system of equation\n", " \"\"\"\n", " image = Image.open(tiff_image) #Open the image and read it as an Image object\n", " image = np.array(image)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data\n", " image = image.astype(int) \n", " print(image.shape)\n", " # use \n", " A = np.array([[3,0,-1],[0,3,3],[1,-3,-4]]) # the matrix for system of equation\n", " # where z0 = (-1,1), z1 = (0,1), z2 = (1,1), z3 = (-1,0)\n", " z0 = image[0:-2,0:-2] # get all the first pixel for the entire image\n", Loading @@ -123,23 +123,37 @@ " # use numpy solver to solve the system of equations all at once\n", " #predict = np.floor(np.linalg.solve(A,y)[-1])\n", " predict = np.round(np.round((np.linalg.solve(A,y)[-1]),1))\n", " \n", " #Matrix system of points that will be used to solve the least squares fitting hyperplane\n", " points = np.array([[-1,-1,1], [-1,0,1], [-1,1,1], [0,-1,1]])\n", " \n", " # flatten the neighbor pixlels and stack them together\n", " z0 = np.ravel(z0)\n", " z1 = np.ravel(z1)\n", " z2 = np.ravel(z2)\n", " z3 = np.ravel(z3)\n", " neighbor = np.vstack((z0,z1,z2,z3)).T\n", " \n", " if difference:\n", " # calculate the difference\n", " diff = np.max(neighbor,axis = 1) - np.min(neighbor, axis=1)\n", " \n", " else:\n", " #Compute the best fitting hyperplane using least squares\n", " #The res is the residuals of the four points used to fit the hyperplane (summed distance of each of the \n", " #points to the hyperplane), it is a measure of gradient\n", " f, diff, rank, s = la.lstsq(points, neighbor.T, rcond=None) \n", " diff = diff.astype(int)\n", " \n", " # calculate the error\n", " error = np.ravel(image[1:-1,1:-1])-predict\n", " \n", " return image, predict, diff, error, A\n" " return image, predict, diff, error, A" ] }, { "cell_type": "code", "execution_count": 15, "execution_count": 62, "id": "6b965751", "metadata": {}, "outputs": [], Loading Loading @@ -192,12 +206,12 @@ }, { "cell_type": "code", "execution_count": 24, "execution_count": 63, "id": "b7561883", "metadata": {}, "outputs": [], "source": [ "def huffman(image, num_bins=4):\n", "def huffman(image, num_bins=4, difference = True):\n", " \"\"\"\n", " This function is used to encode the error based on the difference\n", " and split the difference into different bins\n", Loading @@ -218,7 +232,7 @@ " \n", " \"\"\"\n", " # get the prediction error and difference\n", " image, predict, diff, error, A = predict_pix(image)\n", " image, predict, diff, error, A = predict_pix(image, difference)\n", " \n", " # get the number of points in each bins\n", " data_points_per_bin = len(diff) // num_bins\n", Loading Loading @@ -300,18 +314,23 @@ }, { "cell_type": "code", "execution_count": 17, "execution_count": 64, "id": "2eb774d2", "metadata": {}, "outputs": [], "source": [ "def encoder(error, list_dic, diff, bound, bins):\n", " \"\"\"\n", <<<<<<< HEAD " This function en\n", ======= " This function \n", >>>>>>> a352868acf14cebeaa7ea2a58e879b1d36b066ad " This function encode the matrix with huffman coding tables\n", " \n", " Input:\n", " error (512, 640): a matrix with all the errors\n", " list_dic (num_dic + 1,): a list of huffman coding table \n", " bound (2300,): the boundary values after subtracting the very first pixel value\n", " bins (num_bins - 1,): a list of threshold to cut the bins\n", " \n", " Return:\n", " encoded (512, 640): encoded matrix\n", " \"\"\"\n", " # copy the error matrix (including the boundary)\n", " encoded = np.copy(error).astype(int).astype(str).astype(object)\n", Loading @@ -335,15 +354,22 @@ }, { "cell_type": "code", "execution_count": 23, "execution_count": 79, "id": "8eeb40d0", "metadata": {}, "outputs": [], "source": [ "def decoder(A, encoded_matrix, list_dic, bins):\n", "def decoder(A, encoded_matrix, list_dic, bins, use_diff):\n", " \"\"\"\n", " Function that accecpts the prediction matrix A for the linear system,\n", " the encoded matrix of error values, and the encoding dicitonary.\n", " This function decodes the encoded_matrix.\n", " Input:\n", " A (3 X 3): system of equation\n", " list_dic (num_dic + 1,): a list of huffman coding table \n", " encoded_matrix (512, 640): encoded matrix\n", " bins (num_bins - 1,): a list of threshold to cut the bins\n", " \n", " Return:\n", " decode_matrix (512, 640): decoded matrix\n", " \"\"\"\n", " # change the dictionary back to list\n", " # !!!!!WARNING!!!! has to change this part, eveytime you change the number of bins\n", Loading @@ -362,62 +388,85 @@ " the_keys4 = list(list_dic[4].keys())\n", " the_values4 = list(list_dic[4].values())\n", " \n", " error_matrix = np.zeros((512,640))\n", " #Matrix system of points that will be used to solve the least squares fitting hyperplane\n", " points = np.array([[-1,-1,1], [-1,0,1], [-1,1,1], [0,-1,1]])\n", " \n", " decode_matrix = np.zeros((512,640))\n", " # loop through all the element in the matrix\n", " for i in range(error_matrix.shape[0]):\n", " for j in range(error_matrix.shape[1]):\n", " for i in range(decode_matrix.shape[0]):\n", " for j in range(decode_matrix.shape[1]):\n", " # if it's the very first pixel on the image\n", " if i == 0 and j == 0:\n", " error_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])])\n", " decode_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])])\n", " # if it's on the boundary\n", " elif i == 0 or i == error_matrix.shape[0]-1 or j == 0 or j == error_matrix.shape[1]-1:\n", " error_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])]) + error_matrix[0][0]\n", " elif i == 0 or i == decode_matrix.shape[0]-1 or j == 0 or j == decode_matrix.shape[1]-1:\n", " decode_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])]) + decode_matrix[0][0]\n", " # if not the boundary\n", " else:\n", " # predict the image with the known pixel value\n", " z0 = error_matrix[i-1][j-1]\n", " z1 = error_matrix[i-1][j]\n", " z2 = error_matrix[i-1][j+1]\n", " z3 = error_matrix[i][j-1]\n", " z0 = decode_matrix[i-1][j-1]\n", " z1 = decode_matrix[i-1][j]\n", " z2 = decode_matrix[i-1][j+1]\n", " z3 = decode_matrix[i][j-1]\n", " y0 = int(-z0+z2-z3)\n", " y1 = int(z0+z1+z2)\n", " y2 = int(-z0-z1-z2-z3)\n", " y = np.vstack((y0,y1,y2))\n", " if use_diff:\n", " difference = max(z0,z1,z2,z3) - min(z0,z1,z2,z3)\n", " else:\n", " \n", " f, difference, rank, s = la.lstsq(points, [z0,z1,z2,z3], rcond=None) \n", " difference = difference.astype(int)\n", " \n", " predict = np.round(np.round(np.linalg.solve(A,y)[-1][0],1))\n", " \n", " # add on the difference by searching the dictionary\n", " # !!!!!WARNING!!!! has to change this part, eveytime you change the number of bins\n", " if difference <= bins[0]:\n", " error_matrix[i][j] = int(the_keys1[the_values1.index(encoded_matrix[i,j])]) + int(predict)\n", " decode_matrix[i][j] = int(the_keys1[the_values1.index(encoded_matrix[i,j])]) + int(predict)\n", " elif difference <= bins[1] and difference > bins[0]:\n", " error_matrix[i][j] = int(the_keys2[the_values2.index(encoded_matrix[i,j])]) + int(predict)\n", " decode_matrix[i][j] = int(the_keys2[the_values2.index(encoded_matrix[i,j])]) + int(predict)\n", " elif difference <= bins[2] and difference > bins[1]:\n", " error_matrix[i][j] = int(the_keys3[the_values3.index(encoded_matrix[i,j])]) + int(predict)\n", " decode_matrix[i][j] = int(the_keys3[the_values3.index(encoded_matrix[i,j])]) + int(predict)\n", " else:\n", " error_matrix[i][j] = int(the_keys4[the_values4.index(encoded_matrix[i,j])]) + int(predict)\n", " decode_matrix[i][j] = int(the_keys4[the_values4.index(encoded_matrix[i,j])]) + int(predict)\n", " \n", " \n", " return error_matrix.astype(int)" " return decode_matrix.astype(int)" ] }, { "cell_type": "code", "execution_count": 19, "execution_count": 74, "id": "f959fe93", "metadata": {}, "outputs": [], "source": [ "def compress_rate(image, error, diff, bound, list_dic, bins):\n", "def compress_rate(image, new_error, diff, bound, list_dic, bins):\n", " '''\n", " This function is used to calculate the compression rate.\n", " Input:\n", " image (512, 640): original image\n", " new_error (512, 640): error that includes the boundary\n", " diff (510, 638): difference of min and max of the 4 neighbors\n", " bound (2300,): the boundary values after subtracting the very first pixel value\n", " list_dic (num_dic + 1,): a list of huffman coding table \n", " bins (num_bins - 1,): a list of threshold to cut the bins\n", " \n", " Return:\n", " compression rate\n", " '''\n", " # the bits for the original image\n", " o_len = 0\n", " # the bits for the compressed image\n", " c_len = 0\n", " # initializing the varible \n", " im = np.reshape(image,(512, 640))\n", " real_b = np.hstack((im[0,:],im[-1,:],im[1:-1,0],im[1:-1,-1]))\n", " original = im[1:-1,1:-1].reshape(-1)\n", " real_b = np.hstack((image[0,:],image[-1,:],image[1:-1,0],image[1:-1,-1]))\n", " original = image[1:-1,1:-1].reshape(-1)\n", " diff = diff.reshape(-1)\n", " error = new_error[1:-1,1:-1].reshape(-1)\n", " \n", " # calculate the bit for boundary\n", " for i in range(0,len(bound)):\n", Loading @@ -426,6 +475,7 @@ " \n", " # calculate the bit for the pixels inside the boundary\n", " for i in range(0,len(original)):\n", "\n", " # for the original image\n", " o_len += len(bin(original[i])[2:])\n", " \n", Loading @@ -441,14 +491,14 @@ " c_len += len(list_dic[3][str(int(error[i]))])\n", "\n", " else: \n", " c_len += len(list_dic[5][str(int(error[i]))])\n", " c_len += len(list_dic[4][str(int(error[i]))])\n", "\n", " return c_len/o_len" ] }, { "cell_type": "code", "execution_count": 25, "execution_count": 80, "id": "3e0e9742", "metadata": {}, "outputs": [ Loading @@ -456,7 +506,6 @@ "name": "stdout", "output_type": "stream", "text": [ "(512, 640)\n", "True\n", "5\n" ] Loading @@ -465,30 +514,32 @@ "source": [ "scenes = file_extractor()\n", "images = image_extractor(scenes)\n", "list_dic, image, new_error, diff, bound, predict, bins, A = huffman(images[0], 4)\n", "list_dic, image, new_error, diff, bound, predict, bins, A = huffman(images[0], 4, False)\n", "encoded_matrix = encoder(new_error, list_dic, diff, bound, bins)\n", "reconstruct_image = decoder(A, encoded_matrix, list_dic, bins)\n", "reconstruct_image = decoder(A, encoded_matrix, list_dic, bins, False)\n", "print(np.allclose(image, reconstruct_image))\n", "print(len(list_dic))" ] }, { "cell_type": "code", "execution_count": 32, "execution_count": 81, "id": "004e8ba8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[26, 40, 62]\n" "data": { "text/plain": [ "0.4437662760416667" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\n", "print(bins)" "compress_rate(image, new_error, diff, bound, list_dic, bins)" ] }, { Loading
Encoding_decoding.ipynb +53 −20 Original line number Diff line number Diff line %% Cell type:code id:14f74f21 tags: ``` python import numpy as np from matplotlib import pyplot as plt from itertools import product import os import sys from PIL import Image from scipy.optimize import minimize,linprog import time import seaborn as sns from sklearn.neighbors import KernelDensity import pandas as pd from collections import Counter import time import numpy.linalg as la ``` %% Cell type:code id:c16af61f tags: ``` python def file_extractor(dirname="images"): files = os.listdir(dirname) scenes = [] for file in files: if file == '.DS_Store': continue else: scenes.append(os.path.join(dirname, file)) return scenes def image_extractor(scenes): image_folder = [] for scene in scenes: files = os.listdir(scene) for file in files: #if file[-4:] == ".jp4" or file[-7:] == "_6.tiff": if file[-5:] != ".tiff" or file[-7:] == "_6.tiff": continue else: image_folder.append(os.path.join(scene, file)) return image_folder #returns a list of file paths to .tiff files in the specified directory given in file_extractor def im_distribution(images, num): """ Function that extracts tiff files from specific cameras and returns a list of all the tiff files corresponding to that camera. i.e. all pictures labeled "_7.tiff" or otherwise specified camera numbers. Parameters: images (list): list of all tiff files, regardless of classification. This is NOT a list of directories but of specific tiff files that can be opened right away. This is the list that we iterate through and divide. num (str): a string designation for the camera number that we want to extract i.e. "14" for double digits of "_1" for single digits. Returns: tiff (list): A list of tiff files that have the specified designation from num. They are the files extracted from the 'images' list that correspond to the given num. """ tiff = [] for im in images: if im[-7:-5] == num: tiff.append(im) return tiff ``` %% Cell type:code id:aceba613 tags: %% Cell type:code id:8172fa41 tags: ``` python def predict_pix(tiff_image): def predict_pix(tiff_image, difference = True): """ This function predict the pixel values excluding the boundary. Using the 4 neighbor pixel values and MSE to predict the next pixel value (-1,1) (0,1) (1,1) => relative position of the 4 other given values (-1,0) (0,0) => (0,0) is the one we want to predict take the derivative of mean square error to solve for the system of equation A = np.array([[3,0,-1],[0,3,3],[1,-3,-4]]) A @ [a, b, c] = [-z0+z2-z3, z0+z1+z2, -z0-z1-z2-z3] where z0 = (-1,1), z1 = (0,1), z2 = (1,1), z3 = (-1,0) and the predicted pixel value is c. Input: tiff_image (string): path to the tiff file Return: image (512 X 640): original image predict (325380,): predicted image exclude the boundary diff. (325380,): difference between the min and max of four neighbors exclude the boundary predict (325380,): predicted image excluding the boundary diff. (325380,): IF difference = TRUE, difference between the min and max of four neighbors exclude the boundary ELSE: the residuals of the four nearest pixels to a fitted hyperplane error (325380,): difference between the original image and predicted image A (3 X 3): system of equation """ image = Image.open(tiff_image) #Open the image and read it as an Image object image = np.array(image)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data image = image.astype(int) print(image.shape) # use A = np.array([[3,0,-1],[0,3,3],[1,-3,-4]]) # the matrix for system of equation # where z0 = (-1,1), z1 = (0,1), z2 = (1,1), z3 = (-1,0) z0 = image[0:-2,0:-2] # get all the first pixel for the entire image z1 = image[0:-2,1:-1] # get all the second pixel for the entire image z2 = image[0:-2,2::] # get all the third pixel for the entire image z3 = image[1:-1,0:-2] # get all the forth pixel for the entire image # calculate the out put of the system of equation y0 = np.ravel(-z0+z2-z3) y1 = np.ravel(z0+z1+z2) y2 = np.ravel(-z0-z1-z2-z3) y = np.vstack((y0,y1,y2)) # use numpy solver to solve the system of equations all at once #predict = np.floor(np.linalg.solve(A,y)[-1]) predict = np.round(np.round((np.linalg.solve(A,y)[-1]),1)) #Matrix system of points that will be used to solve the least squares fitting hyperplane points = np.array([[-1,-1,1], [-1,0,1], [-1,1,1], [0,-1,1]]) # flatten the neighbor pixlels and stack them together z0 = np.ravel(z0) z1 = np.ravel(z1) z2 = np.ravel(z2) z3 = np.ravel(z3) neighbor = np.vstack((z0,z1,z2,z3)).T # calculate the difference diff = np.max(neighbor,axis = 1) - np.min(neighbor, axis=1) if difference: # calculate the difference diff = np.max(neighbor,axis = 1) - np.min(neighbor, axis=1) else: #Compute the best fitting hyperplane using least squares #The res is the residuals of the four points used to fit the hyperplane (summed distance of each of the #points to the hyperplane), it is a measure of gradient f, diff, rank, s = la.lstsq(points, neighbor.T, rcond=None) diff = diff.astype(int) # calculate the error error = np.ravel(image[1:-1,1:-1])-predict return image, predict, diff, error, A ``` %% Cell type:code id:6b965751 tags: ``` python """ this huffman coding code is found online https://favtutor.com/blogs/huffman-coding """ class NodeTree(object): def __init__(self, left=None, right=None): self.left = left self.right = right def children(self): return self.left, self.right def __str__(self): return self.left, self.right def huffman_code_tree(node, binString=''): ''' Function to find Huffman Code ''' if type(node) is str: return {node: binString} (l, r) = node.children() d = dict() d.update(huffman_code_tree(l, binString + '0')) d.update(huffman_code_tree(r, binString + '1')) return d def make_tree(nodes): ''' Function to make tree :param nodes: Nodes :return: Root of the tree ''' while len(nodes) > 1: (key1, c1) = nodes[-1] (key2, c2) = nodes[-2] nodes = nodes[:-2] node = NodeTree(key1, key2) nodes.append((node, c1 + c2)) nodes = sorted(nodes, key=lambda x: x[1], reverse=True) return nodes[0][0] ``` %% Cell type:code id:b7561883 tags: ``` python def huffman(image, num_bins=4): def huffman(image, num_bins=4, difference = True): """ This function is used to encode the error based on the difference and split the difference into different bins Input: image (string): path to the tiff file num_bins (int): number of bins Return: list_dic (num_bins + 1): a list of dictionary image (512, 640): original image new_error (512, 640): error that includes the boundary diff (510, 638): difference of min and max of the 4 neighbors boundary (2300,): the boundary values after subtracting the very first pixel value predict (325380,): the list of predicted values bins (num_bins - 1,): a list of threshold to cut the bins A (3 X 3): system of equation """ # get the prediction error and difference image, predict, diff, error, A = predict_pix(image) image, predict, diff, error, A = predict_pix(image, difference) # get the number of points in each bins data_points_per_bin = len(diff) // num_bins # sort the difference and create the bins sorted_diff = diff.copy() sorted_diff.sort() bins = [sorted_diff[i*data_points_per_bin] for i in range(1,num_bins)] # get the boundary boundary = np.hstack((image[0,:],image[-1,:],image[1:-1,0],image[1:-1,-1])) # take the difference of the boundary with the very first pixel boundary = boundary - image[0,0] boundary[0] = image[0,0] # huffman encode the boundary string = [str(i) for i in boundary] freq = dict(Counter(string)) freq = sorted(freq.items(), key=lambda x: x[1], reverse=True) node = make_tree(freq) encode = huffman_code_tree(node) # create a list of huffman table list_dic = [encode] n = len(bins) # loop through different bins for i in range (0,n): # the fisrt bin if i == 0 : # get the point within the bin and huffman encode mask = diff <= bins[i] string = [str(i) for i in error[mask].astype(int)] freq = dict(Counter(string)) freq = sorted(freq.items(), key=lambda x: x[1], reverse=True) node = make_tree(freq) encode = huffman_code_tree(node) list_dic.append(encode) # the middle bins else: # get the point within the bin and huffman encode mask = diff > bins[i-1] new_error = error[mask] mask2 = diff[mask] <= bins[i] string = [str(i) for i in new_error[mask2].astype(int)] freq = dict(Counter(string)) freq = sorted(freq.items(), key=lambda x: x[1], reverse=True) node = make_tree(freq) encode = huffman_code_tree(node) list_dic.append(encode) # the last bin # get the point within the bin and huffman encode mask = diff > bins[-1] string = [str(i) for i in error[mask].astype(int)] freq = dict(Counter(string)) freq = sorted(freq.items(), key=lambda x: x[1], reverse=True) node = make_tree(freq) encode = huffman_code_tree(node) list_dic.append(encode) # create a error matrix that includes the boundary (used in encoding matrix) new_error = np.copy(image) new_error[1:-1,1:-1] = np.reshape(error,(510, 638)) keep = new_error[0,0] new_error[0,:] = new_error[0,:] - keep new_error[-1,:] = new_error[-1,:] - keep new_error[1:-1,0] = new_error[1:-1,0] - keep new_error[1:-1,-1] = new_error[1:-1,-1] - keep new_error[0,0] = keep diff = np.reshape(diff,(510,638)) # return the huffman dictionary return list_dic, image, new_error, diff, boundary, predict, bins, A ``` %% Cell type:code id:2eb774d2 tags: ``` python def encoder(error, list_dic, diff, bound, bins): """ This function encode the matrix with huffman coding tables Input: error (512, 640): a matrix with all the errors list_dic (num_dic + 1,): a list of huffman coding table bound (2300,): the boundary values after subtracting the very first pixel value bins (num_bins - 1,): a list of threshold to cut the bins Return: encoded (512, 640): encoded matrix """ # copy the error matrix (including the boundary) encoded = np.copy(error).astype(int).astype(str).astype(object) #diff = np.reshape(diff,(510,638)) # loop through all the pixel to encode for i in range(encoded.shape[0]): for j in range(encoded.shape[1]): if i == 0 or i == encoded.shape[0]-1 or j == 0 or j == encoded.shape[1]-1: encoded[i][j] = list_dic[0][encoded[i][j]] elif diff[i-1][j-1] <= bins[0]: encoded[i][j] = list_dic[1][encoded[i][j]] elif diff[i-1][j-1] <= bins[1] and diff[i-1][j-1] > bins[0]: encoded[i][j] = list_dic[2][encoded[i][j]] elif diff[i-1][j-1] <= bins[2] and diff[i-1][j-1] > bins[1]: encoded[i][j] = list_dic[3][encoded[i][j]] else: encoded[i][j] = list_dic[4][encoded[i][j]] return encoded ``` %% Cell type:code id:8eeb40d0 tags: ``` python def decoder(A, encoded_matrix, list_dic, bins): def decoder(A, encoded_matrix, list_dic, bins, use_diff): """ This function decodes the encoded_matrix. Input: A (3 X 3): system of equation list_dic (num_dic + 1,): a list of huffman coding table encoded_matrix (512, 640): encoded matrix bins (num_bins - 1,): a list of threshold to cut the bins Return: decode_matrix (512, 640): decoded matrix """ # change the dictionary back to list # !!!!!WARNING!!!! has to change this part, eveytime you change the number of bins the_keys0 = list(list_dic[0].keys()) the_values0 = list(list_dic[0].values()) the_keys1 = list(list_dic[1].keys()) the_values1 = list(list_dic[1].values()) the_keys2 = list(list_dic[2].keys()) the_values2 = list(list_dic[2].values()) the_keys3 = list(list_dic[3].keys()) the_values3 = list(list_dic[3].values()) the_keys4 = list(list_dic[4].keys()) the_values4 = list(list_dic[4].values()) #Matrix system of points that will be used to solve the least squares fitting hyperplane points = np.array([[-1,-1,1], [-1,0,1], [-1,1,1], [0,-1,1]]) decode_matrix = np.zeros((512,640)) # loop through all the element in the matrix for i in range(decode_matrix.shape[0]): for j in range(decode_matrix.shape[1]): # if it's the very first pixel on the image if i == 0 and j == 0: decode_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])]) # if it's on the boundary elif i == 0 or i == decode_matrix.shape[0]-1 or j == 0 or j == decode_matrix.shape[1]-1: decode_matrix[i][j] = int(the_keys0[the_values0.index(encoded_matrix[i,j])]) + decode_matrix[0][0] # if not the boundary else: # predict the image with the known pixel value z0 = decode_matrix[i-1][j-1] z1 = decode_matrix[i-1][j] z2 = decode_matrix[i-1][j+1] z3 = decode_matrix[i][j-1] y0 = int(-z0+z2-z3) y1 = int(z0+z1+z2) y2 = int(-z0-z1-z2-z3) y = np.vstack((y0,y1,y2)) difference = max(z0,z1,z2,z3) - min(z0,z1,z2,z3) if use_diff: difference = max(z0,z1,z2,z3) - min(z0,z1,z2,z3) else: f, difference, rank, s = la.lstsq(points, [z0,z1,z2,z3], rcond=None) difference = difference.astype(int) predict = np.round(np.round(np.linalg.solve(A,y)[-1][0],1)) # add on the difference by searching the dictionary # !!!!!WARNING!!!! has to change this part, eveytime you change the number of bins if difference <= bins[0]: decode_matrix[i][j] = int(the_keys1[the_values1.index(encoded_matrix[i,j])]) + int(predict) elif difference <= bins[1] and difference > bins[0]: decode_matrix[i][j] = int(the_keys2[the_values2.index(encoded_matrix[i,j])]) + int(predict) elif difference <= bins[2] and difference > bins[1]: decode_matrix[i][j] = int(the_keys3[the_values3.index(encoded_matrix[i,j])]) + int(predict) else: decode_matrix[i][j] = int(the_keys4[the_values4.index(encoded_matrix[i,j])]) + int(predict) return decode_matrix.astype(int) ``` %% Cell type:code id:f959fe93 tags: ``` python def compress_rate(image, error, diff, bound, list_dic, bins): def compress_rate(image, new_error, diff, bound, list_dic, bins): ''' This function is used to calculate the compression rate. Input: image (512, 640): original image new_error (512, 640): error that includes the boundary diff (510, 638): difference of min and max of the 4 neighbors bound (2300,): the boundary values after subtracting the very first pixel value list_dic (num_dic + 1,): a list of huffman coding table bins (num_bins - 1,): a list of threshold to cut the bins Return: compression rate ''' # the bits for the original image o_len = 0 # the bits for the compressed image c_len = 0 # initializing the varible im = np.reshape(image,(512, 640)) real_b = np.hstack((image[0,:],image[-1,:],image[1:-1,0],image[1:-1,-1])) original = image[1:-1,1:-1].reshape(-1) diff = diff.reshape(-1) error = new_error[1:-1,1:-1].reshape(-1) # calculate the bit for boundary for i in range(0,len(bound)): o_len += len(bin(real_b[i])[2:]) c_len += len(list_dic[0][str(bound[i])]) # calculate the bit for the pixels inside the boundary for i in range(0,len(original)): # for the original image o_len += len(bin(original[i])[2:]) # check the difference and find the coresponding huffman table # !!!!!WARNING!!!! has to change this part, eveytime you change the number of bins if diff[i] <= bins[0]: c_len += len(list_dic[1][str(int(error[i]))]) elif diff[i] <= bins[1] and diff[i] > bins[0]: c_len += len(list_dic[2][str(int(error[i]))]) elif diff[i] <= bins[2] and diff[i] > bins[1]: c_len += len(list_dic[3][str(int(error[i]))]) else: c_len += len(list_dic[5][str(int(error[i]))]) c_len += len(list_dic[4][str(int(error[i]))]) return c_len/o_len ``` %% Cell type:code id:3e0e9742 tags: ``` python scenes = file_extractor() images = image_extractor(scenes) list_dic, image, new_error, diff, bound, predict, bins, A = huffman(images[0], 4) list_dic, image, new_error, diff, bound, predict, bins, A = huffman(images[0], 4, False) encoded_matrix = encoder(new_error, list_dic, diff, bound, bins) reconstruct_image = decoder(A, encoded_matrix, list_dic, bins) reconstruct_image = decoder(A, encoded_matrix, list_dic, bins, False) print(np.allclose(image, reconstruct_image)) print(len(list_dic)) ``` %% Output (512, 640) True 5 %% Cell type:code id:004e8ba8 tags: ``` python print(encoded_matrix.shape) compress_rate(image, new_error, diff, bound, list_dic, bins) ``` %% Output (512, 640) 0.4437662760416667 %% Cell type:code id:a282f9e6 tags: ``` python ```
