deletions final

'''

Created on Jan 11, 2022

@author: nathanielc

python file located in the Image Compression project

folder under nathanielc user. This python file is for

exploring possible image compression techniques and is by 

no means a final product. Goal is to learn how to download 

images and extract important statistics from them.

'''

import numpy as np

from matplotlib import pyplot as plt

from itertools import product

import os

import sys

from PIL import Image

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:-6] == num:

            tiff.append(im)

    return tiff

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

    """

    '''jj = 0

    fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(15,12))

    for cam, ax in zip(cameras, axs.ravel()):

        diff = []

        for ii in range(len(cam)):

            image = Image.open(cam[ii])    #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

            ar1, ar2 = image.shape

            ind1, ind2 = np.random.randint(1,ar1-1), np.random.randint(1,ar2-1) #ind1 randomly selects a row, ind2 randomly selects a column, 

                                                                            #this is now a random pixel selection within the image

            surrounding = []                                                #initialize a list to be filled the 8 surrounding pixels

            for i,j in product(np.arange(-1,2), repeat=2):                  #Iterate through the combinations of surrounding pixel indices

                if i == 0 and j == 0:                                       #Avoid the target pixel

                    continue

                else:

                    surrounding.append(image[ind1+i, ind1+j])               #Add the other 8 pixels to the list

            diff.append(np.max(surrounding)-np.min(surrounding))

        ax.hist(diff)

        ax.set_title(f"tiff {jj}")

        jj += 1

    plt.tight_layout()

    plt.show()

    return '''

    image = tiff_list[0]

    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

    row, col = image.shape

    predict = np.empty([row-1,col-1])     # create a empty matrix to update prediction

    temp = image.copy

    diff = np.empty([row-1,col-1])

    for r in range(1,row-1):                  # loop through the rth row

        for c in range(1,col-1):              # loop through the cth column

            surrounding = np.array([temp[r-1,c-1], temp[r-1,c], temp[r-1,c+1], temp[r,c-1]])

            predict[r,c] = np.mean(surrounding)       # take the mean of the previous 4 pixels

            temp[r,c] = np.mean(surrounding)

            diff[r,c] = (np.max(surrounding)-np.min(surrounding))

    predict = np.ravel(predict)

    diff = np.ravel(diff)

    n = len(predict)

    fig = plt.figure()

    ax1 = fig.add_subplot(111, projection='3d')

    z3 = np.zeros(n)

    dx = np.ones(n)

    dy = np.ones(n)

    dz = np.arange(n)

    ax1.bar3d(predict, diff, z3, dx, dy, dz, color="red")

    ax1.axis('off')

    plt.show()

    return image, predict, diff

if __name__ == '__main__':

    """For boundary cases: Start by grabbing the shape of the images and saving those

    as variables. Then, if statements for if row == 0 or row == maximum and if

    col == 0 or col == maximum. Then grab corresponding open pixels. Then proceed to do

    an and statement that handles the corners"""

    scenes = file_extractor()

    images = image_extractor(scenes)

    #image, predict, difference = plot_hist(images)

    #error = np.abs(image-predict)

    plot_hist(images)

 No newline at end of file

#!/usr/bin/env python

# coding: utf-8

# In[72]:

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

from time import time

from numpy import linalg as la

from scipy.stats import gaussian_kde, entropy

import seaborn as sns

import pywt

import math

#import cv2

# In[15]:

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:

            if file[-4:] == ".jp4" 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

# In[16]:

def plot_hist(tiff_list, i):

    """

    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[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 = 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.linalg.solve(A,y)[-1]

    #predict = []

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

    """for i in range(len(neighbor)):

        if neighbor[i][0] >= max(neighbor[i][3], neighbor[i][1]):

            predict.append(min(neighbor[i][3], neighbor[i][1]))

        elif neighbor[i][0] < min(neighbor[i][3], neighbor[i][1]):

            predict.append(max(neighbor[i][3], neighbor[i][1]))

        else:

            predict.append(neighbor[i][3] + neighbor[i][1] - neighbor[i][0])"""

    # flatten the image to a vector

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

    return image_ravel, predict, diff, image

# In[17]:

scenes = file_extractor()

images = image_extractor(scenes)

num_images = im_distribution(images, "_1")

error_mean = []

error_mean1 = []

diff_mean = []

times = []

times1 = []

all_error = []

for i in range(len(num_images)):

    """start1 = time()

    image_1, predict_1, difference_1, x_s_1 = plot_hist(num_images, i, "second")

    stop1 = time()

    times1.append(stop1-start1)

    error1 = np.abs(image_1-predict_1)

    error_mean1.append(np.mean(np.ravel(error1)))"""

    start = time()

    image, predict, difference, non_ravel = plot_hist(num_images, i)

    stop = time()

    times.append(stop-start)

    error = np.abs(image-predict)

    all_error.append(np.ravel(error))

    error_mean.append(np.mean(np.ravel(error)))

    diff_mean.append(np.mean(np.ravel(difference)))

#image, predict, difference = plot_hist(images, 0)

# In[18]:

print(f"Average Error: {np.mean(error_mean)}")

print(f"Standard Deviaiton of Mean Errors: {np.sqrt(np.var(error_mean))}")

print(f"Average Difference: {np.mean(diff_mean)}")

print(f"Average Time per Image for First: {np.mean(times)}")

# In[19]:

new_image, new_pred, new_diff, no_ravel = plot_hist(images, 10)

# In[21]:

new_error = new_image-new_pred

plt.hist(new_error, bins=20, density=True)

sns.kdeplot(new_error)

plt.xlabel("error")

plt.show()

# In[41]:

image = Image.open(images[0])    #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(np.int64)

print("Std Deviation of E: ", np.std(new_error))

print("Normal bits: ", int(image[0][0]).bit_length())

H = np.log2(np.std(new_error)) + 1.943

print("Encoded Bits: ", H)

# In[47]:

# In[9]:

pred = new_pred.reshape((510,638))

real_pred = no_ravel.copy()

real_pred[1:-1, 1:-1] = pred

# In[10]:

coeffs = pywt.dwt2(no_ravel, 'bior1.3')

LL, (LH, HL, HH) = coeffs

print(HH.shape)

decompress = pywt.idwt2(coeffs, 'bior1.3')

"""print(decompress)

print(np.mean(np.abs(decompress-no_ravel)))"""