Skip to content

I
Image Compression
Commit 18a92d19 authored by Kelly Chang's avatar Kelly Chang
Browse files
Options

Kelly

parent 697f75e8
Hide whitespace changes
Inline Side-by-side
Showing with 623 additions and 103 deletions
Encoding_Kelly.ipynb
View file @ 18a92d19
......@@ -24,7 +24,7 @@
},
{
"cell_type": "code",
"execution_count": 3,
"execution_count": 397,
"id": "76317b02",
"metadata": {},
"outputs": [],
......@@ -72,14 +72,14 @@
" \"\"\"\n",
" tiff = []\n",
" for im in images:\n",
" if im[-7:-6] == num:\n",
" if im[-7:-5] == num:\n",
" tiff.append(im)\n",
" return tiff"
]
},
{
"cell_type": "code",
"execution_count": 62,
"execution_count": 398,
"id": "be1ff8a1",
"metadata": {},
"outputs": [],
......@@ -125,7 +125,7 @@
},
{
"cell_type": "code",
"execution_count": 63,
"execution_count": 399,
"id": "8483903e",
"metadata": {},
"outputs": [],
......@@ -173,7 +173,7 @@
},
{
"cell_type": "code",
"execution_count": 86,
"execution_count": 400,
"id": "64a3a193",
"metadata": {},
"outputs": [],
......@@ -227,181 +227,690 @@
" return new_e"
]
},
{
"cell_type": "markdown",
"id": "c7104fbf",
"metadata": {},
"source": [
"### Huffman without dividing into bins"
]
},
{
"cell_type": "code",
"execution_count": 132,
"id": "91879f19",
"execution_count": 401,
"id": "a43f3f1c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"257\n"
"0.444949904726781\n"
]
},
}
],
"source": [
"scenes = file_extractor()\n",
"images = image_extractor(scenes)\n",
"def huffman_nb(image):\n",
" origin, predict, diff, error, A = plot_hist(image)\n",
" image = Image.open(image)\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",
" new_error = np.copy(image)\n",
" new_error[1:-1,1:-1] = np.reshape(error,(510, 638))\n",
" keep = new_error[0,0]\n",
" new_error[0,:] = new_error[0,:] - keep\n",
" new_error[-1,:] = new_error[-1,:] - keep\n",
" new_error[1:-1,0] = new_error[1:-1,0] - keep\n",
" new_error[1:-1,-1] = new_error[1:-1,-1] - keep\n",
" new_error[0,0] = keep\n",
" new_error = np.ravel(new_error)\n",
" \n",
" \n",
" \n",
" #ab_error = np.abs(new_error)\n",
" #string = [str(i) for i in ab_error]\n",
" string = [str(i) for i in new_error.astype(int)]\n",
" freq = dict(Counter(string))\n",
" \n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encoding = huffman_code_tree(node)\n",
" #encoded = [\"1\"+encoding[str(-i)] if i < 0 else \"0\"+encoding[str(i)] for i in error]\n",
" \n",
" # return the huffman dictionary\n",
" return encoding, new_error, image.reshape(-1)\n",
" \n",
" \n",
"def compress_rate_nb(image, error, encoding):\n",
" #original = original.reshape(-1)\n",
" #error = error.reshape(-1)\n",
" o_len = 0\n",
" c_len = 0\n",
" for i in range(0, len(original)):\n",
" o_len += len(bin(original[i])[2:])\n",
" c_len += len(encoding[str(int(error[i]))])\n",
"\n",
" \n",
" return c_len/o_len\n",
"\n",
"\n",
"encoding, error, image = huffman_nb(images[0])\n",
"print(compress_rate_nb(image, error, encoding))"
]
},
{
"cell_type": "markdown",
"id": "eac2f456",
"metadata": {},
"source": [
"### Huffman with dividing into non-uniform bins"
]
},
{
"cell_type": "code",
"execution_count": 407,
"id": "207b0bd2",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAD4CAYAAAAO9oqkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQCklEQVR4nO3df6zdd13H8efLwQjhR9bRS23azg6txkHi2JqtiWhQtOu2mI6oZPxhG1yoCVsCiSYW90cJk2SYgLERZ4Y0dAaZi4BrYFhKgxL/6OgdlHY/GL2MLmvTtYXODYMZTt/+cT53+VrO6b29v865vc9HcnK+5/39nu95n2+/97z6/XG+J1WFJGlp+5lhNyBJGj7DQJJkGEiSDANJEoaBJAl4xbAbmKnly5fX2rVrh92GJC0qjzzyyA+qauzc+qINg7Vr1zI+Pj7sNiRpUUnydL+6u4kkSYaBJMkwkCRhGEiSMAwkSRgGkiQMA0kShoEkCcNAksQi/gayNBfWbv/Sy8PH7r55iJ1Iw+WWgSTJMJAkGQaSJAwDSRKGgSQJzyaS+vIsIy01bhlIkgwDSZJhIEnCMJAkYRhIkjAMJEkYBpIkDANJEoaBJAnDQJKEYSBJwmsTaYnwWkPS+bllIEkyDCRJhoEkCcNAksQ0wiDJmiRfS/J4kseSvL/VL0+yL8nRdr+s1ZNkZ5KJJIeTXNOZ19Y2/dEkWzv1a5Mcac/ZmSTz8WYlSf1NZ8vgJeCPq+oqYANwe5KrgO3A/qpaB+xvjwFuBNa12zbgHuiFB7ADuB64DtgxGSBtmvd2nrdp9m9NkjRdU4ZBVZ2sqm+24R8BTwCrgM3A7jbZbuCWNrwZuK96DgCXJVkJ3ADsq6qzVfUcsA/Y1Ma9vqoOVFUB93XmJUlaABd0zCDJWuCtwMPAiqo62UY9C6xow6uAZzpPO95q56sf71Pv9/rbkownGT9z5syFtC5JOo9ph0GS1wKfAz5QVS90x7X/0dcc9/ZTqureqlpfVevHxsbm++UkacmYVhgkeSW9IPhMVX2+lU+1XTy0+9OtfgJY03n66lY7X311n7okaYFM52yiAJ8Cnqiqj3dG7QEmzwjaCjzYqW9pZxVtAJ5vu5P2AhuTLGsHjjcCe9u4F5JsaK+1pTMvSdICmM61iX4V+APgSJJDrfZnwN3AA0luA54G3tXGPQTcBEwAPwbeA1BVZ5PcBRxs0324qs624fcBnwZeDXy53SRJC2TKMKiqfwcGnff/jj7TF3D7gHntAnb1qY8Db5mqF2nYvOCdLlZ+A1mSZBhIkgwDSRKGgSQJw0CShGEgScIwkCRhGEiSMAwkSRgGkiQMA0kShoEkCcNAkoRhIEnCMJAkMb0ft5EWDX9vQJoZtwwkSYaBJMkwkCRhGEiS8ACylqDuQWZJPYaB1BgSWsrcTSRJMgwkSYaBJAnDQJKEYSBJwjCQJGEYSJIwDCRJ+KUzaUp+GU1LgVsGkiTDQJJkGEiSMAwkSXgAWZoT/vayFrsptwyS7EpyOsmjndqHkpxIcqjdbuqM+2CSiSRPJrmhU9/UahNJtnfqVyZ5uNX/Mcmlc/kGJUlTm85uok8Dm/rU/7Kqrm63hwCSXAXcCry5PedvklyS5BLgE8CNwFXAu9u0AB9t8/oF4Dngttm8IUnShZsyDKrq68DZac5vM3B/Vb1YVd8HJoDr2m2iqp6qqp8A9wObkwT4TeCf2vN3A7dc2FuQJM3WbA4g35HkcNuNtKzVVgHPdKY53mqD6m8A/qOqXjqn3leSbUnGk4yfOXNmFq1LkrpmGgb3AD8PXA2cBD42Vw2dT1XdW1Xrq2r92NjYQrykJC0JMzqbqKpOTQ4n+STwxfbwBLCmM+nqVmNA/YfAZUle0bYOutNLkhbIjLYMkqzsPHwnMHmm0R7g1iSvSnIlsA74BnAQWNfOHLqU3kHmPVVVwNeA32vP3wo8OJOeJEkzN+WWQZLPAm8Hlic5DuwA3p7kaqCAY8AfAVTVY0keAB4HXgJur6r/afO5A9gLXALsqqrH2kv8KXB/kj8HvgV8aq7enCRpeqYMg6p6d5/ywA/sqvoI8JE+9YeAh/rUn6J3tpEkaUj8BrIuWl56Wpo+r00kSTIMJEmGgSQJw0CShGEgScIwkCRhGEiSMAwkSfilMy1S/sykNLcMA2mG/IazLibuJpIkuWUgzTV3YWkxcstAkmQYSJIMA0kShoEkCcNAkoRhIEnCMJAkYRhIkjAMJEkYBpIkvByFLgJeME6aPbcMJEmGgSTJMJAkYRhIkjAMJEkYBpIkDANJEoaBJAnDQJKEYSBJwjCQJGEYSJKYRhgk2ZXkdJJHO7XLk+xLcrTdL2v1JNmZZCLJ4STXdJ6ztU1/NMnWTv3aJEfac3YmyVy/SUnS+U1ny+DTwKZzatuB/VW1DtjfHgPcCKxrt23APdALD2AHcD1wHbBjMkDaNO/tPO/c15IkzbMpw6Cqvg6cPae8GdjdhncDt3Tq91XPAeCyJCuBG4B9VXW2qp4D9gGb2rjXV9WBqirgvs68JEkLZKbHDFZU1ck2/Cywog2vAp7pTHe81c5XP96n3leSbUnGk4yfOXNmhq1Lks416wPI7X/0NQe9TOe17q2q9VW1fmxsbCFeUpKWhJmGwam2i4d2f7rVTwBrOtOtbrXz1Vf3qUuSFtBMw2APMHlG0FbgwU59SzuraAPwfNudtBfYmGRZO3C8Edjbxr2QZEM7i2hLZ16SpAUy5W8gJ/ks8HZgeZLj9M4Kuht4IMltwNPAu9rkDwE3ARPAj4H3AFTV2SR3AQfbdB+uqsmD0u+jd8bSq4Evt5skaQFNGQZV9e4Bo97RZ9oCbh8wn13Arj71ceAtU/UhSZo/U4aBNCxrt3/p5eFjd988xE6ki5+Xo5AkuWUgLRS3dDTK3DKQJBkGkiTDQJKEYSBJwjCQJGEYSJLw1FItEt3TMiXNPcNAmkeGmBYLdxNJkgwDSZJhIEnCMJAkYRhIkjAMJEkYBpIkDANJEoaBJAnDQJKEYSBJwjCQJGEYSJIwDCRJGAaSJAwDSRKGgSQJw0CShD97qRHQ/WnIY3ffPMROpKXLLQNJkmEgSXI3kTR07ibTKDAMNFK6H4ySFo67iSRJbhlIw+AWkEbNrLYMkhxLciTJoSTjrXZ5kn1Jjrb7Za2eJDuTTCQ5nOSazny2tumPJtk6u7ckSbpQc7Gb6Deq6uqqWt8ebwf2V9U6YH97DHAjsK7dtgH3QC88gB3A9cB1wI7JAJEkLYz5OGawGdjdhncDt3Tq91XPAeCyJCuBG4B9VXW2qp4D9gGb5qEvSdIAsw2DAr6S5JEk21ptRVWdbMPPAiva8Crgmc5zj7faoLokaYHM9gDy26rqRJI3AvuSfKc7sqoqSc3yNV7WAmcbwBVXXDFXs5WkJW9WWwZVdaLdnwa+QG+f/6m2+4d2f7pNfgJY03n66lYbVO/3evdW1fqqWj82Njab1iVJHTMOgySvSfK6yWFgI/AosAeYPCNoK/BgG94DbGlnFW0Anm+7k/YCG5MsaweON7aaJGmBzGY30QrgC0km5/MPVfUvSQ4CDyS5DXgaeFeb/iHgJmAC+DHwHoCqOpvkLuBgm+7DVXV2Fn1Jki7QjMOgqp4CfqVP/YfAO/rUC7h9wLx2Abtm2oskaXa8HIUkyTCQJBkGkiQMA0kShoEkCcNAkoS/Z6AF5M87SqPLMNBQ+OMu0mgxDKQRMigk3ZLSfPOYgSTJMJAkGQaSJAwDSRKGgSQJw0CShGEgScIwkCRhGEiSMAwkSRgGkiS8NpHmgVcnnV8uX80Hw0DzyquTSouDYSAtAoaq5pvHDCRJhoEkyTCQJGEYSJIwDCRJGAaSJDy1VLPg6Y7Dd75/A7+QpgvhloEkyTCQJBkGkiQMA0kSHkDWNHigePHzSqeaimEgXaQMcV0IdxNJkkZnyyDJJuCvgEuAv6uqu4fc0pLj/ySXhkH/zu4+WtpGIgySXAJ8Avht4DhwMMmeqnp8uJ1dnPzQVz+GxNI2EmEAXAdMVNVTAEnuBzYDhsE0+OGu+XSh65fhsTiNShisAp7pPD4OXH/uREm2Advaw/9M8uQcvPZy4AdzMJ+Fspj6tdf5M7L95qM/VRrZXgdYTP3OpNef61cclTCYlqq6F7h3LueZZLyq1s/lPOfTYurXXufPYup3MfUKi6vfuex1VM4mOgGs6Txe3WqSpAUwKmFwEFiX5MoklwK3AnuG3JMkLRkjsZuoql5Kcgewl96ppbuq6rEFevk53e20ABZTv/Y6fxZTv4upV1hc/c5Zr6mquZqXJGmRGpXdRJKkITIMJElLKwyS/H6Sx5L8b5L1nfraJP+V5FC7/W1n3LVJjiSZSLIzSYbZaxv3wdbPk0lu6NQ3tdpEku0L0Wc/ST6U5ERned7UGde392EaleU2SJJjbR08lGS81S5Psi/J0Xa/bIj97UpyOsmjnVrf/tKzsy3rw0muGYFeR3J9TbImydeSPN4+C97f6vOzbKtqydyAXwZ+CfhXYH2nvhZ4dMBzvgFsAAJ8GbhxyL1eBXwbeBVwJfA9egfdL2nDbwIubdNcNaTl/CHgT/rU+/Y+5HViZJbbeXo8Biw/p/YXwPY2vB346BD7+3Xgmu7f0KD+gJva31Ha39XDI9DrSK6vwErgmjb8OuC7rad5WbZLasugqp6oqml/aznJSuD1VXWgekv7PuCW+eqv6zy9bgbur6oXq+r7wAS9y3m8fEmPqvoJMHlJj1EyqPdhWgzLrZ/NwO42vJsFWi/7qaqvA2fPKQ/qbzNwX/UcAC5rf2cLYkCvgwx1fa2qk1X1zTb8I+AJeldrmJdlu6TCYApXJvlWkn9L8muttorepTEmHW+1Yep36Y5V56kPyx1tU3VXZxfGqPUIo9nTuQr4SpJH2iVZAFZU1ck2/CywYjitDTSov1Fd3iO9viZZC7wVeJh5WrYj8T2DuZTkq8DP9hl1Z1U9OOBpJ4ErquqHSa4F/jnJm+etyWaGvY6E8/UO3APcRe9D7C7gY8AfLlx3F523VdWJJG8E9iX5TndkVVWSkT1HfNT7Y8TX1ySvBT4HfKCqXugetpzLZXvRhUFV/dYMnvMi8GIbfiTJ94BfpHdJjNWdSef0Mhkz6ZXzX7pjwS7pMd3ek3wS+GJ7OIqXHRnFnv6fqjrR7k8n+QK9XRWnkqysqpNtV8DpoTb50wb1N3LLu6pOTQ6P2vqa5JX0guAzVfX5Vp6XZetuIiDJWHq/qUCSNwHrgKfaptgLSTa0s4i2AMP+H/se4NYkr0pyJb1ev8EIXdLjnP2U7wQmz9wY1Pswjcxy6yfJa5K8bnIY2Ehvee4BtrbJtjL89fJcg/rbA2xpZ75sAJ7v7PIYilFdX9tnzqeAJ6rq451R87NsF+rI+Cjc6P1DH6e3FXAK2Nvqvws8BhwCvgn8Tuc56+mtHN8D/pr2re1h9drG3dn6eZLO2U30zib4bht35xCX898DR4DDbQVdOVXvQ14vRmK5DejtTfTOaPl2W0fvbPU3APuBo8BXgcuH2ONn6e1q/e+2zt42qD96Z7p8oi3rI3TOlBtiryO5vgJvo7fr6nD7bDrU1tV5WbZejkKS5G4iSZJhIEnCMJAkYRhIkjAMJEkYBpIkDANJEvB/DrQFsWZUkGEAAAAASUVORK5CYII=\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
"0.44205322265625"
]
},
"metadata": {
"needs_background": "light"
"execution_count": 407,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def huffman(image):\n",
" origin, predict, diff, error, A = plot_hist(image)\n",
" image = Image.open(image)\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",
" \n",
" boundary = np.hstack((image[0,:],image[-1,:],image[1:-1,0],image[1:-1,-1]))\n",
" boundary = boundary - image[0,0]\n",
" boundary[0] = image[0,0]\n",
"\n",
" string = [str(i) for i in boundary]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode1 = huffman_code_tree(node)\n",
" \n",
" \n",
" mask = diff <= 25\n",
" string = [str(i) for i in error[mask].astype(int)]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode2 = huffman_code_tree(node)\n",
"\n",
" \n",
" mask = diff > 25\n",
" new_error = error[mask]\n",
" mask2 = diff[mask] <= 40\n",
" string = [str(i) for i in new_error[mask2].astype(int)]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode3 = huffman_code_tree(node)\n",
" \n",
"\n",
" mask = diff > 40\n",
" new_error = error[mask]\n",
" mask2 = diff[mask] <= 70\n",
" string = [str(i) for i in new_error[mask2].astype(int)]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode4 = huffman_code_tree(node)\n",
" \n",
" \n",
" mask = diff > 70\n",
" string = [str(i) for i in error[mask].astype(int)]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode5 = huffman_code_tree(node)\n",
"\n",
" \n",
" \n",
"\n",
" new_error = np.copy(image)\n",
" new_error[1:-1,1:-1] = np.reshape(error,(510, 638))\n",
" keep = new_error[0,0]\n",
" new_error[0,:] = new_error[0,:] - keep\n",
" new_error[-1,:] = new_error[-1,:] - keep\n",
" new_error[1:-1,0] = new_error[1:-1,0] - keep\n",
" new_error[1:-1,-1] = new_error[1:-1,-1] - keep\n",
" new_error[0,0] = keep\n",
" new_error = np.ravel(new_error)\n",
" \n",
" # return the huffman dictionary\n",
" return encode1, encode2, encode3, encode4, encode5, np.ravel(image), error, diff, boundary\n",
"\n",
"def compress_rate(image, error, diff, bound, encode1, encode2, encode3, encode4, encode5):\n",
" #original = original.reshape(-1)\n",
" #error = error.reshape(-1)\n",
" o_len = 0\n",
" c_len = 0\n",
" im = np.reshape(image,(512, 640))\n",
" real_b = np.hstack((im[0,:],im[-1,:],im[1:-1,0],im[1:-1,-1]))\n",
" original = im[1:-1,1:-1].reshape(-1)\n",
"\n",
" for i in range(0,len(bound)):\n",
" o_len += len(bin(real_b[i])[2:])\n",
" c_len += len(encode1[str(bound[i])])\n",
" \n",
" for i in range(0, len(original)):\n",
" o_len += len(bin(original[i])[2:])\n",
" if diff[i] <= 25:\n",
" c_len += len(encode2[str(int(error[i]))])\n",
"\n",
" if diff[i] <= 40 and diff[i] > 25:\n",
" c_len += len(encode3[str(int(error[i]))])\n",
" \n",
" if diff[i] <= 70 and diff[i] > 40:\n",
" c_len += len(encode4[str(int(error[i]))])\n",
" \n",
" if diff[i] > 70:\n",
" c_len += len(encode5[str(int(error[i]))])\n",
" \n",
" return c_len/o_len\n",
"scenes = file_extractor()\n",
"images = image_extractor(scenes)\n",
"encode1, encode2, encode3, encode4, encode5, image, error, diff, boundary = huffman(images[0])\n",
"compress_rate(image, error, diff, boundary, encode1, encode2, encode3, encode4, encode5)\n"
]
},
{
"cell_type": "markdown",
"id": "3a3f06a5",
"metadata": {},
"source": [
"### Huffman with dividing into uniform bins"
]
},
{
"cell_type": "code",
"execution_count": 415,
"id": "14075c94",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.4432273356119792"
]
},
"output_type": "display_data"
},
"execution_count": 415,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def huffman_u(image):\n",
" origin, predict, diff, error, A = plot_hist(image)\n",
" image = Image.open(image)\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",
" \n",
" boundary = np.hstack((image[0,:],image[-1,:],image[1:-1,0],image[1:-1,-1]))\n",
" boundary = boundary - image[0,0]\n",
" boundary[0] = image[0,0]\n",
"\n",
" string = [str(i) for i in boundary]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode1 = huffman_code_tree(node)\n",
" \n",
" \n",
" mask = diff <= 100\n",
" string = [str(i) for i in error[mask].astype(int)]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode2 = huffman_code_tree(node)\n",
"\n",
" \n",
" mask = diff > 100\n",
" #new_error = error[mask]\n",
" #mask2 = diff[mask] <= 200\n",
" #string = [str(i) for i in new_error[mask2].astype(int)]\n",
" string = [str(i) for i in error[mask].astype(int)]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode3 = huffman_code_tree(node)\n",
" \n",
"\n",
" '''mask = diff > 200\n",
" new_error = error[mask]\n",
" mask2 = diff[mask] <= 300\n",
" string = [str(i) for i in new_error[mask2].astype(int)]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode4 = huffman_code_tree(node)\n",
" \n",
" \n",
" mask = diff > 300\n",
" string = [str(i) for i in error[mask].astype(int)]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode5 = huffman_code_tree(node)'''\n",
"\n",
" \n",
" \n",
"\n",
" new_error = np.copy(image)\n",
" new_error[1:-1,1:-1] = np.reshape(error,(510, 638))\n",
" keep = new_error[0,0]\n",
" new_error[0,:] = new_error[0,:] - keep\n",
" new_error[-1,:] = new_error[-1,:] - keep\n",
" new_error[1:-1,0] = new_error[1:-1,0] - keep\n",
" new_error[1:-1,-1] = new_error[1:-1,-1] - keep\n",
" new_error[0,0] = keep\n",
" new_error = np.ravel(new_error)\n",
" \n",
" # return the huffman dictionary\n",
" #return encode1, encode2, encode3, encode4, encode5, np.ravel(image), error, diff, boundary\n",
" return encode1, encode2, encode3, np.ravel(image), error, diff, boundary\n",
"\n",
"#def compress_rate_u(image, error, diff, bound, encode1, encode2, encode3, encode4, encode5):\n",
"def compress_rate_u(image, error, diff, bound, encode1, encode2, encode3):\n",
" #original = original.reshape(-1)\n",
" #error = error.reshape(-1)\n",
" o_len = 0\n",
" c_len = 0\n",
" im = np.reshape(image,(512, 640))\n",
" real_b = np.hstack((im[0,:],im[-1,:],im[1:-1,0],im[1:-1,-1]))\n",
" original = im[1:-1,1:-1].reshape(-1)\n",
"\n",
" for i in range(0,len(bound)):\n",
" o_len += len(bin(real_b[i])[2:])\n",
" c_len += len(encode1[str(bound[i])])\n",
" \n",
" for i in range(0, len(original)):\n",
" o_len += len(bin(original[i])[2:])\n",
" if diff[i] <= 100:\n",
" c_len += len(encode2[str(int(error[i]))])\n",
" \n",
" if diff[i] > 100:\n",
" c_len += len(encode3[str(int(error[i]))])\n",
"\n",
" '''if diff[i] <= 200 and diff[i] > 100:\n",
" c_len += len(encode3[str(int(error[i]))])'''\n",
" \n",
" '''if diff[i] <= 300 and diff[i] > 200:\n",
" c_len += len(encode4[str(int(error[i]))])\n",
" \n",
" if diff[i] > 300:\n",
" c_len += len(encode5[str(int(error[i]))])'''\n",
" \n",
" return c_len/o_len\n",
"scenes = file_extractor()\n",
"images = image_extractor(scenes)\n",
"encode1, encode2, encode3, image, error, diff, boundary = huffman_u(images[0])\n",
"compress_rate_u(image, error, diff, boundary, encode1, encode2, encode3)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f8b93cc5",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 417,
"id": "6abed5da",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"-154.0\n",
"197.0\n"
"Compression rate of huffman with different bins: 0.44946919759114584\n",
"Compression rate of huffman without bins: 0.4513634314749933\n",
"Compression rate of huffman with uniform bins: 0.44956921895345053\n"
]
}
],
"source": [
"scenes = file_extractor()\n",
"images = image_extractor(scenes)\n",
"origin, predict, diff, error, A = plot_hist(images[0])\n",
"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(int)\n",
"print(len(set(list(error))))\n",
"plt.hist(error,100)\n",
"plt.show()\n",
"print(min(error))\n",
"print(max(error))"
"num_images = im_distribution(images, \"_9\")\n",
"rate = []\n",
"rate_nb = []\n",
"rate_u = []\n",
"for i in range(len(num_images)):\n",
" encode1, encode2, encode3, encode4, encode5, image, error, diff, bound = huffman(num_images[i])\n",
" r = compress_rate(image, error, diff, bound, encode1, encode2, encode3, encode4, encode5)\n",
" rate.append(r)\n",
" encoding, error, image = huffman_nb(num_images[i])\n",
" r = compress_rate_nb(image, error, encoding)\n",
" rate_nb.append(r)\n",
" encode1, encode2, encode3, image, error, diff, bound = huffman_u(num_images[i])\n",
" r = compress_rate_u(image, error, diff, bound, encode1, encode2, encode3)\n",
" rate_u.append(r)\n",
" \n",
"print(f\"Compression rate of huffman with different bins: {np.mean(rate)}\")\n",
"print(f\"Compression rate of huffman without bins: {np.mean(rate_nb)}\")\n",
"print(f\"Compression rate of huffman with uniform bins: {np.mean(rate_u)}\")"
]
},
{
"cell_type": "code",
"execution_count": 145,
"id": "207b0bd2",
"execution_count": 427,
"id": "15eecad3",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
"0.44225341796875"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
"execution_count": 427,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def huffman(image):\n",
" origin, predict, diff, error, A = plot_hist(image)\n",
" image = Image.open(image)\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",
" \n",
" boundary = np.hstack((image[0,:],image[-1,:],image[1:-1,0],image[1:-1,-1]))\n",
" boundary = boundary - image[0,0]\n",
" boundary[0] = image[0,0]\n",
"\n",
" string = [str(i) for i in boundary]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode1 = huffman_code_tree(node)\n",
" \n",
" \n",
" mask = diff <= 10\n",
" string = [str(i) for i in error[mask].astype(int)]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode2 = huffman_code_tree(node)\n",
"\n",
" \n",
" mask = diff > 10\n",
" new_error = error[mask]\n",
" mask2 = diff[mask] <= 25\n",
" string = [str(i) for i in new_error[mask2].astype(int)]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode3 = huffman_code_tree(node)\n",
" \n",
"\n",
" mask = diff > 25\n",
" new_error = error[mask]\n",
" mask2 = diff[mask] <= 45\n",
" string = [str(i) for i in new_error[mask2].astype(int)]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode4 = huffman_code_tree(node)\n",
" \n",
" \n",
" mask = diff > 45\n",
" string = [str(i) for i in error[mask].astype(int)]\n",
" freq = dict(Counter(string))\n",
" freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
" node = make_tree(freq)\n",
" encode5 = huffman_code_tree(node)\n",
"\n",
" \n",
" \n",
"\n",
" new_error = np.copy(image)\n",
" new_error[1:-1,1:-1] = np.reshape(error,(510, 638))\n",
" keep = new_error[0,0]\n",
" new_error[0,:] = new_error[0,:] - keep\n",
" new_error[-1,:] = new_error[-1,:] - keep\n",
" new_error[1:-1,0] = new_error[1:-1,0] - keep\n",
" new_error[1:-1,-1] = new_error[1:-1,-1] - keep\n",
" new_error[0,0] = keep\n",
" new_error = np.ravel(new_error)\n",
" \n",
" # return the huffman dictionary\n",
" return encode1, encode2, encode3, encode4, encode5, np.ravel(image), error, diff, boundary\n",
"\n",
"def compress_rate(image, error, diff, bound, encode1, encode2, encode3, encode4, encode5):\n",
" #original = original.reshape(-1)\n",
" #error = error.reshape(-1)\n",
" o_len = 0\n",
" c_len = 0\n",
" im = np.reshape(image,(512, 640))\n",
" real_b = np.hstack((im[0,:],im[-1,:],im[1:-1,0],im[1:-1,-1]))\n",
" original = im[1:-1,1:-1].reshape(-1)\n",
"\n",
" for i in range(0,len(bound)):\n",
" o_len += len(bin(real_b[i])[2:])\n",
" c_len += len(encode1[str(bound[i])])\n",
" \n",
" for i in range(0, len(original)):\n",
" o_len += len(bin(original[i])[2:])\n",
" if diff[i] <= 10:\n",
" c_len += len(encode2[str(int(error[i]))])\n",
"\n",
" if diff[i] <= 25 and diff[i] > 10:\n",
" c_len += len(encode3[str(int(error[i]))])\n",
" \n",
" if diff[i] <= 45 and diff[i] > 25:\n",
" c_len += len(encode4[str(int(error[i]))])\n",
" \n",
" if diff[i] > 45:\n",
" c_len += len(encode5[str(int(error[i]))])\n",
" \n",
" return c_len/o_len\n",
"scenes = file_extractor()\n",
"images = image_extractor(scenes)\n",
"encode1, encode2, encode3, encode4, encode5, image, error, diff, boundary = huffman(images[0])\n",
"compress_rate(image, error, diff, boundary, encode1, encode2, encode3, encode4, encode5)\n"
]
},
{
"cell_type": "code",
"execution_count": 428,
"id": "f8a8c717",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"458\n",
"{'61': '000000000', '87': '000000001000', '140': '000000001001000', '142': '000000001001001', '250': '000000001001010', '179': '000000001001011', '151': '000000001001100', '207': '0000000010011010', '141': '0000000010011011', '101': '00000000100111', '77': '00000000101', '69': '0000000011', '53': '00000001', '44': '0000001', '33': '000001', '20': '00001', '19': '00010', '18': '00011', '43': '0010000', '75': '00100010000', '84': '001000100010', '104': '00100010001100', '122': '001000100011010', '120': '001000100011011', '94': '0010001000111', '83': '001000100100', '153': '001000100101000', '130': '001000100101001', '143': '001000100101010', '127': '001000100101011', '93': '0010001001011', '115': '0010001001100000', '375': '0010001001100001', '366': '0010001001100010', '373': '0010001001100011', '377': '0010001001100100', '314': '0010001001100101', '402': '0010001001100110', '367': '0010001001100111', '133': '0010001001101000', '210': '0010001001101001', '334': '0010001001101010', '298': '0010001001101011', '176': '0010001001101100', '332': '0010001001101101', '335': '0010001001101110', '362': '0010001001101111', '371': '0010001001110000', '333': '0010001001110001', '251': '0010001001110010', '226': '0010001001110011', '247': '0010001001110100', '315': '0010001001110101', '304': '0010001001110110', '258': '0010001001110111', '306': '0010001001111000', '261': '0010001001111001', '289': '0010001001111010', '372': '0010001001111011', '239': '0010001001111100', '252': '0010001001111101', '224': '0010001001111110', '205': '0010001001111111', '60': '001000101', '52': '00100011', '32': '001001', '17': '00101', '51': '00110000', '139': '001100010000000', '149': '001100010000001', '132': '001100010000010', '154': '001100010000011', '163': '001100010000100', '162': '001100010000101', '281': '001100010000110', '346': '001100010000111', '384': '00110001000100000', '331': '00110001000100001', '383': '00110001000100010', '155': '00110001000100011', '354': '00110001000100100', '456': '00110001000100101', '229': '00110001000100110', '388': '00110001000100111', '294': '00110001000101000', '413': '00110001000101001', '211': '00110001000101010', '292': '00110001000101011', '376': '00110001000101100', '382': '00110001000101101', '387': '00110001000101110', '309': '00110001000101111', '158': '001100010001100', '159': '001100010001101', '313': '00110001000111000', '126': '00110001000111001', '327': '00110001000111010', '319': '00110001000111011', '302': '00110001000111100', '330': '00110001000111101', '385': '00110001000111110', '573': '00110001000111111', '76': '00110001001', '214': '0011000101000000', '259': '0011000101000001', '243': '0011000101000010', '255': '0011000101000011', '410': '0011000101000100', '399': '0011000101000101', '134': '0011000101000110', '270': '0011000101000111', '216': '0011000101001000', '236': '0011000101001001', '213': '0011000101001010', '196': '0011000101001011', '290': '0011000101001100', '231': '0011000101001101', '128': '0011000101001110', '193': '0011000101001111', '169': '0011000101010000', '178': '0011000101010001', '328': '0011000101010010', '160': '0011000101010011', '394': '0011000101010100', '336': '0011000101010101', '204': '0011000101010110', '227': '0011000101010111', '200': '0011000101011000', '212': '0011000101011001', '352': '0011000101011010', '147': '0011000101011011', '342': '0011000101011100', '308': '0011000101011101', '329': '0011000101011110', '379': '0011000101011111', '221': '00110001011000000', '267': '00110001011000001', '269': '001100010110000100', '177': '001100010110000101', '220': '001100010110000110', '202': '001100010110000111', '225': '00110001011000100', '185': '00110001011000101', '170': '00110001011000110', '198': '00110001011000111', '429': '001100010110010000', '206': '001100010110010001', '426': '001100010110010010', '438': '001100010110010011', '403': '001100010110010100', '424': '001100010110010101', '299': '001100010110010110', '325': '001100010110010111', '237': '001100010110011000', '152': '001100010110011001', '145': '001100010110011010', '230': '001100010110011011', '411': '001100010110011100', '286': '001100010110011101', '374': '001100010110011110', '469': '001100010110011111', '293': '00110001011010000', '406': '00110001011010001', '407': '00110001011010010', '421': '00110001011010011', '301': '00110001011010100', '275': '00110001011010101', '423': '00110001011010110', '395': '00110001011010111', '244': '00110001011011000', '337': '00110001011011001', '300': '00110001011011010', '233': '00110001011011011', '322': '00110001011011100', '400': '00110001011011101', '253': '00110001011011110', '361': '00110001011011111', '297': '001100010111000000', '390': '001100010111000001', '444': '001100010111000010', '242': '001100010111000011', '606': '001100010111000100', '498': '001100010111000101', '397': '001100010111000110', '532': '001100010111000111', '209': '001100010111001000', '283': '001100010111001001', '430': '001100010111001010', '351': '001100010111001011', '539': '001100010111001100', '530': '001100010111001101', '256': '001100010111001110', '491': '001100010111001111', '511': '001100010111010000', '570': '001100010111010001', '559': '001100010111010010', '478': '001100010111010011', '359': '001100010111010100', '22554': '001100010111010101', '512': '001100010111010110', '503': '001100010111010111', '474': '001100010111011000', '489': '001100010111011001', '404': '001100010111011010', '380': '001100010111011011', '519': '001100010111011100', '568': '001100010111011101', '515': '001100010111011110', '543': '001100010111011111', '439': '001100010111100000', '418': '001100010111100001', '419': '001100010111100010', '425': '001100010111100011', '454': '001100010111100100', '228': '001100010111100101', '447': '001100010111100110', '452': '001100010111100111', '414': '001100010111101000', '435': '001100010111101001', '416': '001100010111101010', '345': '001100010111101011', '401': '001100010111101100', '440': '001100010111101101', '409': '001100010111101110', '350': '001100010111101111', '494': '001100010111110000', '482': '001100010111110001', '502': '001100010111110010', '393': '001100010111110011', '422': '001100010111110100', '370': '001100010111110101', '461': '001100010111110110', '369': '001100010111110111', '398': '001100010111111000', '445': '001100010111111001', '203': '001100010111111010', '249': '001100010111111011', '405': '001100010111111100', '486': '001100010111111101', '467': '001100010111111110', '470': '001100010111111111', '68': '0011000110', '74': '00110001110', '91': '0011000111100', '114': '001100011110100', '307': '001100011110101', '199': '001100011110110', '110': '001100011110111', '89': '0011000111110', '109': '00110001111110', '105': '001100011111110', '150': '0011000111111110', '129': '0011000111111111', '42': '0011001', '31': '001101', '16': '00111', '15': '01000', '67': '0100100000', '66': '0100100001', '59': '010010001', '50': '01001001', '41': '0100101', '30': '010011', '14': '01010', '13': '01011', '12': '01100', '29': '011010', '49': '01101100', '73': '01101101000', '82': '011011010010', '88': '0110110100110', '90': '0110110100111', '264': '0110110101000000', '272': '0110110101000001', '181': '0110110101000010', '218': '0110110101000011', '368': '0110110101000100', '347': '0110110101000101', '186': '0110110101000110', '248': '0110110101000111', '365': '0110110101001000', '187': '0110110101001001', '165': '0110110101001010', '164': '0110110101001011', '305': '0110110101001100', '161': '0110110101001101', '271': '0110110101001110', '340': '0110110101001111', '386': '0110110101010000', '280': '0110110101010001', '112': '0110110101010010', '137': '0110110101010011', '100': '01101101010101', '326': '0110110101011000', '277': '0110110101011001', '288': '0110110101011010', '316': '0110110101011011', '148': '0110110101011100', '287': '0110110101011101', '131': '0110110101011110', '183': '0110110101011111', '81': '011011010110', '188': '011011010111000', '125': '011011010111001', '171': '0110110101110100', '166': '0110110101110101', '167': '011011010111011', '116': '011011010111100', '174': '011011010111101', '108': '011011010111110', '107': '011011010111111', '58': '011011011', '40': '0110111', '11': '01110', '10': '01111', '28': '100000', '39': '1000010', '57': '100001100', '65': '1000011010', '72': '10000110110', '70': '10000110111', '48': '10000111', '9': '10001', '7': '10010', '8': '10011', '27': '101000', '38': '1010010', '47': '10100110', '63': '1010011100', '71': '10100111010', '79': '101001110110', '97': '10100111011100', '103': '10100111011101', '96': '10100111011110', '138': '10100111011111000', '146': '10100111011111001', '282': '10100111011111010', '222': '10100111011111011', '118': '101001110111111', '56': '101001111', '6': '10101', '5': '10110', '0': '101110', '26': '101111', '3': '11000', '2': '11001', '1': '11010', '4': '11011', '25': '111000', '37': '1110010', '64': '1110011000', '119': '11100110010000000', '349': '11100110010000001', '364': '11100110010000010', '392': '11100110010000011', '358': '11100110010000100', '378': '11100110010000101', '197': '11100110010000110', '279': '11100110010000111', '323': '11100110010001000', '318': '11100110010001001', '360': '11100110010001010', '436': '11100110010001011', '217': '11100110010001100', '124': '11100110010001101', '311': '11100110010001110', '324': '11100110010001111', '274': '11100110010010000', '278': '11100110010010001', '310': '11100110010010010', '296': '11100110010010011', '353': '11100110010010100', '357': '11100110010010101', '262': '11100110010010110', '223': '11100110010010111', '303': '11100110010011000', '284': '11100110010011001', '396': '11100110010011010', '338': '11100110010011011', '135': '11100110010011100', '355': '11100110010011101', '234': '11100110010011110', '441': '11100110010011111', '195': '1110011001010000', '320': '1110011001010001', '257': '11100110010100100', '215': '11100110010100101', '254': '11100110010100110', '263': '11100110010100111', '157': '1110011001010100', '285': '1110011001010101', '172': '1110011001010110', '192': '1110011001010111', '381': '11100110010110000', '389': '11100110010110001', '321': '11100110010110010', '189': '11100110010110011', '415': '11100110010110100', '190': '11100110010110101', '232': '11100110010110110', '245': '11100110010110111', '180': '11100110010111000', '235': '11100110010111001', '273': '11100110010111010', '317': '11100110010111011', '240': '11100110010111100', '219': '11100110010111101', '182': '11100110010111110', '246': '11100110010111111', '113': '1110011001100000', '276': '1110011001100001', '265': '1110011001100010', '175': '1110011001100011', '121': '1110011001100100', '123': '1110011001100101', '144': '1110011001100110', '156': '1110011001100111', '184': '1110011001101000', '344': '1110011001101001', '266': '1110011001101010', '173': '1110011001101011', '348': '1110011001101100', '268': '1110011001101101', '363': '1110011001101110', '312': '1110011001101111', '80': '111001100111', '55': '111001101', '46': '11100111', '24': '111010', '36': '1110110', '54': '111011100', '62': '1110111010', '92': '11101110110000', '98': '11101110110001', '86': '1110111011001', '95': '11101110110100', '99': '11101110110101', '106': '111011101101100', '117': '111011101101101', '136': '1110111011011100', '241': '1110111011011101', '102': '111011101101111', '85': '1110111011100', '201': '1110111011101000', '238': '1110111011101001', '191': '1110111011101010', '208': '1110111011101011', '343': '1110111011101100', '111': '1110111011101101', '168': '1110111011101110', '339': '1110111011101111', '78': '111011101111', '45': '11101111', '23': '111100', '35': '1111010', '34': '1111011', '22': '111110', '21': '111111'}\n"
"Compression rate of huffman with different bins: 0.4488415273030599\n"
]
}
],
"source": [
"scenes = file_extractor()\n",
"images = image_extractor(scenes)\n",
"start = time.time()\n",
"origin, predict, diff, error, A = plot_hist(images[0])\n",
"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(int)\n",
"new_error = np.copy(image)\n",
"new_error[1:-1,1:-1] = np.reshape(error,(510, 638))\n",
"keep = new_error[0,0]\n",
"new_error[0,:] = new_error[0,:] - keep\n",
"new_error[-1,:] = new_error[-1,:] - keep\n",
"new_error[1:-1,0] = new_error[1:-1,0] - keep\n",
"new_error[1:-1,-1] = new_error[1:-1,-1] - keep\n",
"new_error[0,0] = keep\n",
"new_error = np.ravel(new_error)\n",
"plt.hist(new_error[1:],bins=100)\n",
"plt.show()\n",
"ab_error = np.abs(new_error)\n",
"string = [str(i) for i in ab_error]\n",
"#string = [str(i) for i in new_error]\n",
"#string = [str(i) for i in np.arange(0,5)] + [str(i) for i in np.arange(0,5)] + [str(i) for i in np.arange(0,2)]*2\n",
"freq = dict(Counter(string))\n",
"#print(freq)\n",
"freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)\n",
"node = make_tree(freq)\n",
"encoding = huffman_code_tree(node)\n",
"#encoded = [\"1\"+encoding[str(-i)] if i < 0 else \"0\"+encoding[str(i)] for i in error]\n",
"#print(time.time()-start)\n",
"print(len(encoding))\n",
"print(encoding)"
"num_images = im_distribution(images, \"_9\")\n",
"rate = []\n",
"\n",
"for i in range(len(num_images)):\n",
" encode1, encode2, encode3, encode4, encode5, image, error, diff, bound = huffman(num_images[i])\n",
" r = compress_rate(image, error, diff, bound, encode1, encode2, encode3, encode4, encode5)\n",
" rate.append(r)\n",
" \n",
" \n",
"print(f\"Compression rate of huffman with different bins: {np.mean(rate)}\")\n"
]
},
{
"cell_type": "code",
"execution_count": 154,
"id": "14075c94",
"execution_count": 238,
"id": "992dd8bb",
"metadata": {},
"outputs": [],
"source": [
"def compress_rate(original, error, encoding):\n",
" original = original.reshape(-1)\n",
" error = error.reshape(-1)\n",
" o_len = 0\n",
" c_len = 0\n",
" for i in range(0, len(original)):\n",
" o_len += len(bin(original[i])[2:])\n",
" c_len += len(encoding[str(abs(error[i]))])\n",
" c_len += 1\n",
" \n",
" return c_len/o_len"
"origin, predict, diff, error, A = plot_hist(images[0])"
]
},
{
"cell_type": "code",
"execution_count": 155,
"id": "b93c068b",
"execution_count": 418,
"id": "904ba7b1",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"0.4473590087890625"
"<Figure size 432x288 with 1 Axes>"
]
},
"execution_count": 155,
"metadata": {},
"output_type": "execute_result"
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"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": [
"compress_rate(image,new_error,encoding)"
"plt.hist(error,bins=50)\n",
"plt.show()\n",
"mask = diff <= 20\n",
"plt.hist(error[mask],bins=50)\n",
"plt.show()\n",
"\n",
"mask = diff > 20\n",
"new_error = error[mask]\n",
"mask2 = diff[mask] <= 35\n",
"plt.hist(new_error[mask2],bins=50)\n",
"plt.show()\n",
"\n",
"mask = diff > 35\n",
"new_error = error[mask]\n",
"mask2 = diff[mask] <= 50\n",
"plt.hist(new_error[mask2],bins=50)\n",
"plt.show()\n",
"\n",
"mask = diff > 50\n",
"#new_error = error[mask]\n",
"#mask2 = diff[mask] <= 400\n",
"plt.hist(error[mask],bins=50)\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 140,
"id": "a8dc8674",
"execution_count": 236,
"id": "2f5ef010",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 140,
"metadata": {},
"output_type": "execute_result"
"name": "stdout",
"output_type": "stream",
"text": [
"(512, 640)\n"
]
}
],
"source": [
"image = Image.open(images[0])\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",
"boundary = np.hstack((image[0,:],image[-1,:],image[1:-1,0],image[1:-1,-1]))\n",
"boundary = boundary - image[0,0]\n",
"boundary[0] = image[0,0]\n",
"print(image.shape)"
]
},
{
"cell_type": "code",
"execution_count": 228,
"id": "4860903b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[22554 -2 -35 ... -16 40 19]\n"
]
}
],
"source": [
"int('0100',2)"
"print(boundary)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "992dd8bb",
"id": "f145c221",
"metadata": {},
"outputs": [],
"source": []
......
prediction_MSE_kelly.ipynb
View file @ 18a92d19
......@@ -2,7 +2,7 @@
"cells": [
{
"cell_type": "code",
"execution_count": 11,
"execution_count": 28,
"id": "dbef8759",
"metadata": {},
"outputs": [],
......@@ -19,7 +19,7 @@
},
{
"cell_type": "code",
"execution_count": 12,
"execution_count": 29,
"id": "b7a550e0",
"metadata": {},
"outputs": [],
......@@ -74,7 +74,7 @@
},
{
"cell_type": "code",
"execution_count": 13,
"execution_count": 30,
"id": "9ed20f84",
"metadata": {},
"outputs": [],
......@@ -119,14 +119,25 @@
},
{
"cell_type": "code",
"execution_count": 14,
"execution_count": 34,
"id": "8e3ef654",
"metadata": {},
"outputs": [],
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"120\n",
"8\n"
]
}
],
"source": [
"scenes = file_extractor()\n",
"images = image_extractor(scenes)\n",
"num_images = im_distribution(images, \"_9\")\n",
"print(len(images))\n",
"print(len(num_images))\n",
"error_mean = []\n",
"error_mean1 = []\n",
"diff_mean = []\n",
......
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