Skip to content

I
image-compression
Commit aad13dd4 authored by Nathaniel Callens's avatar Nathaniel Callens
Browse files
Options

updates

parent 1037f11d
Show whitespace changes
Inline Side-by-side
Showing with 1378 additions and 1083 deletions
.ipynb_checkpoints/Error_to_Image-checkpoint.ipynb 0 → 100644
View file @ aad13dd4
{
"cells": [
{
"cell_type": "code",
"execution_count": 3,
"id": "dbef8759",
"metadata": {
"id": "dbef8759"
},
"outputs": [],
"source": [
"import numpy as np\n",
"from prediction_MSE_Scout import file_extractor, image_extractor, im_distribution\n",
"from matplotlib import pyplot as plt\n",
"from itertools import product\n",
"import os\n",
"import sys\n",
"from PIL import Image\n",
"from scipy.optimize import minimize\n",
"from time import time\n",
"from numpy import linalg as la\n",
"from scipy.stats import gaussian_kde\n",
"import seaborn as sns\n",
"import pywt"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "9ed20f84",
"metadata": {
"id": "9ed20f84"
},
"outputs": [],
"source": [
"def plot_hist(tiff_list, i=0):\n",
" \"\"\"\n",
" This function is the leftovers from the first attempt to plot histograms.\n",
" As it stands it needs some work in order to function again. We will\n",
" fix this later. 1/25/22\n",
" \"\"\"\n",
" \n",
" image = tiff_list[i]\n",
" image = Image.open(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",
" \n",
" A = np.array([[3,0,-1],[0,3,3],[1,-3,-4]]) # the matrix for system of equation\n",
" \n",
" z0 = image[0:-2,0:-2] # get all the first pixel for the entire image\n",
" z1 = image[0:-2,1:-1] # get all the second pixel for the entire image\n",
" z2 = image[0:-2,2::] # get all the third pixel for the entire image\n",
" z3 = image[1:-1,0:-2] # get all the forth pixel for the entire image\n",
" \n",
" # calculate the out put of the system of equation\n",
" y0 = np.ravel(-z0+z2-z3)\n",
" y1 = np.ravel(z0+z1+z2)\n",
" y2 = np.ravel(-z0-z1-z2-z3)\n",
" y = np.vstack((y0,y1,y2))\n",
" \n",
" # use numpy solver to solve the system of equations all at once\n",
" predict = np.linalg.solve(A,y)[-1]\n",
" #predict = []\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",
" # calculate the difference\n",
" diff = np.max(neighbor,axis = 1) - np.min(neighbor, axis=1)\n",
" \n",
" \n",
" # flatten the image to a vector\n",
" small_image = image[1:-1,1:-1]\n",
" \n",
" #Reshape the predictions to be a 2D array\n",
" predict = np.pad(predict.reshape(510,638), pad_width=1)\n",
" predict[0,:] = image[0,:]\n",
" predict[:,0] = image[:,0]\n",
" predict[:,-1] = image[:,-1]\n",
" predict[-1,:] = image[-1,:]\n",
" \n",
" \n",
" #Calculate the error between the original image and our predictions\n",
" #Note that we only predicted on the inside square of the original image, excluding\n",
" #The first row, column and last row, column\n",
" error = image - predict\n",
"\n",
" \n",
" return predict, diff, image, error, A"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "de1e8dc9",
"metadata": {},
"outputs": [],
"source": [
"scenes = file_extractor()\n",
"images = image_extractor(scenes)\n",
"num_images = im_distribution(images, \"_1\")"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "8b046cba",
"metadata": {},
"outputs": [],
"source": [
"predict, diff, im, err, A = plot_hist(num_images, 0)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c13a239a",
"metadata": {},
"outputs": [],
"source": [
"def reconstruct(error, A):\n",
" \"\"\"\n",
" Function that reconstructs the original image\n",
" from the error matrix and using the predictive\n",
" algorithm developed in the encoding.\n",
" \n",
" Parameters:\n",
" error (array): matrix of errors computed in encoding. Same \n",
" shape as the original image (512, 640) in this case\n",
" A (array): Matrix used for the system of equations to create predictions\n",
" Returns: \n",
" image (array): The reconstructed image\n",
" \"\"\"\n",
" "
]
}
],
"metadata": {
"colab": {
"collapsed_sections": [],
"name": "Wavelet_Huffman.ipynb",
"provenance": []
},
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.11"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
.ipynb_checkpoints/Scout_Compression_Exp-checkpoint.ipynb 0 → 100644
View file @ aad13dd4
{
"cells": [
{
"cell_type": "code",
"execution_count": 3,
"id": "9d3f0b36",
"metadata": {},
"outputs": [],
"source": [
"from prediction_MSE_Scout import file_extractor, image_extractor, im_distribution\n",
"import numpy as np\n",
"from matplotlib import pyplot as plt\n",
"import os\n",
"import sys\n",
"from PIL import Image\n",
"import math"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "e20525b8",
"metadata": {},
"outputs": [],
"source": [
"scenes = file_extractor()\n",
"images = image_extractor(scenes)\n",
"num_images = im_distribution(images, \"_1\")"
]
},
{
"cell_type": "code",
"execution_count": 65,
"id": "837df9c4",
"metadata": {},
"outputs": [],
"source": [
"def compress(inputFile):\n",
" twoBytes = 256*256\n",
" # Read the input file into a numpy array of 8-bit values\n",
" #\n",
" # The img.shape is a 3-type with rows,columns,channels, where\n",
" # channels is the number of components in each pixel. The img.dtype\n",
" # is 'uint8', meaning that each component is an 8-bit unsigned\n",
" # integer.\n",
"\n",
" #img = netpbm.imread(inputFile).astype('uint8')\n",
" img = Image.open(inputFile) #Open the image and read it as an Image object\n",
" img = np.array(img)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data\n",
" img = img.astype('uint8')\n",
"\n",
" # Compress the image\n",
" #\n",
" #\n",
" # Note that single-channel images will have a 'shape' with only two\n",
" # components: the y dimensions and the x dimension. So you will\n",
" # have to detect this and set the number of channels accordingly.\n",
" # Furthermore, single-channel images must be indexed as img[y,x]\n",
" # instead of img[y,x,1]. You'll need two pieces of similar code:\n",
" # one piece for the single-channel case and one piece for the\n",
" # multi-channel case.\n",
"\n",
" #startTime = time.time()\n",
"\n",
" outputBytes = bytearray()\n",
"\n",
" # initialize dictionary\n",
" d = {}\n",
" counter = 256\n",
" for i in range(-counter, counter):\n",
" d[str(i)] = i\n",
" # Set Dictionary limit\n",
"\n",
" # Make a list to hold bytes\n",
" tempBytes = []\n",
" # A counter for the number of bytes\n",
" numBytes = 0\n",
" multichannel = False\n",
" \n",
" # for a single channel image\n",
" if (len(img.shape) == 2) :\n",
" multichannel = False\n",
" \n",
" # Go through whole image\n",
" for y in range(img.shape[0]):\n",
" for x in range(img.shape[1]):\n",
" # Initialize prediction to image value\n",
" prediction = img[y][x]\n",
" #\"\"\" \n",
" # Modify prediction to show the difference between prior pixels and current pixel\n",
" if(x != 0):\n",
" prediction = prediction - img[y][x-1]\n",
" elif(y != 0):\n",
" prediction = prediction - img[y-1][x]\n",
" else:\n",
" prediction = prediction - (img[y][x-1]/3 + img[y-1][x]/3 + img[y-1][x-1]/3)\n",
" #\"\"\"\n",
" # Add the predicted value to the bytestream\n",
" tempBytes.append(prediction)\n",
" numBytes += 1\n",
" # Using a string variable as it allows for concatenation\n",
" s = \"\"\n",
" # Set s to the first value of the bytestream \n",
" s = str(int(tempBytes[0]))\n",
" # Go through all bytes\n",
" for i in range(1, numBytes):\n",
" # Do LZW encoding\n",
" # If trying to add entry larger than max size of the dictionary reinitialize the dictionary\n",
" if(counter >= twoBytes):\n",
" counter = 256\n",
" d = {}\n",
" for i in range(-counter, counter):\n",
" d[str(i)] = i\n",
"\n",
" # Add the next byte to the current string. Uses a delimeter to distinguish numbers\n",
" w = s +\"|\"+str(tempBytes[i])\n",
" \n",
" # Checking if it has been seen before\n",
" if w in d:\n",
" s = w\n",
" \n",
" else:\n",
" # Output bytes by splitting integer into two bytes, this allows for a larger dictionary\n",
" outputBytes.append((int(d[s]) >> 8) & 0xFF)\n",
" outputBytes.append(int(d[s]) & 0xFF)\n",
" # Add to dictionarry\n",
" d[w] = counter\n",
" counter += 1\n",
" s = str(int(tempBytes[i]))\n",
" # Check if the last byte was added or not \n",
" if s in d: \n",
" outputBytes.append((int(d[s]) >> 8) & 0xFF)\n",
" outputBytes.append(int(d[s]) & 0xFF)\n",
" \n",
" \n",
" \n",
" return outputBytes, img.shape[0], img.shape[1]"
]
},
{
"cell_type": "code",
"execution_count": 64,
"id": "dec67245",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"103\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\calle\\AppData\\Local\\Temp/ipykernel_12604/4289951463.py:56: RuntimeWarning: overflow encountered in ubyte_scalars\n",
" prediction = prediction - img[y][x-1]\n",
"C:\\Users\\calle\\AppData\\Local\\Temp/ipykernel_12604/4289951463.py:58: RuntimeWarning: overflow encountered in ubyte_scalars\n",
" prediction = prediction - img[y-1][x]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"245\n"
]
}
],
"source": [
"test = images[0]\n",
"out, rows, cols = compress(test)\n",
"print(out[19])"
]
},
{
"cell_type": "code",
"execution_count": 55,
"id": "51938ebb",
"metadata": {},
"outputs": [],
"source": [
"# Uncompress an image\n",
"\n",
"def uncompress(byteArray, rows, columns):\n",
" twoBytes = 256*256\n",
" # Check that it's a known file\n",
"\n",
" \"\"\"if inputFile.readline() != headerText + '\\n':\n",
" sys.stderr.write( \"Input is not in the '%s' format.\\n\" % headerText )\n",
" sys.exit(1)\"\"\"\n",
" \n",
" # Read the rows, columns, and channels. counter\n",
"\n",
" #rows, columns, channels = [ int(x) for x in inputFile.readline().split() ]\n",
"\n",
" # Read the raw bytes.\n",
"\n",
" inputBytes = byteArray\n",
"\n",
" # Build the image\n",
" #\n",
" # REPLACE THIS WITH YOUR OWN CODE TO CONVERT THE 'inputBytes' ARRAY INTO AN IMAGE IN 'img'.\n",
" \n",
"\n",
" result = []\n",
"\n",
" # initialize the dictionary in the opposite was as compress and use an array as the value\n",
" d = {} # create a dictionary\n",
" counter = 256\n",
" \n",
" # Initialize dictionary with values equalling keys from [-256,256]\n",
" for i in range(-counter, counter):\n",
" d[i] = [i]\n",
"\n",
" img = np.empty([rows,columns], dtype=np.uint8 )\n",
"\n",
" byteIter = iter(inputBytes)\n",
"\n",
" # Get encoding in the form of next two bytes\n",
" new = (byteIter.__next__() >> 8) + byteIter.__next__()\n",
" s = d[new]\n",
" \n",
" result.append(s[0])\n",
"\n",
" for i in range(1, len(inputBytes)//2):\n",
" \n",
" # again reset the dictionary if it reaches the limit\n",
" # Initialize dictionary with values equalling keys from [-256,256]\n",
"\n",
" if counter >= twoBytes:\n",
" d = {} # initialize blank dictionary\n",
" counter = 256\n",
" for i in range(-counter, counter):\n",
" d[i] = [i]\n",
" \n",
" \n",
" new = (byteIter.__next__() >> 8) + byteIter.__next__()\n",
"\n",
" #retrieve value of dictionary entry from dictionary or create entry assuming it has not yet been entered into dictionary\n",
" \n",
" if new in d:\n",
" d_value = d[new]\n",
" else:\n",
" d_value = []\n",
" for j in s:\n",
" d_value.append(j)\n",
" d_value.append(s[0])\n",
" \n",
" #add dictionary entry value to the result\n",
" for k in range(len(d_value)):\n",
" result.append(d_value[k])\n",
"\n",
" #Create entry in dictionary\n",
" temp = []\n",
" for j in s:\n",
" temp.append(j)\n",
" temp.append(s[0])\n",
" d[counter] = temp\n",
" counter += 1\n",
" \n",
" \n",
" # reset decoded string to dictionary entry value\n",
" s = d_value\n",
" \n",
" print(result[:20])\n",
" channels = 1\n",
" \n",
" #implement predictive encoding\n",
" prediction = 0\n",
" counter = 0\n",
"\n",
" # for a single channel image\n",
" if (channels == 1):\n",
" # Go through whole image\n",
" for y in range(rows):\n",
" for x in range(columns):\n",
" #'''\n",
" if(x != 0):\n",
" prediction = img[y][x-1]\n",
" elif(y != 0):\n",
" prediction = img[y-1][x]\n",
" else:\n",
" prediction = (img[y][x-1]/3 + img[y-1][x]/3 + img[y-1][x-1]/3)\n",
" #'''\n",
" img[y,x] = result[counter] + prediction\n",
" counter += 1\n",
" \n",
" return img\n",
"\n",
" # Output the image\n",
"\n",
" #netpbm.imsave( outputFile, img )\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 56,
"id": "74528264",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[164, 246, 24, 0, 4, 239, 251, 13, 12, 245, 246, 6, 6, 250, 0, 0, 3, 4, 242, 0]\n"
]
},
{
"ename": "IndexError",
"evalue": "list index out of range",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_12604/601870618.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mimgg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0muncompress\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mout\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrows\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcols\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_12604/2882586717.py\u001b[0m in \u001b[0;36muncompress\u001b[1;34m(byteArray, rows, columns)\u001b[0m\n\u001b[0;32m 102\u001b[0m \u001b[0mprediction\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m3\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mimg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m3\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mimg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 103\u001b[0m \u001b[1;31m#'''\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 104\u001b[1;33m \u001b[0mimg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mresult\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mcounter\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mprediction\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 105\u001b[0m \u001b[0mcounter\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 106\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
"\u001b[1;31mIndexError\u001b[0m: list index out of range"
]
}
],
"source": [
"imgg = uncompress(out, rows, cols)"
]
},
{
"cell_type": "code",
"execution_count": 67,
"id": "ea5c3c61",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,\n",
" 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,\n",
" 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,\n",
" 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,\n",
" 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,\n",
" 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,\n",
" 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,\n",
" 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,\n",
" 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,\n",
" 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,\n",
" 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,\n",
" 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,\n",
" 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,\n",
" 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181,\n",
" 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,\n",
" 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,\n",
" 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,\n",
" 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,\n",
" 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,\n",
" 247, 248, 249, 250, 251, 252, 253, 254, 255], dtype=uint8)"
]
},
"execution_count": 67,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"img = Image.open(test) #Open the image and read it as an Image object\n",
"img = np.array(img)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data\n",
"img = img.astype('uint8')\n",
"np.unique(img.ravel())"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.11"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
.ipynb_checkpoints/prediction_MSE_Scout-checkpoint.ipynb
View file @ aad13dd4
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
"cells": [ "cells": [
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 72, "execution_count": 1,
"id": "dbef8759", "id": "dbef8759",
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
...@@ -25,7 +25,7 @@ ...@@ -25,7 +25,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 15, "execution_count": 2,
"id": "b7a550e0", "id": "b7a550e0",
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
...@@ -80,7 +80,7 @@ ...@@ -80,7 +80,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 16, "execution_count": 32,
"id": "9ed20f84", "id": "9ed20f84",
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
...@@ -133,7 +133,7 @@ ...@@ -133,7 +133,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 17, "execution_count": 34,
"id": "8e3ef654", "id": "8e3ef654",
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
...@@ -168,7 +168,7 @@ ...@@ -168,7 +168,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 18, "execution_count": 35,
"id": "fa65dcd6", "id": "fa65dcd6",
"metadata": {}, "metadata": {},
"outputs": [ "outputs": [
...@@ -179,7 +179,7 @@ ...@@ -179,7 +179,7 @@
"Average Error: 19.44221679267325\n", "Average Error: 19.44221679267325\n",
"Standard Deviaiton of Mean Errors: 0.17734010606906342\n", "Standard Deviaiton of Mean Errors: 0.17734010606906342\n",
"Average Difference: 51.95430150900486\n", "Average Difference: 51.95430150900486\n",
"Average Time per Image for First: 0.04917508363723755\n" "Average Time per Image for First: 0.050624340772628784\n"
] ]
} }
], ],
...@@ -192,7 +192,7 @@ ...@@ -192,7 +192,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 19, "execution_count": 6,
"id": "4c05b947", "id": "4c05b947",
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
...@@ -202,13 +202,13 @@ ...@@ -202,13 +202,13 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 21, "execution_count": 28,
"id": "dda442ae", "id": "dda442ae",
"metadata": {}, "metadata": {},
"outputs": [ "outputs": [
{ {
"data": { "data": {
"image/png": "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\n", "image/png": "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\n",
"text/plain": [ "text/plain": [
"<Figure size 432x288 with 1 Axes>" "<Figure size 432x288 with 1 Axes>"
] ]
...@@ -220,7 +220,7 @@ ...@@ -220,7 +220,7 @@
} }
], ],
"source": [ "source": [
"new_error = new_image-new_pred\n", "new_error = (new_image-new_pred).astype(np.int32)\n",
"plt.hist(new_error, bins=20, density=True)\n", "plt.hist(new_error, bins=20, density=True)\n",
"sns.kdeplot(new_error)\n", "sns.kdeplot(new_error)\n",
"plt.xlabel(\"error\")\n", "plt.xlabel(\"error\")\n",
...@@ -229,289 +229,30 @@ ...@@ -229,289 +229,30 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 41, "execution_count": 48,
"id": "58da6063", "id": "58da6063",
"metadata": {}, "metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Std Deviation of E: 26.627504708827136\n",
"Normal bits: 15\n",
"Encoded Bits: 6.677845333316752\n"
]
}
],
"source": [
"image = Image.open(images[0]) #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(np.int64)\n",
"print(\"Std Deviation of E: \", np.std(new_error))\n",
"print(\"Normal bits: \", int(image[0][0]).bit_length())\n",
"H = np.log2(np.std(new_error)) + 1.943\n",
"print(\"Encoded Bits: \", H)"
]
},
{
"cell_type": "code",
"execution_count": 47,
"id": "ec4db902",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"8192\n"
]
}
],
"source": []
},
{
"cell_type": "code",
"execution_count": 9,
"id": "2562feeb",
"metadata": {
"scrolled": false
},
"outputs": [],
"source": [
"pred = new_pred.reshape((510,638))\n",
"real_pred = no_ravel.copy()\n",
"real_pred[1:-1, 1:-1] = pred"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "470cc137",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(258, 322)\n"
]
},
{
"data": {
"text/plain": [
"'print(decompress)\\nprint(np.mean(np.abs(decompress-no_ravel)))'"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"coeffs = pywt.dwt2(no_ravel, 'bior1.3')\n",
"LL, (LH, HL, HH) = coeffs\n",
"print(HH.shape)\n",
"decompress = pywt.idwt2(coeffs, 'bior1.3')\n",
"\"\"\"print(decompress)\n",
"print(np.mean(np.abs(decompress-no_ravel)))\"\"\"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3292b395",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "f9687830",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 13,
"id": "e98eed4b",
"metadata": {},
"outputs": [],
"source": [
"f = open(\"test.craw\", \"wb\")\n",
"f.write(real_pred.tobytes())\n",
"f.close()"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "b7e88aab",
"metadata": {},
"outputs": [],
"source": [
"# Apply arithmetic coding to compress it\n",
"import adaptive_arithmetic_compress\n",
"adaptive_arithmetic_compress.main([\"test.craw\", \"test.tiff\"])"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "7c8abaee",
"metadata": {},
"outputs": [ "outputs": [
{ {
"data": { "data": {
"text/plain": [ "text/plain": [
"'change = Image.open(\"test.tiff\")\\nchange = np.array(change)\\nprint(change.shape)'" "array([[ 0. , 0. , 0. , ..., 0. , 0. , 0. ],\n",
" [ 0. , 22327. , 22323. , ..., 22406.5, 22446. , 0. ],\n",
" [ 0. , 22350.5, 22335.5, ..., 22429. , 22390. , 0. ],\n",
" ...,\n",
" [ 0. , 22099. , 22125. , ..., 22823.5, 22817. , 0. ],\n",
" [ 0. , 22140. , 22172.5, ..., 22774. , 22771. , 0. ],\n",
" [ 0. , 0. , 0. , ..., 0. , 0. , 0. ]])"
] ]
}, },
"execution_count": 11, "execution_count": 48,
"metadata": {}, "metadata": {},
"output_type": "execute_result" "output_type": "execute_result"
} }
], ],
"source": [ "source": [
"\"\"\"change = Image.open(\"test.tiff\")\n", "prediction = new_pred.reshape((510,638))\n",
"change = np.array(change)\n", "prediction = np.pad(prediction, pad_width=1)"
"print(change.shape)\"\"\""
]
},
{
"cell_type": "code",
"execution_count": 114,
"id": "82c20d94",
"metadata": {},
"outputs": [],
"source": [
"def compress(inputFile):#, outputFile):\n",
" twoBytes = 256*256\n",
" # Read the input file into a numpy array of 8-bit values\n",
" #\n",
" # The img.shape is a 3-type with rows,columns,channels, where\n",
" # channels is the number of components in each pixel. The img.dtype\n",
" # is 'uint8', meaning that each component is an 8-bit unsigned\n",
" # integer.\n",
"\n",
" #img = netpbm.imread(inputFile).astype('uint8')\n",
" img = Image.open(inputFile) #Open the image and read it as an Image object\n",
" img = np.array(img)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data\n",
" img = img.astype('uint8')\n",
"\n",
"\n",
" # Compress the image\n",
" #\n",
" #\n",
" # Note that single-channel images will have a 'shape' with only two\n",
" # components: the y dimensions and the x dimension. So you will\n",
" # have to detect this and set the number of channels accordingly.\n",
" # Furthermore, single-channel images must be indexed as img[y,x]\n",
" # instead of img[y,x,1]. You'll need two pieces of similar code:\n",
" # one piece for the single-channel case and one piece for the\n",
" # multi-channel case.\n",
"\n",
" #startTime = time.time()\n",
"\n",
" outputBytes = bytearray()\n",
"\n",
" # initialize dictionary\n",
" d = {}\n",
" counter = 256\n",
" for i in range(-counter, counter):\n",
" d[str(i)] = i\n",
" # Set Dictionary limit\n",
"\n",
" # Make a list to hold bytes\n",
" tempBytes = []\n",
" # A counter for the number of bytes\n",
" numBytes = 0\n",
" multichannel = False\n",
" \n",
" # for a single channel image\n",
" if (len(img.shape) == 2) :\n",
" multichannel = False\n",
" \n",
" # Go through whole image\n",
" for y in range(img.shape[0]):\n",
" for x in range(img.shape[1]):\n",
" # Initialize prediction to image value\n",
" prediction = img[y][x]\n",
" #\"\"\" \n",
" # Modify prediction to show the difference between prior pixels and current pixel\n",
" if(x != 0):\n",
" prediction = prediction - img[y][x-1]\n",
" elif(y != 0):\n",
" prediction = prediction - img[y-1][x]\n",
" else:\n",
" prediction = prediction - (img[y][x-1]/3 + img[y-1][x]/3 + img[y-1][x-1]/3)\n",
" #\"\"\"\n",
" # Add the predicted value to the bytestream\n",
" tempBytes.append(prediction)\n",
" numBytes += 1\n",
" # Using a string variable as it allows for concatenation\n",
" s = \"\"\n",
" # Set s to the first value of the bytestream \n",
" s = str(int(tempBytes[0]))\n",
" # Go through all bytes\n",
" for i in range(1, numBytes):\n",
" # Do LZW encoding\n",
" # If trying to add entry larger than max size of the dictionary reinitialize the dictionary\n",
" if(counter >= twoBytes):\n",
" counter = 256\n",
" d = {}\n",
" for i in range(-counter, counter):\n",
" d[str(i)] = i\n",
"\n",
" # Add the next byte to the current string. Uses a delimeter to distinguish numbers\n",
" w = s +\"|\"+str(int(tempBytes[i]))\n",
" # Checking if it has been seen before\n",
" if w in d:\n",
" s = w\n",
" else:\n",
" # Output bytes by splitting integer into two bytes, this allows for a larger dictionary\n",
" outputBytes.append((int(d[s]) >> 8) & 0xFF)\n",
" outputBytes.append(int(d[s]) & 0xFF)\n",
" # Add to dictionarry\n",
" d[w] = counter\n",
" counter += 1\n",
" s = str(int(tempBytes[i]))\n",
" # Check if the last byte was added or not \n",
" if s in d: \n",
" outputBytes.append((int(d[s]) >> 8) & 0xFF)\n",
" outputBytes.append(int(d[s]) & 0xFF) \n",
" return numBytes, outputBytes, tempBytes"
]
},
{
"cell_type": "code",
"execution_count": 123,
"id": "9190b5a8",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\calle\\AppData\\Local\\Temp/ipykernel_1700/265550185.py:56: RuntimeWarning: overflow encountered in ubyte_scalars\n",
" prediction = prediction - img[y][x-1]\n",
"C:\\Users\\calle\\AppData\\Local\\Temp/ipykernel_1700/265550185.py:58: RuntimeWarning: overflow encountered in ubyte_scalars\n",
" prediction = prediction - img[y-1][x]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"245\n"
]
}
],
"source": [
"test = images[0]\n",
"comp, out, temp = compress(test)\n",
"print(out[19])"
] ]
} }
], ],
......
Error_to_Image.ipynb 0 → 100644
View file @ aad13dd4
{
"cells": [
{
"cell_type": "code",
"execution_count": 3,
"id": "dbef8759",
"metadata": {
"id": "dbef8759"
},
"outputs": [],
"source": [
"import numpy as np\n",
"from prediction_MSE_Scout import file_extractor, image_extractor, im_distribution\n",
"from matplotlib import pyplot as plt\n",
"from itertools import product\n",
"import os\n",
"import sys\n",
"from PIL import Image\n",
"from scipy.optimize import minimize\n",
"from time import time\n",
"from numpy import linalg as la\n",
"from scipy.stats import gaussian_kde\n",
"import seaborn as sns\n",
"import pywt"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "9ed20f84",
"metadata": {
"id": "9ed20f84"
},
"outputs": [],
"source": [
"def plot_hist(tiff_list, i=0):\n",
" \"\"\"\n",
" This function is the leftovers from the first attempt to plot histograms.\n",
" As it stands it needs some work in order to function again. We will\n",
" fix this later. 1/25/22\n",
" \"\"\"\n",
" \n",
" image = tiff_list[i]\n",
" image = Image.open(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",
" \n",
" A = np.array([[3,0,-1],[0,3,3],[1,-3,-4]]) # the matrix for system of equation\n",
" \n",
" z0 = image[0:-2,0:-2] # get all the first pixel for the entire image\n",
" z1 = image[0:-2,1:-1] # get all the second pixel for the entire image\n",
" z2 = image[0:-2,2::] # get all the third pixel for the entire image\n",
" z3 = image[1:-1,0:-2] # get all the forth pixel for the entire image\n",
" \n",
" # calculate the out put of the system of equation\n",
" y0 = np.ravel(-z0+z2-z3)\n",
" y1 = np.ravel(z0+z1+z2)\n",
" y2 = np.ravel(-z0-z1-z2-z3)\n",
" y = np.vstack((y0,y1,y2))\n",
" \n",
" # use numpy solver to solve the system of equations all at once\n",
" predict = np.linalg.solve(A,y)[-1]\n",
" #predict = []\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",
" # calculate the difference\n",
" diff = np.max(neighbor,axis = 1) - np.min(neighbor, axis=1)\n",
" \n",
" \n",
" # flatten the image to a vector\n",
" small_image = image[1:-1,1:-1]\n",
" \n",
" #Reshape the predictions to be a 2D array\n",
" predict = np.pad(predict.reshape(510,638), pad_width=1)\n",
" predict[0,:] = image[0,:]\n",
" predict[:,0] = image[:,0]\n",
" predict[:,-1] = image[:,-1]\n",
" predict[-1,:] = image[-1,:]\n",
" \n",
" \n",
" #Calculate the error between the original image and our predictions\n",
" #Note that we only predicted on the inside square of the original image, excluding\n",
" #The first row, column and last row, column\n",
" error = image - predict\n",
"\n",
" \n",
" return predict, diff, image, error, A"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "de1e8dc9",
"metadata": {},
"outputs": [],
"source": [
"scenes = file_extractor()\n",
"images = image_extractor(scenes)\n",
"num_images = im_distribution(images, \"_1\")"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "8b046cba",
"metadata": {},
"outputs": [],
"source": [
"predict, diff, im, err, A = plot_hist(num_images, 0)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c13a239a",
"metadata": {},
"outputs": [],
"source": [
"def reconstruct(error, A):\n",
" \"\"\"\n",
" Function that reconstructs the original image\n",
" from the error matrix and using the predictive\n",
" algorithm developed in the encoding.\n",
" \n",
" Parameters:\n",
" error (array): matrix of errors computed in encoding. Same \n",
" shape as the original image (512, 640) in this case\n",
" A (array): Matrix used for the system of equations to create predictions\n",
" Returns: \n",
" image (array): The reconstructed image\n",
" \"\"\"\n",
" "
]
}
],
"metadata": {
"colab": {
"collapsed_sections": [],
"name": "Wavelet_Huffman.ipynb",
"provenance": []
},
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.11"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
Scout_Compression_Exp.ipynb 0 → 100644
View file @ aad13dd4
{
"cells": [
{
"cell_type": "code",
"execution_count": 3,
"id": "9d3f0b36",
"metadata": {},
"outputs": [],
"source": [
"from prediction_MSE_Scout import file_extractor, image_extractor, im_distribution\n",
"import numpy as np\n",
"from matplotlib import pyplot as plt\n",
"import os\n",
"import sys\n",
"from PIL import Image\n",
"import math"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "e20525b8",
"metadata": {},
"outputs": [],
"source": [
"scenes = file_extractor()\n",
"images = image_extractor(scenes)\n",
"num_images = im_distribution(images, \"_1\")"
]
},
{
"cell_type": "code",
"execution_count": 65,
"id": "837df9c4",
"metadata": {},
"outputs": [],
"source": [
"def compress(inputFile):\n",
" twoBytes = 256*256\n",
" # Read the input file into a numpy array of 8-bit values\n",
" #\n",
" # The img.shape is a 3-type with rows,columns,channels, where\n",
" # channels is the number of components in each pixel. The img.dtype\n",
" # is 'uint8', meaning that each component is an 8-bit unsigned\n",
" # integer.\n",
"\n",
" #img = netpbm.imread(inputFile).astype('uint8')\n",
" img = Image.open(inputFile) #Open the image and read it as an Image object\n",
" img = np.array(img)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data\n",
" img = img.astype('uint8')\n",
"\n",
" # Compress the image\n",
" #\n",
" #\n",
" # Note that single-channel images will have a 'shape' with only two\n",
" # components: the y dimensions and the x dimension. So you will\n",
" # have to detect this and set the number of channels accordingly.\n",
" # Furthermore, single-channel images must be indexed as img[y,x]\n",
" # instead of img[y,x,1]. You'll need two pieces of similar code:\n",
" # one piece for the single-channel case and one piece for the\n",
" # multi-channel case.\n",
"\n",
" #startTime = time.time()\n",
"\n",
" outputBytes = bytearray()\n",
"\n",
" # initialize dictionary\n",
" d = {}\n",
" counter = 256\n",
" for i in range(-counter, counter):\n",
" d[str(i)] = i\n",
" # Set Dictionary limit\n",
"\n",
" # Make a list to hold bytes\n",
" tempBytes = []\n",
" # A counter for the number of bytes\n",
" numBytes = 0\n",
" multichannel = False\n",
" \n",
" # for a single channel image\n",
" if (len(img.shape) == 2) :\n",
" multichannel = False\n",
" \n",
" # Go through whole image\n",
" for y in range(img.shape[0]):\n",
" for x in range(img.shape[1]):\n",
" # Initialize prediction to image value\n",
" prediction = img[y][x]\n",
" #\"\"\" \n",
" # Modify prediction to show the difference between prior pixels and current pixel\n",
" if(x != 0):\n",
" prediction = prediction - img[y][x-1]\n",
" elif(y != 0):\n",
" prediction = prediction - img[y-1][x]\n",
" else:\n",
" prediction = prediction - (img[y][x-1]/3 + img[y-1][x]/3 + img[y-1][x-1]/3)\n",
" #\"\"\"\n",
" # Add the predicted value to the bytestream\n",
" tempBytes.append(prediction)\n",
" numBytes += 1\n",
" # Using a string variable as it allows for concatenation\n",
" s = \"\"\n",
" # Set s to the first value of the bytestream \n",
" s = str(int(tempBytes[0]))\n",
" # Go through all bytes\n",
" for i in range(1, numBytes):\n",
" # Do LZW encoding\n",
" # If trying to add entry larger than max size of the dictionary reinitialize the dictionary\n",
" if(counter >= twoBytes):\n",
" counter = 256\n",
" d = {}\n",
" for i in range(-counter, counter):\n",
" d[str(i)] = i\n",
"\n",
" # Add the next byte to the current string. Uses a delimeter to distinguish numbers\n",
" w = s +\"|\"+str(tempBytes[i])\n",
" \n",
" # Checking if it has been seen before\n",
" if w in d:\n",
" s = w\n",
" \n",
" else:\n",
" # Output bytes by splitting integer into two bytes, this allows for a larger dictionary\n",
" outputBytes.append((int(d[s]) >> 8) & 0xFF)\n",
" outputBytes.append(int(d[s]) & 0xFF)\n",
" # Add to dictionarry\n",
" d[w] = counter\n",
" counter += 1\n",
" s = str(int(tempBytes[i]))\n",
" # Check if the last byte was added or not \n",
" if s in d: \n",
" outputBytes.append((int(d[s]) >> 8) & 0xFF)\n",
" outputBytes.append(int(d[s]) & 0xFF)\n",
" \n",
" \n",
" \n",
" return outputBytes, img.shape[0], img.shape[1]"
]
},
{
"cell_type": "code",
"execution_count": 64,
"id": "dec67245",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"103\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\calle\\AppData\\Local\\Temp/ipykernel_12604/4289951463.py:56: RuntimeWarning: overflow encountered in ubyte_scalars\n",
" prediction = prediction - img[y][x-1]\n",
"C:\\Users\\calle\\AppData\\Local\\Temp/ipykernel_12604/4289951463.py:58: RuntimeWarning: overflow encountered in ubyte_scalars\n",
" prediction = prediction - img[y-1][x]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"245\n"
]
}
],
"source": [
"test = images[0]\n",
"out, rows, cols = compress(test)\n",
"print(out[19])"
]
},
{
"cell_type": "code",
"execution_count": 55,
"id": "51938ebb",
"metadata": {},
"outputs": [],
"source": [
"# Uncompress an image\n",
"\n",
"def uncompress(byteArray, rows, columns):\n",
" twoBytes = 256*256\n",
" # Check that it's a known file\n",
"\n",
" \"\"\"if inputFile.readline() != headerText + '\\n':\n",
" sys.stderr.write( \"Input is not in the '%s' format.\\n\" % headerText )\n",
" sys.exit(1)\"\"\"\n",
" \n",
" # Read the rows, columns, and channels. counter\n",
"\n",
" #rows, columns, channels = [ int(x) for x in inputFile.readline().split() ]\n",
"\n",
" # Read the raw bytes.\n",
"\n",
" inputBytes = byteArray\n",
"\n",
" # Build the image\n",
" #\n",
" # REPLACE THIS WITH YOUR OWN CODE TO CONVERT THE 'inputBytes' ARRAY INTO AN IMAGE IN 'img'.\n",
" \n",
"\n",
" result = []\n",
"\n",
" # initialize the dictionary in the opposite was as compress and use an array as the value\n",
" d = {} # create a dictionary\n",
" counter = 256\n",
" \n",
" # Initialize dictionary with values equalling keys from [-256,256]\n",
" for i in range(-counter, counter):\n",
" d[i] = [i]\n",
"\n",
" img = np.empty([rows,columns], dtype=np.uint8 )\n",
"\n",
" byteIter = iter(inputBytes)\n",
"\n",
" # Get encoding in the form of next two bytes\n",
" new = (byteIter.__next__() >> 8) + byteIter.__next__()\n",
" s = d[new]\n",
" \n",
" result.append(s[0])\n",
"\n",
" for i in range(1, len(inputBytes)//2):\n",
" \n",
" # again reset the dictionary if it reaches the limit\n",
" # Initialize dictionary with values equalling keys from [-256,256]\n",
"\n",
" if counter >= twoBytes:\n",
" d = {} # initialize blank dictionary\n",
" counter = 256\n",
" for i in range(-counter, counter):\n",
" d[i] = [i]\n",
" \n",
" \n",
" new = (byteIter.__next__() >> 8) + byteIter.__next__()\n",
"\n",
" #retrieve value of dictionary entry from dictionary or create entry assuming it has not yet been entered into dictionary\n",
" \n",
" if new in d:\n",
" d_value = d[new]\n",
" else:\n",
" d_value = []\n",
" for j in s:\n",
" d_value.append(j)\n",
" d_value.append(s[0])\n",
" \n",
" #add dictionary entry value to the result\n",
" for k in range(len(d_value)):\n",
" result.append(d_value[k])\n",
"\n",
" #Create entry in dictionary\n",
" temp = []\n",
" for j in s:\n",
" temp.append(j)\n",
" temp.append(s[0])\n",
" d[counter] = temp\n",
" counter += 1\n",
" \n",
" \n",
" # reset decoded string to dictionary entry value\n",
" s = d_value\n",
" \n",
" print(result[:20])\n",
" channels = 1\n",
" \n",
" #implement predictive encoding\n",
" prediction = 0\n",
" counter = 0\n",
"\n",
" # for a single channel image\n",
" if (channels == 1):\n",
" # Go through whole image\n",
" for y in range(rows):\n",
" for x in range(columns):\n",
" #'''\n",
" if(x != 0):\n",
" prediction = img[y][x-1]\n",
" elif(y != 0):\n",
" prediction = img[y-1][x]\n",
" else:\n",
" prediction = (img[y][x-1]/3 + img[y-1][x]/3 + img[y-1][x-1]/3)\n",
" #'''\n",
" img[y,x] = result[counter] + prediction\n",
" counter += 1\n",
" \n",
" return img\n",
"\n",
" # Output the image\n",
"\n",
" #netpbm.imsave( outputFile, img )\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 56,
"id": "74528264",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[164, 246, 24, 0, 4, 239, 251, 13, 12, 245, 246, 6, 6, 250, 0, 0, 3, 4, 242, 0]\n"
]
},
{
"ename": "IndexError",
"evalue": "list index out of range",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_12604/601870618.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mimgg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0muncompress\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mout\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrows\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcols\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_12604/2882586717.py\u001b[0m in \u001b[0;36muncompress\u001b[1;34m(byteArray, rows, columns)\u001b[0m\n\u001b[0;32m 102\u001b[0m \u001b[0mprediction\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m3\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mimg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m3\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mimg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 103\u001b[0m \u001b[1;31m#'''\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 104\u001b[1;33m \u001b[0mimg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mresult\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mcounter\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mprediction\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 105\u001b[0m \u001b[0mcounter\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 106\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
"\u001b[1;31mIndexError\u001b[0m: list index out of range"
]
}
],
"source": [
"imgg = uncompress(out, rows, cols)"
]
},
{
"cell_type": "code",
"execution_count": 67,
"id": "ea5c3c61",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,\n",
" 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,\n",
" 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,\n",
" 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,\n",
" 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,\n",
" 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,\n",
" 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,\n",
" 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,\n",
" 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,\n",
" 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,\n",
" 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,\n",
" 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,\n",
" 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,\n",
" 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181,\n",
" 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,\n",
" 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,\n",
" 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,\n",
" 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,\n",
" 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,\n",
" 247, 248, 249, 250, 251, 252, 253, 254, 255], dtype=uint8)"
]
},
"execution_count": 67,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"img = Image.open(test) #Open the image and read it as an Image object\n",
"img = np.array(img)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data\n",
"img = img.astype('uint8')\n",
"np.unique(img.ravel())"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.11"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
Wavelet_Huffman.ipynb deleted 100644 → 0
View file @ 1037f11d
{
"cells": [
{
"cell_type": "code",
"execution_count": 6,
"id": "dbef8759",
"metadata": {
"id": "dbef8759"
},
"outputs": [],
"source": [
"import numpy as np\n",
"from matplotlib import pyplot as plt\n",
"from itertools import product\n",
"import os\n",
"import sys\n",
"from PIL import Image\n",
"from scipy.optimize import minimize\n",
"from time import time\n",
"from numpy import linalg as la\n",
"from scipy.stats import gaussian_kde\n",
"import seaborn as sns\n",
"import pywt\n",
"import dippykit as dp"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "b7a550e0",
"metadata": {
"id": "b7a550e0"
},
"outputs": [],
"source": [
"def file_extractor(dirname=\"images\"):\n",
" files = os.listdir(dirname)\n",
" scenes = []\n",
" for file in files:\n",
" scenes.append(os.path.join(dirname, file))\n",
" return scenes\n",
"\n",
"def image_extractor(scenes):\n",
" image_folder = []\n",
" for scene in scenes:\n",
" files = os.listdir(scene)\n",
" for file in files:\n",
" image_folder.append(os.path.join(scene, file))\n",
" images = []\n",
" for folder in image_folder:\n",
" ims = os.listdir(folder)\n",
" for im in ims:\n",
" if im[-4:] == \".jp4\" or im[-7:] == \"_6.tiff\":\n",
" continue\n",
" else:\n",
" images.append(os.path.join(folder, im))\n",
" return images #returns a list of file paths to .tiff files in the specified directory given in file_extractor\n",
"\n",
"def im_distribution(images, num):\n",
" \"\"\"\n",
" Function that extracts tiff files from specific cameras and returns a list of all\n",
" the tiff files corresponding to that camera. i.e. all pictures labeled \"_7.tiff\" or otherwise\n",
" specified camera numbers.\n",
" \n",
" Parameters:\n",
" images (list): list of all tiff files, regardless of classification. This is NOT a list of directories but\n",
" of specific tiff files that can be opened right away. This is the list that we iterate through and \n",
" divide.\n",
" \n",
" num (str): a string designation for the camera number that we want to extract i.e. \"14\" for double digits\n",
" of \"_1\" for single digits.\n",
" \n",
" Returns:\n",
" tiff (list): A list of tiff files that have the specified designation from num. They are the files extracted\n",
" from the 'images' list that correspond to the given num.\n",
" \"\"\"\n",
" tiff = []\n",
" for im in images:\n",
" if im[-7:-5] == num:\n",
" tiff.append(im)\n",
" return tiff"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "9ed20f84",
"metadata": {
"id": "9ed20f84"
},
"outputs": [],
"source": [
"def plot_hist(tiff_list, i):\n",
" \"\"\"\n",
" This function is the leftovers from the first attempt to plot histograms.\n",
" As it stands it needs some work in order to function again. We will\n",
" fix this later. 1/25/22\n",
" \"\"\"\n",
" \n",
" image = tiff_list[i]\n",
" image = Image.open(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",
" A = np.array([[3,0,-1],[0,3,3],[1,-3,-4]]) # the matrix for system of equation\n",
" z0 = image[0:-2,0:-2] # get all the first pixel for the entire image\n",
" z1 = image[0:-2,1:-1] # get all the second pixel for the entire image\n",
" z2 = image[0:-2,2::] # get all the third pixel for the entire image\n",
" z3 = image[1:-1,0:-2] # get all the forth pixel for the entire image\n",
" # calculate the out put of the system of equation\n",
" y0 = np.ravel(-z0+z2-z3)\n",
" y1 = np.ravel(z0+z1+z2)\n",
" y2 = np.ravel(-z0-z1-z2-z3)\n",
" y = np.vstack((y0,y1,y2))\n",
" # use numpy solver to solve the system of equations all at once\n",
" predict = np.linalg.solve(A,y)[-1]\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",
" # calculate the difference\n",
" diff = np.max(neighbor,axis = 1) - np.min(neighbor, axis=1)\n",
" # flatten the image to a vector\n",
" image_ravel = np.ravel(image[1:-1,1:-1])\n",
" return image_ravel, predict, diff, image"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "8e3ef654",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 357
},
"id": "8e3ef654",
"outputId": "92f06bb6-c1ab-4e46-e53d-385ed892c7d9"
},
"outputs": [
{
"output_type": "error",
"ename": "FileNotFoundError",
"evalue": "ignored",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-9-80eed1605ff2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mscenes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfile_extractor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mimages\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimage_extractor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscenes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mnum_images\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mim_distribution\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimages\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"_9\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0merror_mean\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0merror_mean1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;32m<ipython-input-7-8baf51e34e4c>\u001b[0m in \u001b[0;36mfile_extractor\u001b[0;34m(dirname)\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfile_extractor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdirname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"images\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mfiles\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdirname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mscenes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mfile\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfiles\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mscenes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdirname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'images'"
]
}
],
"source": [
"scenes = file_extractor()\n",
"images = image_extractor(scenes)\n",
"num_images = im_distribution(images, \"_9\")\n",
"error_mean = []\n",
"error_mean1 = []\n",
"diff_mean = []\n",
"times = []\n",
"times1 = []\n",
"all_error = []\n",
"for i in range(len(num_images)):\n",
" \"\"\"start1 = time()\n",
" image_1, predict_1, difference_1, x_s_1 = plot_hist(num_images, i, \"second\")\n",
" stop1 = time()\n",
" times1.append(stop1-start1)\n",
" error1 = np.abs(image_1-predict_1)\n",
" error_mean1.append(np.mean(np.ravel(error1)))\"\"\"\n",
" start = time()\n",
" image, predict, difference, non_ravel = plot_hist(num_images, i)\n",
" stop = time()\n",
" times.append(stop-start)\n",
" error = np.abs(image-predict)\n",
" all_error.append(np.ravel(error))\n",
" error_mean.append(np.mean(np.ravel(error)))\n",
" diff_mean.append(np.mean(np.ravel(difference)))\n",
" \n",
"#image, predict, difference = plot_hist(images, 0)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fa65dcd6",
"metadata": {
"id": "fa65dcd6",
"outputId": "254b4654-1566-4e76-b774-e5a920819891"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Average Error First and Second Added: 20.017164930235474\n",
"Standard Deviaiton of Mean Errors: 0.16101183692475135\n",
"Average Difference: 53.678648426455226\n",
"Average Time per Image for First: 0.10891032218933105\n"
]
}
],
"source": [
"print(f\"Average Error First and Second Added: {np.mean(error_mean)}\")\n",
"print(f\"Standard Deviaiton of Mean Errors: {np.sqrt(np.var(error_mean))}\")\n",
"print(f\"Average Difference: {np.mean(diff_mean)}\")\n",
"print(f\"Average Time per Image for First: {np.mean(times)}\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4c05b947",
"metadata": {
"id": "4c05b947"
},
"outputs": [],
"source": [
"new_image, new_pred, new_diff, no_ravel = plot_hist(images, 10)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dda442ae",
"metadata": {
"id": "dda442ae",
"outputId": "98bbbfe0-e9d8-46f9-89af-fd3f226b6b58"
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"new_error = np.abs(new_image-new_pred)\n",
"plt.hist(new_error, bins=20, density=True)\n",
"sns.kdeplot(new_error)\n",
"plt.xlabel(\"error\")\n",
"plt.show()\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "58da6063",
"metadata": {
"id": "58da6063",
"outputId": "8529b3dd-68a5-4a10-8310-0549a2af2319"
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.hist(new_image, bins=25, density=True)\n",
"sns.kdeplot(new_image)\n",
"plt.xlabel(\"Actual Pixel Value\")\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2562feeb",
"metadata": {
"scrolled": false,
"id": "2562feeb",
"outputId": "3838d616-2eda-49c5-d434-45acf24cfe5b"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(512, 640)\n",
"1310832\n",
"9\n"
]
}
],
"source": [
"f_r = no_ravel[0]\n",
"print(no_ravel.shape)\n",
"print(sys.getsizeof(no_ravel))\n",
"print((256).bit_length())"
]
},
{
"cell_type": "code",
"execution_count": 31,
"id": "470cc137",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 235
},
"id": "470cc137",
"outputId": "2c9b7aa9-74b9-41db-d1ee-39bb20a005b5"
},
"outputs": [
{
"output_type": "error",
"ename": "NameError",
"evalue": "ignored",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-31-7c411a9343d9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcoeffs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpywt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdwt2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mno_ravel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'bior1.3'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcoeffs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mLL\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mLH\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mHL\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mHH\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcoeffs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mdecompress\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpywt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0midwt2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcoeffs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'bior1.3'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdecompress\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mno_ravel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mNameError\u001b[0m: name 'no_ravel' is not defined"
]
}
],
"source": [
"coeffs = pywt.dwt2(no_ravel, 'bior1.3')\n",
"print(len(coeffs))\n",
"LL, (LH, HL, HH) = coeffs\n",
"decompress = pywt.idwt2(coeffs, 'bior1.3')\n",
"print(np.mean(np.abs(decompress-no_ravel)))\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3292b395",
"metadata": {
"id": "3292b395",
"outputId": "a01866ee-fa9d-4f78-c36a-a24b76ee2c34"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[72, 101, 108, 108, 111, 32, 109, 121, 32, 110, 97, 109, 101, 32, 105, 115, 32, 83, 99, 111, 117, 116]\n",
"256\n",
"71\n"
]
}
],
"source": [
"def compress(uncompressed):\n",
" \"\"\"Compress a string to a list of output symbols.\"\"\"\n",
" \n",
" # Build the dictionary.\n",
" dict_size = 256\n",
" dictionary = dict((chr(i), i) for i in range(dict_size))\n",
" # in Python 3: dictionary = {chr(i): i for i in range(dict_size)}\n",
"\n",
" w = \"\"\n",
" result = []\n",
" for c in uncompressed:\n",
" wc = w + c\n",
" if wc in dictionary:\n",
" w = wc\n",
" else:\n",
" result.append(dictionary[w])\n",
" # Add wc to the dictionary.\n",
" dictionary[wc] = dict_size\n",
" dict_size += 1\n",
" w = c\n",
" \n",
" # Output the code for w.\n",
" if w:\n",
" result.append(dictionary[w])\n",
" return result\n",
"\n",
"store = compress(\"Hello my name is Scout\")\n",
"print(store)\n",
"print(sys.getsizeof(store))\n",
"print(sys.getsizeof(\"Hello my name is Scout\"))"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f9687830",
"metadata": {
"id": "f9687830",
"outputId": "1ebd287f-e5e6-4993-b78c-5c0d46f7b9b0"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.01910218596458435\n"
]
}
],
"source": [
"def wavelet(num_images, i): \n",
"\n",
" image = Image.open(num_images[i]) #Open the image and read it as an Image object\n",
" image = np.array(im)[1:,:]\n",
" coeffs = pywt.dwt2(image, 'bior1.3')\n",
" return coeffs\n",
"\n",
"def huffman(coeffs):\n",
" for i in range(len(coeffs)):\n",
" \n",
"\n",
"coef = wavelet(num_images)\n",
"\n",
"def wave_decompress(coeffs):\n",
" times = []\n",
" for i in range(len(coeffs)):\n",
" start = time()\n",
" decompress = pywt.idwt2(coeffs[i], 'bior1.3')\n",
" stop = time()\n",
" times.append(stop-start)\n",
" return times\n",
"ti = wave_decompress(coef)\n",
"print(np.mean(ti))"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "e98eed4b",
"metadata": {
"id": "e98eed4b"
},
"outputs": [],
"source": [
"image_huff = Image.open(\"1640843156_729797_0.tiff\")\n",
"image_huff = np.array(image_huff)[1:,:]\n",
"a, (b,c,d) = pywt.dwt2(image_huff, 'bior1.3')\n",
"coeffs = [a.astype(int), b.astype(int), c.astype(int), d.astype(int)]\n",
"huffs = []\n",
"for i in range(len(coeffs)):\n",
" huffs.append(dp.coding.huffman_encode(coeffs[i].ravel()))"
]
},
{
"cell_type": "code",
"execution_count": 39,
"id": "b7e88aab",
"metadata": {
"id": "b7e88aab"
},
"outputs": [],
"source": [
"recon_coeff = []\n",
"for i in range(len(huffs)):\n",
" recon_coeff.append(dp.coding.huffman_decode(huffs[i][0], huffs[i][2], huffs[i][1]))\n",
"coeffs = recon_coeff[0].reshape((258,322)), (recon_coeff[1].reshape((258,322)),\\\n",
" recon_coeff[2].reshape((258,322)), recon_coeff[3].reshape((258,322)))\n",
"decompress = pywt.idwt2(coeffs, 'bior1.3')"
]
},
{
"cell_type": "code",
"source": [
"print(np.mean(np.abs(decompress-image_huff)))"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "syg2KPtp5c68",
"outputId": "bfd2ffaa-b942-45c0-af8a-1b7d8a2a14e9"
},
"id": "syg2KPtp5c68",
"execution_count": 40,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"0.46880903243908045\n"
]
}
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.11"
},
"colab": {
"name": "Wavelet_Huffman.ipynb",
"provenance": [],
"collapsed_sections": []
}
},
"nbformat": 4,
"nbformat_minor": 5
}
\ No newline at end of file
prediction_MSE_Scout.ipynb
View file @ aad13dd4
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
"cells": [ "cells": [
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 72, "execution_count": 1,
"id": "dbef8759", "id": "dbef8759",
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
...@@ -25,7 +25,7 @@ ...@@ -25,7 +25,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 15, "execution_count": 2,
"id": "b7a550e0", "id": "b7a550e0",
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
...@@ -80,7 +80,7 @@ ...@@ -80,7 +80,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 16, "execution_count": 32,
"id": "9ed20f84", "id": "9ed20f84",
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
...@@ -133,7 +133,7 @@ ...@@ -133,7 +133,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 17, "execution_count": 34,
"id": "8e3ef654", "id": "8e3ef654",
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
...@@ -168,7 +168,7 @@ ...@@ -168,7 +168,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 18, "execution_count": 35,
"id": "fa65dcd6", "id": "fa65dcd6",
"metadata": {}, "metadata": {},
"outputs": [ "outputs": [
...@@ -179,7 +179,7 @@ ...@@ -179,7 +179,7 @@
"Average Error: 19.44221679267325\n", "Average Error: 19.44221679267325\n",
"Standard Deviaiton of Mean Errors: 0.17734010606906342\n", "Standard Deviaiton of Mean Errors: 0.17734010606906342\n",
"Average Difference: 51.95430150900486\n", "Average Difference: 51.95430150900486\n",
"Average Time per Image for First: 0.04917508363723755\n" "Average Time per Image for First: 0.050624340772628784\n"
] ]
} }
], ],
...@@ -192,7 +192,7 @@ ...@@ -192,7 +192,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 19, "execution_count": 6,
"id": "4c05b947", "id": "4c05b947",
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
...@@ -202,13 +202,13 @@ ...@@ -202,13 +202,13 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 21, "execution_count": 28,
"id": "dda442ae", "id": "dda442ae",
"metadata": {}, "metadata": {},
"outputs": [ "outputs": [
{ {
"data": { "data": {
"image/png": "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\n", "image/png": "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\n",
"text/plain": [ "text/plain": [
"<Figure size 432x288 with 1 Axes>" "<Figure size 432x288 with 1 Axes>"
] ]
...@@ -220,7 +220,7 @@ ...@@ -220,7 +220,7 @@
} }
], ],
"source": [ "source": [
"new_error = new_image-new_pred\n", "new_error = (new_image-new_pred).astype(np.int32)\n",
"plt.hist(new_error, bins=20, density=True)\n", "plt.hist(new_error, bins=20, density=True)\n",
"sns.kdeplot(new_error)\n", "sns.kdeplot(new_error)\n",
"plt.xlabel(\"error\")\n", "plt.xlabel(\"error\")\n",
...@@ -229,289 +229,30 @@ ...@@ -229,289 +229,30 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 41, "execution_count": 48,
"id": "58da6063", "id": "58da6063",
"metadata": {}, "metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Std Deviation of E: 26.627504708827136\n",
"Normal bits: 15\n",
"Encoded Bits: 6.677845333316752\n"
]
}
],
"source": [
"image = Image.open(images[0]) #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(np.int64)\n",
"print(\"Std Deviation of E: \", np.std(new_error))\n",
"print(\"Normal bits: \", int(image[0][0]).bit_length())\n",
"H = np.log2(np.std(new_error)) + 1.943\n",
"print(\"Encoded Bits: \", H)"
]
},
{
"cell_type": "code",
"execution_count": 47,
"id": "ec4db902",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"8192\n"
]
}
],
"source": []
},
{
"cell_type": "code",
"execution_count": 9,
"id": "2562feeb",
"metadata": {
"scrolled": false
},
"outputs": [],
"source": [
"pred = new_pred.reshape((510,638))\n",
"real_pred = no_ravel.copy()\n",
"real_pred[1:-1, 1:-1] = pred"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "470cc137",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(258, 322)\n"
]
},
{
"data": {
"text/plain": [
"'print(decompress)\\nprint(np.mean(np.abs(decompress-no_ravel)))'"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"coeffs = pywt.dwt2(no_ravel, 'bior1.3')\n",
"LL, (LH, HL, HH) = coeffs\n",
"print(HH.shape)\n",
"decompress = pywt.idwt2(coeffs, 'bior1.3')\n",
"\"\"\"print(decompress)\n",
"print(np.mean(np.abs(decompress-no_ravel)))\"\"\"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3292b395",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "f9687830",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 13,
"id": "e98eed4b",
"metadata": {},
"outputs": [],
"source": [
"f = open(\"test.craw\", \"wb\")\n",
"f.write(real_pred.tobytes())\n",
"f.close()"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "b7e88aab",
"metadata": {},
"outputs": [],
"source": [
"# Apply arithmetic coding to compress it\n",
"import adaptive_arithmetic_compress\n",
"adaptive_arithmetic_compress.main([\"test.craw\", \"test.tiff\"])"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "7c8abaee",
"metadata": {},
"outputs": [ "outputs": [
{ {
"data": { "data": {
"text/plain": [ "text/plain": [
"'change = Image.open(\"test.tiff\")\\nchange = np.array(change)\\nprint(change.shape)'" "array([[ 0. , 0. , 0. , ..., 0. , 0. , 0. ],\n",
" [ 0. , 22327. , 22323. , ..., 22406.5, 22446. , 0. ],\n",
" [ 0. , 22350.5, 22335.5, ..., 22429. , 22390. , 0. ],\n",
" ...,\n",
" [ 0. , 22099. , 22125. , ..., 22823.5, 22817. , 0. ],\n",
" [ 0. , 22140. , 22172.5, ..., 22774. , 22771. , 0. ],\n",
" [ 0. , 0. , 0. , ..., 0. , 0. , 0. ]])"
] ]
}, },
"execution_count": 11, "execution_count": 48,
"metadata": {}, "metadata": {},
"output_type": "execute_result" "output_type": "execute_result"
} }
], ],
"source": [ "source": [
"\"\"\"change = Image.open(\"test.tiff\")\n", "prediction = new_pred.reshape((510,638))\n",
"change = np.array(change)\n", "prediction = np.pad(prediction, pad_width=1)"
"print(change.shape)\"\"\""
]
},
{
"cell_type": "code",
"execution_count": 114,
"id": "82c20d94",
"metadata": {},
"outputs": [],
"source": [
"def compress(inputFile):#, outputFile):\n",
" twoBytes = 256*256\n",
" # Read the input file into a numpy array of 8-bit values\n",
" #\n",
" # The img.shape is a 3-type with rows,columns,channels, where\n",
" # channels is the number of components in each pixel. The img.dtype\n",
" # is 'uint8', meaning that each component is an 8-bit unsigned\n",
" # integer.\n",
"\n",
" #img = netpbm.imread(inputFile).astype('uint8')\n",
" img = Image.open(inputFile) #Open the image and read it as an Image object\n",
" img = np.array(img)[1:,:] #Convert to an array, leaving out the first row because the first row is just housekeeping data\n",
" img = img.astype('uint8')\n",
"\n",
"\n",
" # Compress the image\n",
" #\n",
" #\n",
" # Note that single-channel images will have a 'shape' with only two\n",
" # components: the y dimensions and the x dimension. So you will\n",
" # have to detect this and set the number of channels accordingly.\n",
" # Furthermore, single-channel images must be indexed as img[y,x]\n",
" # instead of img[y,x,1]. You'll need two pieces of similar code:\n",
" # one piece for the single-channel case and one piece for the\n",
" # multi-channel case.\n",
"\n",
" #startTime = time.time()\n",
"\n",
" outputBytes = bytearray()\n",
"\n",
" # initialize dictionary\n",
" d = {}\n",
" counter = 256\n",
" for i in range(-counter, counter):\n",
" d[str(i)] = i\n",
" # Set Dictionary limit\n",
"\n",
" # Make a list to hold bytes\n",
" tempBytes = []\n",
" # A counter for the number of bytes\n",
" numBytes = 0\n",
" multichannel = False\n",
" \n",
" # for a single channel image\n",
" if (len(img.shape) == 2) :\n",
" multichannel = False\n",
" \n",
" # Go through whole image\n",
" for y in range(img.shape[0]):\n",
" for x in range(img.shape[1]):\n",
" # Initialize prediction to image value\n",
" prediction = img[y][x]\n",
" #\"\"\" \n",
" # Modify prediction to show the difference between prior pixels and current pixel\n",
" if(x != 0):\n",
" prediction = prediction - img[y][x-1]\n",
" elif(y != 0):\n",
" prediction = prediction - img[y-1][x]\n",
" else:\n",
" prediction = prediction - (img[y][x-1]/3 + img[y-1][x]/3 + img[y-1][x-1]/3)\n",
" #\"\"\"\n",
" # Add the predicted value to the bytestream\n",
" tempBytes.append(prediction)\n",
" numBytes += 1\n",
" # Using a string variable as it allows for concatenation\n",
" s = \"\"\n",
" # Set s to the first value of the bytestream \n",
" s = str(int(tempBytes[0]))\n",
" # Go through all bytes\n",
" for i in range(1, numBytes):\n",
" # Do LZW encoding\n",
" # If trying to add entry larger than max size of the dictionary reinitialize the dictionary\n",
" if(counter >= twoBytes):\n",
" counter = 256\n",
" d = {}\n",
" for i in range(-counter, counter):\n",
" d[str(i)] = i\n",
"\n",
" # Add the next byte to the current string. Uses a delimeter to distinguish numbers\n",
" w = s +\"|\"+str(int(tempBytes[i]))\n",
" # Checking if it has been seen before\n",
" if w in d:\n",
" s = w\n",
" else:\n",
" # Output bytes by splitting integer into two bytes, this allows for a larger dictionary\n",
" outputBytes.append((int(d[s]) >> 8) & 0xFF)\n",
" outputBytes.append(int(d[s]) & 0xFF)\n",
" # Add to dictionarry\n",
" d[w] = counter\n",
" counter += 1\n",
" s = str(int(tempBytes[i]))\n",
" # Check if the last byte was added or not \n",
" if s in d: \n",
" outputBytes.append((int(d[s]) >> 8) & 0xFF)\n",
" outputBytes.append(int(d[s]) & 0xFF) \n",
" return numBytes, outputBytes, tempBytes"
]
},
{
"cell_type": "code",
"execution_count": 123,
"id": "9190b5a8",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\calle\\AppData\\Local\\Temp/ipykernel_1700/265550185.py:56: RuntimeWarning: overflow encountered in ubyte_scalars\n",
" prediction = prediction - img[y][x-1]\n",
"C:\\Users\\calle\\AppData\\Local\\Temp/ipykernel_1700/265550185.py:58: RuntimeWarning: overflow encountered in ubyte_scalars\n",
" prediction = prediction - img[y-1][x]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"245\n"
]
}
],
"source": [
"test = images[0]\n",
"comp, out, temp = compress(test)\n",
"print(out[19])"
] ]
} }
], ],
......
prediction_MSE_Scout.py 0 → 100644
View file @ aad13dd4
#!/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:
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
# 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)))"""
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment