kelly push

%% 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

```

%% Cell type:code id:c16af61f tags:

``` python

def file_extractor(dirname="images"):

    files = os.listdir(dirname)

    scenes = []

    for file in files:

        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:

            image_folder.append(os.path.join(scene, file))

    images = []

    for folder in image_folder:

        ims = os.listdir(folder)

        for im in ims:

            if im[-4:] == ".jp4" or im[-7:] == "_6.tiff":

                continue

            else:

                images.append(os.path.join(folder, im))

    return images #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:

``` python

def plot_hist(tiff_list):

    """

    This function is the leftovers from the first attempt to plot histograms.

    As it stands it needs some work in order to function again. We will

    fix this later. 1/25/22

    """

    image = tiff_list

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

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

    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))

    # 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)

    # flatten the image to a vector

    image = np.ravel(image[1:-1,1:-1])

    error = image-predict

    return image, predict, diff, error, A

```

%% Cell type:code id:6b965751 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:b7561883 tags:

``` python

def huffman(image):

    origin, predict, diff, error, A = plot_hist(image)

    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, predict

```

%% Cell type:code id:2eb774d2 tags:

``` python

def encoder(error, list_dic, diff, bound, bins):

    encoded = np.copy(error).astype(int).astype(str).astype(object)

    diff = np.reshape(diff,(510,638))

    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):

    """

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

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

    """

    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())

    error_matrix = np.zeros((512,640))

    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(the_keys0[the_values0.index(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_keys0[the_values0.index(encoded_matrix[i,j])]) + error_matrix[0][0]

            else:

                z0 = error_matrix[i-1][j-1]

                z1 = error_matrix[i-1][j]

                z2 = error_matrix[i-1][j+1]

                z3 = error_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)

                predict = np.round(np.round(np.linalg.solve(A,y)[-1][0],1))

                if difference <= bins[0]:

                    error_matrix[i][j] = int(the_keys1[the_values1.index(encoded_matrix[i,j])]) + int(predict)

                elif difference <= bins[1] and difference > bins[0]:

                    error_matrix[i][j] = int(the_keys2[the_values2.index(encoded_matrix[i,j])]) + int(predict)

                elif difference <= bins[2] and difference > bins[1]:

                    error_matrix[i][j] = int(the_keys3[the_values3.index(encoded_matrix[i,j])]) + int(predict)

                else:

                    error_matrix[i][j] = int(the_keys4[the_values4.index(encoded_matrix[i,j])]) + int(predict)

    return error_matrix.astype(int)

```

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

``` python

scenes = file_extractor()

images = image_extractor(scenes)

encode1, encode2, encode3, encode4, encode5, image, error, new_error, diff, bound, bins, predict = huffman(images[0])

encoded_matrix = encoder(np.reshape(new_error,(512,640)), [encode1, encode2, encode3, encode4, encode5], diff, bound, bins)

list_dic = [encode1, encode2, encode3, encode4, encode5]

```

%% Cell type:code id:ceb0b957 tags:

``` python

reconstruct_image = decoder(A, encoded_matrix, list_dic, bins)

```

%% Cell type:code id:60297ad0 tags:

``` python

np.allclose(image.reshape(512,640), reconstruct_image)

```

%% Output

    True

%% Cell type:code id:f0948ab2 tags:

``` python

for im in ims:

    if im[-4:] == ".jp4" or im[-7:] == "_6.tiff":

        continue

    else:

        images.append(os.path.join(folder, im))

```

%% Output

    2

%% Cell type:code id:7bc6e808 tags:

``` python

scenes = file_extractor('im')

for

```

%% Output

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

    NotADirectoryError                        Traceback (most recent call last)

    /var/folders/z2/plvrsqjs023g1cmx7k19mhzr0000gn/T/ipykernel_3109/413509388.py in <module>

          1 scenes = file_extractor('im')

    ----> 2 images = image_extractor(scenes)

    /var/folders/z2/plvrsqjs023g1cmx7k19mhzr0000gn/T/ipykernel_3109/3921095921.py in image_extractor(scenes)

          9     image_folder = []

         10     for scene in scenes:

    ---> 11         files = os.listdir(scene)

         12         for file in files:

         13             image_folder.append(os.path.join(scene, file))

    NotADirectoryError: [Errno 20] Not a directory: 'im/1640840453_605947_0.tiff'

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

``` python

print(scenes)

```

%% Output

    ['im/1640840453_605947_0.tiff', 'im/1640843156_846487_11.tiff', 'im/1628259417_495716_13.tiff', 'im/1640840448_738307_14.tiff', 'im/1628260288_519886_14.tiff', 'im/1640840458_606947_14.tiff']

%% Cell type:code id:26bd3666 tags:

``` python

```