From 1fc8c4bf0f780b5c0293ea6ba4a48f7847d6d475 Mon Sep 17 00:00:00 2001 From: Jakob Krause Date: Wed, 2 May 2018 18:30:02 +0200 Subject: [PATCH 1/5] Added solution for ex1 and 2 --- .../01_assignment_sample_solution.ipynb | 422 ++++++++++++++++++ .../02_assignment_sample_solution.ipynb | 410 +++++++++++++++++ 2 files changed, 832 insertions(+) create mode 100644 assignments/01_assignment_sample_solution.ipynb create mode 100644 assignments/02_assignment_sample_solution.ipynb diff --git a/assignments/01_assignment_sample_solution.ipynb b/assignments/01_assignment_sample_solution.ipynb new file mode 100644 index 0000000..f0667af --- /dev/null +++ b/assignments/01_assignment_sample_solution.ipynb @@ -0,0 +1,422 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Image Processing SS 16 - Assignment - 01\n", + "\n", + "### Deadline is 27.4.2016 at 16:00\n", + "\n", + "Please solve the assignments together with a partner.\n", + "I will run every notebook. Make sure the code runs through, when clicked on `Kernel` -> `Restart & Run All`.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction to Python / Numpy\n", + "\n", + "* [Learn Python in 15 minutes](https://learnxinyminutes.com/docs/python/)\n", + "* [Numpy for Matlab Users](https://docs.scipy.org/doc/numpy-dev/user/numpy-for-matlab-users.html#general-purpose-equivalents)\n", + "* [Numpy Quickstart](https://docs.scipy.org/doc/numpy-dev/user/quickstart.html)\n", + "\n", + "## Libraries\n", + "\n", + "We will use the following libraries:\n", + "\n", + "* matplotlib\n", + "* numpy\n", + "* scipy\n", + "* skimage\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 0 - Setup Development Enviroment - [1 Point]\n", + "\n", + "Find a partner, follow the steps in the [README](https://github.com/) and paste a link to your repository, names and matriculation numbers into the KVV assignment box.\n", + "You do not need to upload any files to the KVV. I will clone your repository. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# display the plots inside the notebook\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pylab\n", + "import copy\n", + "pylab.rcParams['figure.figsize'] = (12, 12) # This makes the plot bigger" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The [skimage](http://scikit-image.org/) library comes with multiple useful test images. Let's start with an image of an astronaut. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from skimage.data import astronaut" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "img = astronaut() # Get the image\n", + "print(img.shape) # the dimension of the image\n", + "print(img.dtype) # the image type" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have a `(512, 512, 3)` array of unsigned bytes. At `img[x, y]` there are three values for R,G and B." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will always work with floating point arrays between 0 and 1. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "img = img / 255." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets display the image." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "plt.imshow(img)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is [Eileen Collins](https://en.wikipedia.org/wiki/Eileen_Collins). She was the first astronaut \n", + " to fly the Space Shuttle through a complete 360-degree pitch maneuver. What an inspiring woman." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise 1 - Plot - [1 Point]\n", + "\n", + "Plot the R, G and B channels separately." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "img_red = copy.deepcopy(img)\n", + "img_red[:,:,1] = 0\n", + "img_red[:,:,2] = 0\n", + "plt.imshow(img_red)\n", + "plt.show()\n", + "\n", + "img_green = copy.deepcopy(img);\n", + "img_green[:,:,0] = 0\n", + "img_green[:,:,2] = 0\n", + "plt.imshow(img_green)\n", + "plt.show()\n", + "\n", + "img_blue = copy.deepcopy(img);\n", + "img_blue[:,:,0] = 0\n", + "img_blue[:,:,1] = 0\n", + "plt.imshow(img_blue)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise 2 - RGB to HSV [6 Points]\n", + "\n", + "Implement the `rgb_to_hsv` and `hsv_to_rgb` functions. Don't use any color conversion functions from a library.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def rgb_to_hsv(x):\n", + " \"\"\"\n", + " Converts the numpy array `x` from RGB to the HSV. \n", + " \"\"\"\n", + " hsv=[]\n", + " for line in x:\n", + " newLine=[]\n", + " for pixel in line:\n", + " r= pixel[0]/255\n", + " g= pixel[1]/255\n", + " b= pixel[2]/255\n", + " cMax = np.amax([r,g,b])\n", + " cMin = min([r,g,b])\n", + " delta = cMax-cMin\n", + " v = cMax\n", + " h=0\n", + " s=0\n", + " if v > 0:\n", + " s = delta/cMax\n", + " if s>0 :\n", + " if r == cMax:\n", + " h= ((g-b)/delta)%6\n", + " elif g==cMax:\n", + " h= ((b-r)/delta)+2\n", + " elif b==cMax:\n", + " h=((r-g)/delta)+4\n", + " h=h*60\n", + " if h<0:\n", + " h=h+360\n", + " newLine.append([h,s,v])\n", + " hsv.append(newLine)\n", + " return hsv\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def hsv_to_rgb(x):\n", + " \"\"\"\n", + " Converts the numpy array `x` from HSV to the RGB. \n", + " \"\"\"\n", + " rgb = []\n", + " for line in x:\n", + " newLine=[]\n", + " for pixel in line:\n", + " h= pixel[0]\n", + " s= pixel[1]\n", + " v= pixel[2]\n", + " c = v*s\n", + " x=c*(1-abs(((h/60)%2)-1))\n", + " m= v-c\n", + " tmpPixel= [0,0,0]\n", + " if h >= 0 and h <60:\n", + " tmpPixel=[c,x,0]\n", + " elif h >= 60 and h <120:\n", + " tmpPixel=[x,c,0]\n", + " elif h >= 120 and h <180:\n", + " tmpPixel=[0,c,x]\n", + " elif h >= 180 and h <240:\n", + " tmpPixel=[0,x,c]\n", + " elif h >= 240 and h <300:\n", + " tmpPixel=[x,0,c]\n", + " elif h >= 300 and h <360:\n", + " tmpPixel=[c,0,x]\n", + " newLine.append([(tmpPixel[0]+m)*255,(tmpPixel[1]+m)*255,(tmpPixel[2]+m)*255])\n", + " rgb.append(newLine)\n", + " return rgb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the saturation of the astronaut image" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "img_as_hsv = rgb_to_hsv(img)\n", + "\n", + " # your code\\n\",\n", + "\n", + "img_saturation=copy.deepcopy(np.array(img_as_hsv))\n", + "img_saturation[:,:,0]=0\n", + "img_saturation[:,:,2]=0\n", + "plt.imshow(img_saturation[:, :, 1], cmap='gray')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Increase the saturation by a factor of 2, convert it back to RGB and plot the result." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "img_as_hsv = rgb_to_hsv(img)\n", + "# your code\\n\",\n", + "img_saturation = []\n", + "for line in img_as_hsv:\n", + " newLine=[]\n", + " for pixel in line:\n", + " newPixel=[]\n", + " newPixel.append(pixel[0]) \n", + " newSaturation = pixel[1]*2\n", + " if newSaturation >1:\n", + " newSaturation=1\n", + "\n", + " newPixel.append(newSaturation)\n", + " newPixel.append(pixel[2])\n", + " newLine.append(newPixel)\n", + " img_saturation.append(newLine)\n", + "\n", + "img_as_rgb= hsv_to_rgb(img_saturation)\n", + "plt.imshow(img_as_rgb)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 3 - Callculation [2 Points]\n", + "\n", + "In the figure below you can see the [CIE-XYZ](https://de.wikipedia.org/wiki/CIE-Normvalenzsystem) color space.\n", + "![](https://upload.wikimedia.org/wikipedia/commons/4/49/CIE-Normfarbtafel.png)\n", + "\n", + "What are the approximate x,y,z values for the following Adobe RGB colors:\n", + "* `(0, 0.5, 0.5)`\n", + "* `(0.33, 0.33, 0.33)`\n", + "\n", + "A sodium-vapor lamp shines with double the intensity of a mercury-vapor lamp\n", + ". The light from the sodium lamp only contains \n", + "the spectral line at `589,00nm` and the light from the mercury lamp only the\n", + "spectral line at `435,83 nm`.\n", + "\n", + "What color does a human experience? What are the approximate x,y,z values? \n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "T=np.matrix([[2.04159, -0.56501, -0.34473],[-0.96924, 1.87597, 0.04156],[0.01344, -0.11836, 1.01517]])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "ARGB1 = np.array([0, 0.5, 0.5])\n", + "ARGB2 = np.array([0.33, 0.33, 0.33])\n", + "\n", + "XYZ1 = (T.I).dot(ARGB1)\n", + "print(XYZ1)\n", + "\n", + "XYZ2 = (T.I).dot(ARGB2)\n", + "print(XYZ2)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# For a sodium-vapor lamp and a mercury-vapor lamp a human does experience a bright red.\n", + "# The approximate x,y,z values are 0.5, 0.32, 0.18\n", + "# You can read the values directly from the XYZ-diagram. Connect the two spectral lines with a line.\n", + "# The resulting color is on this line. \n", + "# As the two colors mix and the sodium lamp has double intensity, the color that a human experience is nearer to \n", + "# the sodium lamp.\n", + "# It is exactly 1/3 of the total line length from the sodium spectral line away. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/assignments/02_assignment_sample_solution.ipynb b/assignments/02_assignment_sample_solution.ipynb new file mode 100644 index 0000000..ba14c5f --- /dev/null +++ b/assignments/02_assignment_sample_solution.ipynb @@ -0,0 +1,410 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "# Image Processing SS 16 - Assignment - 02\n", + "\n", + "### Deadline is 4.5.2016 at 16:00 o'clock\n", + "\n", + "Please solve the assignments together with a partner.\n", + "I will run every notebook. Make sure the code runs through. Select `Kernel` -> `Restart & Run All` to test it.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1 - 10 Points\n", + "\n", + "Implement affine transformation with [bicubic interpolation](https://en.wikipedia.org/wiki/Bicubic_interpolation)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# display the plots inside the notebook\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pylab\n", + "pylab.rcParams['figure.figsize'] = (12, 12) # This makes the plot bigger" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The [skimage](http://scikit-image.org/) library comes with multiple useful test images. Let's start with an image of an astronaut. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from skimage.data import astronaut\n", + "from skimage.color import rgb2gray" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# We use a gray image. All the algorithms should work with color images too.\n", + "img = rgb2gray(astronaut() / 255.)\n", + "plt.imshow(img, cmap='gray')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def derive_y(image):\n", + " \"\"\"Computes the derivative of the image w.r.t the y coordinate\"\"\"\n", + " derived_image = np.zeros_like(image)\n", + " for x in range(image.shape[0]):\n", + " for y in range(image.shape[1]):\n", + " if y + 1 < image.shape[1] and y - 1 > 0:\n", + " derived_image[x,y] = image[x, y - 1] - image[x, y + 1]\n", + " return derived_image\n", + "\n", + "def derive_x(image):\n", + " \"\"\"Computes the derivative of the image w.r.t the x coordinate\"\"\"\n", + " derived_image = np.zeros_like(image)\n", + " for x in range(image.shape[0]):\n", + " for y in range(image.shape[1]):\n", + " if x + 1 < image.shape[1] and x - 1 > 0:\n", + " derived_image[x,y] = image[x - 1, y] - image[x + 1, y]\n", + " return derived_image" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "dx_img = derive_x(img)\n", + "dy_img = derive_y(img)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "plt.figure(figsize=(18, 12))\n", + "plt.subplot(131)\n", + "plt.imshow(img, cmap='gray')\n", + "plt.subplot(132)\n", + "plt.imshow(dx_img, cmap='gray')\n", + "plt.subplot(133)\n", + "plt.imshow(dy_img, cmap='gray')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# The derivatives are no longer in the range [0,1].\n", + "print(\"min: {}, max: {}\".format(dx_img.min(), dx_img.max()))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "indicies = np.indices(img.shape).reshape(2, -1)\n", + "indicies.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# pick some random index" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "indicies[:, 123456]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "indicies_hg = np.concatenate([\n", + " indicies, np.ones((1, indicies.shape[1]))], axis=0)\n", + "indicies_hg.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "indicies_hg[:, 123456]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "T_scale = np.array([\n", + " [0.75, 0, 0],\n", + " [0, 0.75, 0],\n", + " [0, 0, 1],\n", + "])\n", + "# np.dot(T_affine, indicies_hg).shape, for python < 3.5\n", + "(T_scale @ indicies_hg).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "T_affine = np.array([\n", + " [0.75, 0.2, 100],\n", + " [-0.2, 0.75, 100],\n", + " [0, 0.001, 1],\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# you can use this function to invert the matricies\n", + "np.linalg.inv(T_scale)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def affine_transformation(img, matrix):\n", + " indicies = np.indices(img.shape).reshape(2, -1)\n", + " indicies_hg = matrix @ np.concatenate([indicies, np.ones((1, indicies.shape[1]))], axis=0)\n", + " \n", + " res_img = np.zeros((int(np.ceil(np.max(indicies_hg[0,:]))), int(np.ceil(np.max(indicies_hg[1,:])))))\n", + " indicies_res = np.indices(res_img.shape).reshape(2, -1)\n", + " indicies_res_hg = np.concatenate([indicies_res, np.ones((1, indicies_res.shape[1]))], axis=0)\n", + " indicies_interpolation = np.linalg.inv(matrix) @ indicies_res_hg\n", + " \n", + " return bicubic_interpolation(img, indicies_interpolation, matrix, res_img)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def bicubic_interpolation(img, indicies, matrix, result):\n", + " dx_img = derive_x(img)\n", + " dy_img = derive_y(img)\n", + " dxy_img = derive_x(dy_img)\n", + " inv_matrix = np.array([\n", + " [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [-3, 3, 0, 0, -2, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [ 2, -2, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 0, -3, 3, 0, 0, -2, -1, 0, 0],\n", + " [ 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 1, 1, 0, 0],\n", + " [-3, 0, 3, 0, 0, 0, 0, 0, -2, 0, -1, 0, 0, 0, 0, 0],\n", + " [ 0, 0, 0, 0, -3, 0, 3, 0, 0, 0, 0, 0, -2, 0, -1, 0],\n", + " [ 9, -9, -9, 9, 6, 3, -6, -3, 6, -6, 3, -3, 4, 2, 2, 1],\n", + " [-6, 6, 6, -6, -3, -3, 3, 3, -4, 4, -2, 2, -2, -2, -1, -1],\n", + " [ 2, 0, -2, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0],\n", + " [ 0, 0, 0, 0, 2, 0, -2, 0, 0, 0, 0, 0, 1, 0, 1, 0],\n", + " [-6, 6, 6, -6, -4, -2, 4, 2, -3, 3, -3, 3, -2, -1, -2, -1],\n", + " [ 4, -4, -4, 4, 2, 2, -2, -2, 2, -2, 2, -2, 1, 1, 1, 1]\n", + " ])\n", + "\n", + " x_size = img.shape[0]\n", + " y_size = img.shape[1]\n", + " \n", + " for i in range(indicies.shape[-1]):\n", + " point = indicies[:, i]\n", + " x_val_floor = int(np.floor(point[0]))\n", + " x_val_ceil = int(np.ceil(point[0]))\n", + " y_val_floor = int(np.floor(point[1]))\n", + " y_val_ceil = int(np.ceil(point[1]))\n", + "\n", + " if 0 < x_val_floor < x_size and 0 < x_val_ceil < x_size and 0 < y_val_floor < y_size and 0 < y_val_ceil < y_size:\n", + " func_values = np.array([\n", + " img[x_val_floor][y_val_floor], img[x_val_ceil][y_val_floor], img[x_val_floor][y_val_ceil], img[x_val_ceil][y_val_ceil],\n", + " dx_img[x_val_floor][y_val_floor], dx_img[x_val_ceil][y_val_floor], dx_img[x_val_floor][y_val_ceil], dx_img[x_val_ceil][y_val_ceil],\n", + " dy_img[x_val_floor][y_val_floor], dy_img[x_val_ceil][y_val_floor], dy_img[x_val_floor][y_val_ceil], dy_img[x_val_ceil][y_val_ceil],\n", + " dxy_img[x_val_floor][y_val_floor], dxy_img[x_val_ceil][y_val_floor], dxy_img[x_val_floor][y_val_ceil], dxy_img[x_val_ceil][y_val_ceil]\n", + " ])\n", + " alpha = inv_matrix @ func_values\n", + " res_point = matrix @ point\n", + " result[int(np.rint(res_point[0]))][int(np.rint(res_point[1]))] = calc_value(point[0] - x_val_floor, point[1] - y_val_floor, alpha)\n", + "\n", + " return result\n", + "\n", + "def calc_value(x, y, alpha):\n", + " x_pow2 = x ** 2\n", + " x_pow3 = x ** 3\n", + " y_pow2 = y ** 2\n", + " y_pow3 = y ** 3\n", + " \n", + " return alpha[0] + alpha[4] * y + alpha[8] * y_pow2 + alpha[12] * y_pow3\\\n", + " + (alpha[1] + alpha[5] * y + alpha[9] * y_pow2 + alpha[13] * y_pow3) * x\\\n", + " + (alpha[2] + alpha[6] * y + alpha[10] * y_pow2 + alpha[14] * y_pow3) * x_pow2\\\n", + " + (alpha[3] + alpha[7] * y + alpha[11] * y_pow2 + alpha[15] * y_pow3) * x_pow3\\" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "img_scale = affine_transformation(img, T_scale)\n", + "img_affine = affine_transformation(img, T_affine)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "plt.imshow(img_scale, cmap='gray')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [], + "source": [ + "plt.imshow(img_affine, cmap='gray')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5.1+" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From fcd436d3b6a12fb31b593b03a9baaf3cad9a4d5d Mon Sep 17 00:00:00 2001 From: Jakob Krause Date: Wed, 9 May 2018 10:49:26 +0200 Subject: [PATCH 2/5] added 4 assignment --- assignments/04_assignment.ipynb | 211 ++++++++++++++++++++++++++++++++ 1 file changed, 211 insertions(+) create mode 100644 assignments/04_assignment.ipynb diff --git a/assignments/04_assignment.ipynb b/assignments/04_assignment.ipynb new file mode 100644 index 0000000..28c4017 --- /dev/null +++ b/assignments/04_assignment.ipynb @@ -0,0 +1,211 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "# Image Processing SS 18 - Assignment - 04\n", + "\n", + "### Deadline is 16.5.2016 at 8:00 o'clock\n", + "\n", + "Please solve the assignments together with a partner.\n", + "I will run every notebook. Make sure the code runs through. Select `Kernel` -> `Restart & Run All` to test it.\n", + "Please strip the output from the cells, either select `Cell` -> `All Output` -> `Clear` or use the `nb_strip_output.py` script / git hook." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# display the plots inside the notebook\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pylab\n", + "try:\n", + " import urllib.request as urllib2\n", + "except ImportError:\n", + " import urllib2\n", + "\n", + "import random\n", + "try:\n", + " from StringIO import StringIO as BytesIO\n", + "except ImportError:\n", + " from io import BytesIO\n", + " \n", + "from PIL import Image\n", + "\n", + "pylab.rcParams['figure.figsize'] = (12, 12) # This makes the plot bigger" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 1 - Qualify sharpness and noise - 5 Points\n", + "\n", + "Qualify the noise and sharpness in the images. Make a plot images, noise\n", + "\n", + "Please download sample picture from [here](http://www.imageprocessingplace.com/downloads_V3/root_downloads/image_databases/standard_test_images.zip)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Load the pictures here\n", + "sample_images = None" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def qualify_noise(img):\n", + " \"\"\"Qualify the noise based on the std of a gaussian model.\n", + " You may find a window that is contant in the images.\n", + " \"\"\"\n", + " # your code here\n", + " return random.randint(0, 10)\n", + "\n", + "plt.bar(range(len(sample_images)), [qualify_noise(i) for i in sample_images])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def qualify_sharpness(img):\n", + " \"\"\"Qualify the sharpness based on the average pixel differences.\"\"\"\n", + " # your code here\n", + " return random.randint(0, 10)\n", + "plt.bar(range(len(sample_images)), [qualify_sharpness(i) for i in sample_images])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Does the result match the expectations? If not what processing step can be done?/" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise 2 - SSIM JPEG Compression - 5 Points" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def jpeg_enocde(img, quality):\n", + " pil_img = Image.fromarray(img)\n", + " buffer = BytesIO()\n", + " im1.save(buffer, \"JPEG\", quality=quality)\n", + " return buffer\n", + "\n", + "def jpeg_decode(buffer):\n", + " img = Image.open(buffer)\n", + " return np.array(img)\n", + "\n", + "def jpeg_quality_filter(img, quality):\n", + " as_jpeg = jpeg_enocde(img, quality)\n", + " return jpeg_decode(as_jpeg)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(images_for_jpeg)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "images10 = [jpeg_quality_filter(img, 10) for img in sample_images]\n", + "images50 = [jpeg_quality_filter(img, 10) for img in sample_images]\n", + "images80 = [jpeg_quality_filter(img, 10) for img in sample_images]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def ssim(img, filtered_img):\n", + " \"\"\"The SSIM similarity measure. Use the parameters from the paper \n", + " as on the second to last slide from the lecture\"\"\"\n", + " # your code\n", + " return random.randint(0, 10)\n", + "\n", + "for i, img in enumerate(images_for_jpeg):\n", + " print(i)\n", + " compressed_images = [images10[i], images50[i], images80[i]]\n", + " plt.bar(range(len(compressed_images)),\n", + " [ssim(img, comp) for comp in compressed_images])\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} From 69a50713f5c2811699f74a52519d3c2dd236ec8a Mon Sep 17 00:00:00 2001 From: Jakob Krause Date: Wed, 9 May 2018 12:03:40 +0200 Subject: [PATCH 3/5] reworked images --- assignments/04_assignment.ipynb | 40 +++++++++++++++------------------ 1 file changed, 18 insertions(+), 22 deletions(-) diff --git a/assignments/04_assignment.ipynb b/assignments/04_assignment.ipynb index 28c4017..7a86cb7 100644 --- a/assignments/04_assignment.ipynb +++ b/assignments/04_assignment.ipynb @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -58,17 +58,26 @@ "\n", "Qualify the noise and sharpness in the images. Make a plot images, noise\n", "\n", - "Please download sample picture from [here](http://www.imageprocessingplace.com/downloads_V3/root_downloads/image_databases/standard_test_images.zip)" + "Please download sample picture from [here](http://sipi.usc.edu/database/misc.zip)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Load the pictures here\n", - "sample_images = None" + "sample_images = []\n", + "direc = 'misc/' # directory of the sample pictures realtivly to your notebook\n", + "for number in [1,3,5,6]:\n", + " sample_images.append(\n", + " np.array(Image.open(direc+'4.2.0'+str(number)+'.tiff'))\n", + " )\n", + "for name in ['house', 'ruler.512']:\n", + " sample_images.append(\n", + " np.array(Image.open(direc+name+'.tiff'))\n", + " )" ] }, { @@ -117,15 +126,13 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "def jpeg_enocde(img, quality):\n", " pil_img = Image.fromarray(img)\n", " buffer = BytesIO()\n", - " im1.save(buffer, \"JPEG\", quality=quality)\n", + " pil_img.save(buffer, \"JPEG\", quality=quality)\n", " return buffer\n", "\n", "def jpeg_decode(buffer):\n", @@ -137,15 +144,6 @@ " return jpeg_decode(as_jpeg)" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "len(images_for_jpeg)" - ] - }, { "cell_type": "code", "execution_count": null, @@ -169,7 +167,7 @@ " # your code\n", " return random.randint(0, 10)\n", "\n", - "for i, img in enumerate(images_for_jpeg):\n", + "for i, img in enumerate(sample_images):\n", " print(i)\n", " compressed_images = [images10[i], images50[i], images80[i]]\n", " plt.bar(range(len(compressed_images)),\n", @@ -180,9 +178,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [] } From a7e04468162e810d01cb5282fbac7f1abea14da4 Mon Sep 17 00:00:00 2001 From: Jakob Krause Date: Wed, 9 May 2018 12:09:55 +0200 Subject: [PATCH 4/5] limit image for jpeg --- assignments/04_assignment.ipynb | 104 ++++++++++++++++++++++++++++---- 1 file changed, 93 insertions(+), 11 deletions(-) diff --git a/assignments/04_assignment.ipynb b/assignments/04_assignment.ipynb index 7a86cb7..91c1f95 100644 --- a/assignments/04_assignment.ipynb +++ b/assignments/04_assignment.ipynb @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -82,9 +82,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def qualify_noise(img):\n", " \"\"\"Qualify the noise based on the std of a gaussian model.\n", @@ -98,9 +119,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def qualify_sharpness(img):\n", " \"\"\"Qualify the sharpness based on the average pixel differences.\"\"\"\n", @@ -125,7 +167,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -144,6 +186,27 @@ " return jpeg_decode(as_jpeg)" ] }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "images_for_jpeg = sample_images[3::]\n", + "len(images_for_jpeg)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -157,9 +220,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + }, + { + "ename": "NameError", + "evalue": "name 'images10' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimages_for_jpeg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mcompressed_images\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mimages10\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimages50\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimages80\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\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 10\u001b[0m plt.bar(range(len(compressed_images)),\n\u001b[1;32m 11\u001b[0m [ssim(img, comp) for comp in compressed_images])\n", + "\u001b[0;31mNameError\u001b[0m: name 'images10' is not defined" + ] + } + ], "source": [ "def ssim(img, filtered_img):\n", " \"\"\"The SSIM similarity measure. Use the parameters from the paper \n", @@ -167,7 +249,7 @@ " # your code\n", " return random.randint(0, 10)\n", "\n", - "for i, img in enumerate(sample_images):\n", + "for i, img in enumerate(images_for_jpeg):\n", " print(i)\n", " compressed_images = [images10[i], images50[i], images80[i]]\n", " plt.bar(range(len(compressed_images)),\n", From 204b8299b7a3498ab14cef1a1a8cbaa3cd00630d Mon Sep 17 00:00:00 2001 From: Jakob Krause Date: Wed, 9 May 2018 12:17:38 +0200 Subject: [PATCH 5/5] remove last picture --- assignments/04_assignment.ipynb | 106 +++++--------------------------- 1 file changed, 17 insertions(+), 89 deletions(-) diff --git a/assignments/04_assignment.ipynb b/assignments/04_assignment.ipynb index 91c1f95..60689e6 100644 --- a/assignments/04_assignment.ipynb +++ b/assignments/04_assignment.ipynb @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -74,7 +74,7 @@ " sample_images.append(\n", " np.array(Image.open(direc+'4.2.0'+str(number)+'.tiff'))\n", " )\n", - "for name in ['house', 'ruler.512']:\n", + "for name in ['house']:\n", " sample_images.append(\n", " np.array(Image.open(direc+name+'.tiff'))\n", " )" @@ -82,30 +82,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "def qualify_noise(img):\n", " \"\"\"Qualify the noise based on the std of a gaussian model.\n", @@ -119,30 +98,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "def qualify_sharpness(img):\n", " \"\"\"Qualify the sharpness based on the average pixel differences.\"\"\"\n", @@ -167,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -188,22 +146,11 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "images_for_jpeg = sample_images[3::]\n", + "images_for_jpeg = sample_images[2::]\n", "len(images_for_jpeg)" ] }, @@ -213,35 +160,16 @@ "metadata": {}, "outputs": [], "source": [ - "images10 = [jpeg_quality_filter(img, 10) for img in sample_images]\n", - "images50 = [jpeg_quality_filter(img, 10) for img in sample_images]\n", - "images80 = [jpeg_quality_filter(img, 10) for img in sample_images]" + "images10 = [jpeg_quality_filter(img, 10) for img in images_for_jpeg]\n", + "images50 = [jpeg_quality_filter(img, 10) for img in images_for_jpeg]\n", + "images80 = [jpeg_quality_filter(img, 10) for img in images_for_jpeg]" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0\n" - ] - }, - { - "ename": "NameError", - "evalue": "name 'images10' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimages_for_jpeg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mcompressed_images\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mimages10\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimages50\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimages80\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\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 10\u001b[0m plt.bar(range(len(compressed_images)),\n\u001b[1;32m 11\u001b[0m [ssim(img, comp) for comp in compressed_images])\n", - "\u001b[0;31mNameError\u001b[0m: name 'images10' is not defined" - ] - } - ], + "outputs": [], "source": [ "def ssim(img, filtered_img):\n", " \"\"\"The SSIM similarity measure. Use the parameters from the paper \n",