end of day

ErrorImageCreator.py

+from turtle import color
+from WorkingPyDemo import *
+def produce_error_array(encoded_string, 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_matrix = np.zeros((512,640))
+    A = np.array([[3,0,-1],[0,3,3],[1,-3,-4]]) # the matrix for system of equation
+    # change the dictionary back to list
+    # !!!!!WARNING!!!! has to change this part, everytime 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:
+                colorvalue, encoded_string = decode_string(encoded_string,the_keys=the_keys0, the_values=the_values0)
+                decode_matrix[i][j] = colorvalue
+                
+            # if it's on the boundary (any of the 4 edges)
+            elif i == 0 or i == decode_matrix.shape[0]-1 or j == 0 or j == decode_matrix.shape[1]-1:
+                colorvalue, encoded_string = decode_string(encoded_string,the_keys=the_keys0, the_values=the_values0)
+                decode_matrix[i][j] = colorvalue + 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))
+
+                    
+                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]:
+                    colorvalue, encoded_string = decode_string(encoded_string,the_keys=the_keys1, the_values=the_values1)
+                    decode_matrix[i][j] = colorvalue + int(predict)
+                    change_matrix[i][j] = colorvalue
+                elif difference <= bins[1] and difference > bins[0]:
+                    colorvalue, encoded_string = decode_string(encoded_string,the_keys=the_keys2, the_values=the_values2)
+                    decode_matrix[i][j] = colorvalue + int(predict)
+                    change_matrix[i][j] = colorvalue
+                elif difference <= bins[2] and difference > bins[1]:
+                    colorvalue, encoded_string = decode_string(encoded_string,the_keys=the_keys3, the_values=the_values3)
+                    decode_matrix[i][j] = colorvalue + int(predict)
+                    change_matrix[i][j] = colorvalue
+                else:
+                    colorvalue, encoded_string = decode_string(encoded_string,the_keys=the_keys4, the_values=the_values4)
+                    decode_matrix[i][j] = colorvalue + int(predict)
+                    change_matrix[i][j] = colorvalue
+    return decode_matrix.astype(int), change_matrix.astype(int)
+def color_adjust(visual_array):
+    min_of_errors = np.min(visual_array)
+    adjusted_array = visual_array - min_of_errors
+    adjusted_array = np.round(adjusted_array*255/np.max(adjusted_array))
+    return adjusted_array
+scenes = file_extractor(folder_name)
+images = image_extractor(scenes)
+list_dic = np.load("first_dic.npy", allow_pickle="TRUE")
+bins = [21,32,48]
+encoded_string2 = bytes_to_bitstring(read_from_file(images[250][:-5] + "_Compressed.txt"))
+original_array, error_array = produce_error_array(encoded_string2, list_dic, bins, False)
+adjusted_errors = color_adjust(abs(error_array))
+original_array_adjusted = color_adjust(original_array)
+# print(adjusted_errors)
+plt.subplot(121)
+plt.imshow(original_array_adjusted,cmap='gray',vmin = 0, vmax=255)
+plt.subplot(122)
+plt.imshow(adjusted_errors,cmap = 'gray', vmin = 0, vmax=255)
+plt.show()
\ No newline at end of file

FullTester.ipynb

@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -15,7 +15,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -257,7 +257,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {