deletions made

%% Cell type:code id:dbef8759 tags:

``` python

import numpy as np

from prediction_MSE_Scout import file_extractor, image_extractor, im_distribution

from matplotlib import pyplot as plt

from itertools import product

import os

import sys

from PIL import Image

from scipy.optimize import minimize

from time import time

from numpy import linalg as la

from scipy.stats import gaussian_kde

import seaborn as sns

from collections import Counter

import pandas as pd

import scipy as sp

```

%% Cell type:code id:9ed20f84 tags:

``` python

def predict(tiff_list, i=0):

    """

    This function predicts the pixel values based on a linear combination

    of the MSE from the three pixels above it and the one to the left. It

    uses a system of equations to fit the plane ax + by + c and takes c

    as the prediction for the unknown pixel. It does this all at once

    by constructing vectors and matrices of the surrounding pixels and solving each system simultaneously

    so as not to iterate through each one.

    Parameters:

        tiff_list: list, list of names of image file paths to access. These should be strings

        in the form of a path to the image

        i: int, which index in the tiff_list of images we want to predict on

    Returns:

        prediction: matrix (ndarray), the matrix of predicted values

        for the image using the previous four piexels

        diff: matrix (ndarray), the difference between the highest and lowest valued surrounding four pixels

        image_int: matrix (ndarray), the original image, changed into integers

        error: matrix (ndarray), a matrix of errors, so each entry is the

        difference between the integer predicted value and the actual value. Should

        be all integers

        A: matrix (3,3 ndarray), the matrix used to solve the MSE system

    """

    image = tiff_list[i]

    image = Image.open(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_int = image.astype(int)

    A = np.array([[3,0,-1],[0,3,3],[1,-3,-4]]) # the matrix for system of equation

    z0 = image_int[0:-2,0:-2]   # get all the first pixel for the entire image

    z1 = image_int[0:-2,1:-1]   # get all the second pixel for the entire image

    z2 = image_int[0:-2,2::]    # get all the third pixel for the entire image

    z3 = image_int[1:-1,0:-2]   # get all the fourth 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.linalg.solve(A,y)[-1]

    prediction = np.floor(np.linalg.solve(A,y)[-1]).astype(int)

    #predict = []

    # flatten the neighbor pixels 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)

    #diff = np.pad(diff.reshape(510,638), pad_width=1)

    # flatten the image to a vector

    small_image = image_int[1:-1,1:-1]

    #Reshape the predictions to be a 2D array

    prediction = np.pad(prediction.reshape(510,638), pad_width=1)

    #Calculate the error between the original image and our predictions

    #Note that we only predicted on the inside square of the original image, excluding

    #The first row, column and last row, column

    #error = (image_int - predict).astype(int) #Experiment

    #this one works

    error = image_int - prediction

    return prediction, diff, image_int, error[1:-1,1:-1], A

```

%% Cell type:code id:ba2881d9 tags:

``` python

scenes = file_extractor()

images = image_extractor(scenes)

num_images = im_distribution(images, "11")

```

%% Cell type:code id:11e95c34 tags:

``` python

prediction, diff, im, err, A = predict(images, 2)

```

%% Cell type:code id:434e4d2f tags:

``` python

def reconstruct(error, A):

    """

    Function that reconstructs the original image

    from the error matrix and using the predictive

    algorithm developed in the encoding.

    Parameters:

        error (array): matrix of errors computed in encoding. Same

                       shape as the original image (512, 640) in this case

        A (array): Matrix used for the system of equations to create predictions

    Returns:

        image (array): The reconstructed image

    """

    new_e = error.copy()

    rows, columns = new_e.shape

    for r in range(1, rows-1):        #Iterate through the inside square of the error matrix

        for c in range(1, columns-1):

            z0, z1, z2, z3 = new_e[r-1][c-1], new_e[r-1][c], new_e[r-1][c+1], new_e[r][c-1] #Grab the four nearest pixels

            y = np.vstack((-z0+z2-z3, z0+z1+z2, -z0-z1-z2-z3)) #Create a vector of the linear combinations for the

                                                               #solution to be solved

            new_e[r][c] = np.round(new_e[r][c] + np.linalg.solve(A,y)[-1], 1)  #Add the error to the solved system solution

                                                                               #rounding the result because np.linalg.solve(A,y)

                                                                               #can be a float. Since we did np.floor on it in

                                                                               #prediction, we round to the nearest integer here

    return new_e.astype(int)

```

%% Cell type:code id:3cc609dc tags:

``` python

new_error = reconstruct(err, A)

```

%% Cell type:code id:5d290a0c tags:

``` python

im == new_error

```

%% Output

    C:\Users\calle\AppData\Local\Temp/ipykernel_23384/389333.py:1: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.

      im == new_error

    False

%% Cell type:code id:bb11dcd0 tags:

``` python

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:c01fda28 tags:

``` python

def encoder(images, i, plot=True):

    """

    Function that creates Huffman encodings out of the error values

    for a given image. The encodings are more efficient ways to store

    large integer values that the original image contains.

    Parameters:

        images (list): list of file paths to the images that

        will be encoded.

        i (int): which index of the images list to grab and

        then encode.

        plot (bool): if true, this plots the error matrix to

        show the distribution of values.

    """

    prediction, diff, original, error, A = predict(images, i) #Predict the values and return the error for the specified image

    image = original

    new_error = np.copy(image)   #Create a new matrix that is a copy of the original image, this is the matrix we will

                                 #update on throughout

    #new_error[1:-1,1:-1] = np.reshape(error[1:-1,1:-1],(510, 638))

    new_error[1:-1, 1:-1] = error[1:-1, 1:-1]  #Set the inside of the updating matrix to be the same as the

                                               #error matrix retreived from predicting

    keep = new_error[0,0]                      #The top left entry stays the same

    new_error[0,:] = new_error[0,:] - keep     #All edge pixels are set to be the difference between themselves and

    new_error[-1,:] = new_error[-1,:] - keep   #the top left entry named "keep". This reduces their size to a more

    new_error[1:-1,0] = new_error[1:-1,0] - keep #manageable integer and makes them encodeable with the other error values

    new_error[1:-1,-1] = new_error[1:-1,-1] - keep

    new_error[0,0] = keep

    new_error = np.ravel(new_error) #Unravel it to plot it

    if plot:

        plt.hist(new_error[1:],bins=100)

        plt.show()

    string = [str(i) for i in new_error]  #Create strings out of the integers in the new_error matrix

    freq = dict(Counter(string))  #Initialize a dictionary that maps integers to the string values

    freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)  #Create a frequency mapping of how often the string

                                                                   #values occur in the dictionary

    node = make_tree(freq) #Use the Huffman code given above to make a Huffman tree

    encoding_dict = huffman_code_tree(node) #Create the Huffman dictionary

    #encoded = ["1"+encoding[str(-i)] if i < 0 else "0"+encoding[str(i)] for i in error]

    encoded = new_error.reshape((512,640)).copy().astype(str).astype(object) #Reshape the error matrix and make a copy that

                                                                             #that is all strings so we can call the

                                                                             #dictionary on its entries

    for i in range(encoded.shape[0]):        #Iterate through the string valued error dictionary

        for j in range(encoded.shape[1]):

            if i == 0 and j == 0:

                encoded[i][j] = encoded[i][j]  #Replace each value in the dictionary with its encoding from the dictionary

            else:

                encoded[i][j] = encoding_dict[encoded[i][j]]

    return encoding_dict, encoded, new_error.reshape((512,640)), image

    #print(encoding)

```

%% Cell type:code id:ffa858e8 tags:

``` python

encode_dict, encoding, error, orig_image = encoder(images, 2, plot=False)

```

%% Output

    ---------------------------------------------------------------------------

    ValueError                                Traceback (most recent call last)

    ~\AppData\Local\Temp/ipykernel_23384/384786850.py in <module>

    ~\AppData\Local\Temp/ipykernel_2620/384786850.py in <module>

    ----> 1 encode_dict, encoding, error, orig_image = encoder(images, 2, plot=False)

    ~\AppData\Local\Temp/ipykernel_23384/3253315524.py in encoder(images, i, plot)

    ~\AppData\Local\Temp/ipykernel_2620/3253315524.py in encoder(images, i, plot)

         21                                  #update on throughout

         22     #new_error[1:-1,1:-1] = np.reshape(error[1:-1,1:-1],(510, 638))

    ---> 23     new_error[1:-1, 1:-1] = error[1:-1, 1:-1]  #Set the inside of the updating matrix to be the same as the

         24                                                #error matrix retreived from predicting

         25     keep = new_error[0,0]                      #The top left entry stays the same

    ValueError: could not broadcast input array from shape (508,636) into shape (510,638)

%% Cell type:code id:825cc48c tags:

``` python

def decoder(A, encoded_matrix, encoding_dict):

    """

    Function that accecpts the prediction matrix A for the linear system,

    the encoded matrix of error values, and the encoding dicitonary.

    """

    the_keys = list(encoding_dict.keys())

    the_values = list(encoding_dict.values())

    error_matrix = encoded_matrix.copy()

    for i in range(error_matrix.shape[0]):

        for j in range(error_matrix.shape[1]):

            if i == 0 and j == 0:

                error_matrix[i][j] = int(encoded_matrix[i][j])

            elif i == 0 or i == error_matrix.shape[0]-1 or j == 0 or j == error_matrix.shape[1]-1:

                error_matrix[i][j] = int(the_keys[the_values.index(error_matrix[i,j])]) + error_matrix[0][0]

            else:

                """z0, z1, z2, z3 = error_matrix[i-1][j-1], error_matrix[i-1][j], \

                error_matrix[i-1][j+1], error_matrix[i][j-1]

                y = np.vstack((-z0+z2-z3, z0+z1+z2, -z0-z1-z2-z3))"""

                error_matrix[i][j] = int(the_keys[the_values.index(error_matrix[i,j])])

    return error_matrix.astype(int)

```

%% Cell type:code id:ba1d2c2c tags:

``` python

em = decoder(A, encoding, encode_dict)

```

%% Output

    ---------------------------------------------------------------------------

    NameError                                 Traceback (most recent call last)

    ~\AppData\Local\Temp/ipykernel_23384/3979147550.py in <module>

    ----> 1 em = decoder(A, encoding, encode_dict)

    NameError: name 'encoding' is not defined

%% Cell type:code id:b2cdce6d tags:

``` python

hopefully = reconstruct(em, A)

#22487 22483 22521 22464

```

%% Output

    ---------------------------------------------------------------------------

    NameError                                 Traceback (most recent call last)

    ~\AppData\Local\Temp/ipykernel_23384/2268978435.py in <module>

    ----> 1 hopefully = reconstruct(em, A)

          2 #22487 22483 22521 22464

    NameError: name 'em' is not defined

%% Cell type:code id:285efcf0 tags:

``` python

def test_decoder():

    n = len(images)//12

    fails = 0

    for i in range(n):

        encode_dict1, encoding1, error1, orig_image1 = encoder(images, i, plot=False)

        new_error = decoder(A, encoding1, encode_dict1)

        reconstructed_image = reconstruct(new_error, A)

        if False in np.ravel(reconstructed_image == orig_image):

            fails += 0

    return fails/n

f = test_decoder()

```

%% Cell type:code id:30b1c87e tags:

``` python

def entropy_func(images):

    """

    Computes the entropy for all pictures (tiff files) in the images list.

    This gives an idea of how many bits it would take on average to encode the

    given image. The output is a list of entropies, one per image.

    """

    entr = []

    for i in range(len(images)):

        prediction, diff, im, err, A = predict(images, i)

        panda_im = pd.Series(np.ravel(im))

        counts = panda_im.value_counts()

        entr.append(sp.stats.entropy(counts))

    return entr

e = entropy_func(images)

print(np.mean(e))

```

%% Output

    6.7830123821108295

%% Cell type:code id:4c268907 tags:

``` python

def huffman(image):

    origin, predicty, diff, error, A = predict(image,0)

    image = Image.open(image)

    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)

    boundary = np.hstack((image[0,:],image[-1,:],image[1:-1,0],image[1:-1,-1]))

    boundary = boundary - image[0,0]

    boundary[0] = image[0,0]

    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)

    encode1 = huffman_code_tree(node)

    mask = diff <= 25

    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)

    encode2 = huffman_code_tree(node)

    mask = diff > 25

    new_error = error[mask]

    mask2 = diff[mask] <= 40

    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)

    encode3 = huffman_code_tree(node)

    mask = diff > 40

    new_error = error[mask]

    mask2 = diff[mask] <= 70

    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)

    encode4 = huffman_code_tree(node)

    mask = diff > 70

    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)

    encode5 = huffman_code_tree(node)

    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

    #new_error = np.ravel(new_error)

    bins = [25,40,70]

    # return the huffman dictionary

    return encode1, encode2, encode3, encode4, encode5, np.ravel(image), error, new_error, diff, boundary, bins

scenes = file_extractor()

images = image_extractor(scenes)

encode1, encode2, encode3, encode4, encode5, image, error, new_error, diff, boundary, bins = huffman(images)

```

%% Output

    ---------------------------------------------------------------------------

    AttributeError                            Traceback (most recent call last)

    ~\anaconda3\lib\site-packages\PIL\Image.py in open(fp, mode, formats)

       2971     try:

    -> 2972         fp.seek(0)

       2973     except (AttributeError, io.UnsupportedOperation):

    AttributeError: 'list' object has no attribute 'seek'

During handling of the above exception, another exception occurred:

    AttributeError                            Traceback (most recent call last)

    ~\AppData\Local\Temp/ipykernel_23384/4042219417.py in <module>

         72 scenes = file_extractor()

         73 images = image_extractor(scenes)

    ---> 74 encode1, encode2, encode3, encode4, encode5, image, error, new_error, diff, boundary, bins = huffman(images)

    ~\AppData\Local\Temp/ipykernel_23384/4042219417.py in huffman(image)

          2     origin, predicty, diff, error, A = predict(image,0)

          3

    ----> 4     image = Image.open(image)

          5     image = np.array(image)[1:,:]    #Convert to an array, leaving out the first row because the first row is just housekeeping data

          6     image = image.astype(int)

    ~\anaconda3\lib\site-packages\PIL\Image.py in open(fp, mode, formats)

       2972         fp.seek(0)

       2973     except (AttributeError, io.UnsupportedOperation):

    -> 2974         fp = io.BytesIO(fp.read())

       2975         exclusive_fp = True

       2976

    AttributeError: 'list' object has no attribute 'read'

%% Cell type:code id:e98fc3cf tags:

``` python

print(boundary)

```

%% Output

    [22541   -10    14 ...    62   151   208]

%% Cell type:code id:f5e71acc tags:

``` python

```

%% Cell type:code id:642b95a3 tags:

``` python

def compress_rate(image, error, diff, bound, encode1, encode2, encode3, encode4, encode5):

    #original = original.reshape(-1)

    #error = error.reshape(-1)

    o_len = 0

    c_len = 0

    im = np.reshape(image,(512, 640))

    real_b = np.hstack((im[0,:],im[-1,:],im[1:-1,0],im[1:-1,-1]))

    original = im[1:-1,1:-1].reshape(-1)

    for i in range(0,len(bound)):

        o_len += len(bin(real_b[i])[2:])

        c_len += len(encode1[str(bound[i])])

    for i in range(0, len(original)):

        o_len += len(bin(original[i])[2:])

        if diff[i] <= 10:

            c_len += len(encode2[str(int(error[i]))])

        if diff[i] <= 25 and diff[i] > 10:

            c_len += len(encode3[str(int(error[i]))])

        if diff[i] <= 45 and diff[i] > 25:

            c_len += len(encode4[str(int(error[i]))])

        if diff[i] > 45:

            c_len += len(encode5[str(int(error[i]))])

    return c_len/o_len

compress_rate(origin, error, diff, boundary, encode1, encode2, encode3, encode4, encode5)

```

%% Output

    0.4427516682942708