{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Exercise 1: The basics of image processing\n", "=======================\n", "\n", "To complete the exercise, follow the instructions and complete the missing code and write the answers where required. All points, except the ones marked with **(N points)** are mandatory. The optional tasks require more independent work and some extra effort. Without completing them you can get at most 75 points for the exercise (the total number of points is 100 and results in grade 10). Sometimes there are more optional exercises and you do not have to complete all of them, you can get at most 100 points.\n", "\n", "If you have not used Python, IPython and Jupyter environment before, take a look at the following list introductory tutorials:\n", "\n", " * [Introduction to Python 3](https://realpython.com/python-introduction/)\n", " * [Useful IPython facts](https://ipython.org/ipython-doc/3/interactive/tutorial.html)\n", " * [Introduction to Jupyter notebooks](https://www.dataquest.io/blog/jupyter-notebook-tutorial/)\n", " * [Introduction to NumPy, SciKit, MatPlotLib](https://cs231n.github.io/python-numpy-tutorial/)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# First, run this cell to download the data used in this exercise\n", "import zipfile, urllib.request, io\n", "zipfile.ZipFile(io.BytesIO(urllib.request.urlopen(\"http://data.vicos.si/lukacu/multimedia/exercise1.zip\").read())).extractall()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Assignment 1: Image processing, histograms, filters\n", "----------\n", "\n", "The aim of this assignment is to familiarize yourself with the basic functionality of SciKit, NumPy and MatPlotLib, as well as the use of matrices for storing image information. In this assignment, you will try to load an image, display it and manipulate its content with NumPy operations." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * Read image from the file `umbrellas.jpg`, and display it using functions skimage.io.imshow. The image that you have loaded consists of three channels (Red, Green, and Blue), and is represented as a 3-D matrix with dimensions height \u00d7 width \u00d7 channels." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Use this IPython command to enable interactive plots (without it they will be rendered only as static images)\n", "%matplotlib notebook\n", "\n", "# We will be using SciKit-Image library for image IO and image processing and MatPlotLib \n", "# for visualization in the notebook.\n", "from skimage import data, io\n", "from matplotlib import pyplot as plt\n", "\n", "image = io.imread(\"umbrellas.jpg\")\n", "plt.imshow(image) # Draw the image\n", "plt.show() # Display the image" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * You can query the dimensions of the matrix using the property `shape`. Observe that a color image has three layers (third dimension), while a grayscale image has only one layer and is also missing the third dimension. Also check the dtype of the matrix, by default images are presented using uint8 type (unsigned integers in range 0 to 255)." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "print(image.shape)\n", "\n", "gray = io.imread(\"phone.jpg\")\n", "print(gray.shape)\n", "\n", "print(image.dtype)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * Convert the color image into a grayscale one by averaging all three channels. Be careful when visualizing single channel images as they are not always visualized as grayscale. It is important to correctly set the colormap of the plot." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# We will be using numpy library for low-level matrix operations.\n", "import numpy as np\n", "\n", "gray = np.mean(image, 2) # Function numpy.mean converts image to float64\n", "print(gray.dtype) # Display the data type of matrix\n", "\n", "plt.figure()\n", "plt.imshow(gray.astype(np.uint8), cmap = plt.cm.gray) # If we want to display image correctly we have to cast it to uint8 again.\n", "plt.show()\n", "\n", "plt.figure()\n", "plt.imshow(gray.astype(np.uint8), cmap = plt.cm.jet) # Change colormap to interpret values differently.\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * Cut out a rectangular sub-image, and display it as a new image. Mark the same region in the original image by setting its third (the blue) color channel to 0, and display the modified image." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "cutout = image[100:200, 100:200, 1]\n", "plt.imshow(cutout)\n", "plt.show()\n", "\n", "# TODO: set a part of the image to 0 using range-indexing notation." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * Display a grayscale image that has the selected region negated (its values are inverted)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# TODO: use the same region as before. You can use matrix-scalar operations to achieve negation (255 - A)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * Compute and display a thresholded binary image. Thresholding is an image operation that produces a binary image (mask) of the same size as the source image; its values are 1 (true) and 0 (false), depending on whether the corresponding pixels in the source image have values greater or lower than the specified threshold. Use a threshold of 150, and display the resulting image. Experiment with different thresholds and write down your observations." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "image = io.imread(\"umbrellas.jpg\")\n", "\n", "gray = np.mean(image, 2)\n", "\n", "_, ax = plt.subplots(1, 3, figsize=(9, 4)) # Divide plot into a grid of axes, use each handle to draw on subplot\n", "\n", "ax[0].imshow(image)\n", "ax[1].imshow(gray, cmap=plt.cm.gray)\n", "\n", "thresholded = gray > 150\n", "ax[2].imshow(thresholded, cmap=plt.cm.gray)\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we will take a look at the construction of histograms. Histograms are a very useful tool in image analysis; as we will be using them extensively in the later exercises, it is recommended that you pay extra attention to how they are built. In this assignment, we will focus on the construction of histograms for single-channel (grayscale) images. We will use function `skimage.exposure.histogram` which has some useful modes. Check the documentation for arguments `nbins`, `source_range` and `normalize` and write down their function. What is the meaning of variables returned by the function?\n", "\n", "The second part of the assignment expects you to try out several image filtering approaches, this is another useful basic technique that is used frequenlty in our next assignments." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from skimage.exposure import histogram\n", "\n", "image = np.mean(io.imread(\"umbrellas.jpg\"), 2).astype(np.uint8)\n", "hvalues, hbins = histogram(image, nbins=256, source_range='dtype', normalize=False)\n", "\n", "print(hvalues)\n", "print(hbins)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * Compute histogram for more than one image of your choice and visualize the results using `matplotlib.pyplot.bar`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "_, ax = plt.subplots(2, 1, figsize=(4, 8))\n", "\n", "ax[0].imshow(image, cmap = plt.cm.gray)\n", "ax[1].bar(hbins, hvalues) # Use this function to draw a bar graph\n", "plt.show()\n", "\n", "# TODO: add at least two more images and their histograms to the left of the figure." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * For this task, you will implement a simple image operation called *histogram stretching*. Using the pseudo-code provided below, implement the function `histstretch`, which performs the histogram stretching on the input grayscale image. For the outline of the algorithm, consult the slides from the lectures. As we are performing the same operation (with the same factors) on all image elements, the operation can be sped-up via use of matrix operations, which perform the operation on the whole image at once. Do not use any existing function to simplify your work, this assignment should test your skills a bit.\n", " \n", " Hints: The maximum and the minimum grayscale value in the input image, can be determined using functions `np.max` and `np.min`.\n", " \n", " Test the function by writing a script that reads an image from file `phone.jpg` (note that it is already a grayscale image), compute the histogram with 256 bins, and displays it. As you can observe from the histogram, the lowest grayscale value in the image is not 0, and the highest value is not 255. Perform the histogram stretching operation and visualize the results (display the image and plot its 256-bin histogram)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def histstretch(image):\n", " # 1. determine the minimum and maximum value of I\n", " # 2. the minimum and maximum of the output image S are known\n", " # 3. use the stretch formula to compute new value for each pixel\n", " pass\n", " \n", "# TODO: write a code to test your function" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * **(5 points)** How would you use the different color spaces to perform the histogram stretching operation to improve the contrast, but without distorting the colors? Find a color image with weak contrast and write a script that demonstrates your solution on it. Use existing hisotgram equalization in `skimage.exposure.equalize_hist` to improve single-channel image, but note that the function only works correctly on grayscale images, so an extra step is required to achieve correct adjustment. Use the `flowers.jpg` image for testing." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# TODO\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * Now lets look at linear filtering operations. We will not implement them, instead we will simply test the effects of some common operations on images. Write a script that loads images `umbrellas.jpg` and `trucks.jpg`, converts them to grayscale and filters them using Gaussian filter, Sobel filter, and Median filter. You can find implementations of all three filters in the `skimage.filters` module. Visualize the results for default parameter values. Which of the three are linear filters? What effect does `sigma` parameter have for Gaussian filter?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# TODO" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * (**5 points**) Implement image sharpening as a combination of blurring and pixel-wise operations as it was described at the lectures. How can you control the impact of the sharpening on the input image? To complete the task you have to understand the underlying principle, not just show the implementation." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# TODO" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Assignment 2: Geometric transformations\n", "-----\n", " \n", "A homography is a bijective transformation between two projection spaces, in our case planes; the first plane is the source image plane, while the second plane is defined by input points that denote an area in which we wish to embed the source image. A homography s described by a matrix; in case of transformation between two planes, it has dimension\n", "3 \u00d7 3." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * Write a script in which you read and display the image from file `monitor.jpg`, and determine a polygon of four points. It is recommended that you pick the four points that correspond to the corners of the monitor in the image. Determine a suitable order of points (for example, begin at top-right corner and continue in counter-clockwise direction). Afterwards, display a polygon that is defined by the selected points (e.g. set the pixels within the polygon to white as shown in the example below). " ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "image = io.imread(\"monitor.jpg\")\n", "\n", "p2 = [(50, 50), (400, 50), (600, 600), (40, 400)] # Change destination point coordinates here\n", "fig = plt.figure()\n", "io.imshow(image)\n", "xs, ys = zip(*p2) # Convert points to vertices of x and y coordinates (handy function in Python)\n", "plt.fill(xs, ys, edgecolor='r', fill=False)\n", "plt.show()\n", "\n", "def onclick(event):\n", " value = str(event) # Dynamically update the text box above\n", " print(value)\n", "\n", "# Create an hard reference to the callback not to be cleared by the garbage collector\n", "ka = fig.canvas.mpl_connect('button_press_event', onclick)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * Create a script that reads an image and uses the its dimensions and the selected points to compute the homography, using the function estimate_homography. This function returns the homography matrix H, which can be used to transform pixel-coordinates from the source image plane using the following formula:\n", "\\begin{equation}\n", "\\label{eq:homography1}\n", "p^\\prime_b = \\mathbf{H}_{ab}p_a \\,\n", "\\end{equation}\n", "with the following individual parts of the equation:\n", "\\begin{equation}\n", "\\label{eq:homography2}\n", "p_a = \\begin{bmatrix} x_a\\\\y_a\\\\1\\end{bmatrix}, p^\\prime_b = \\begin{bmatrix} w^{\\prime}x_b\\\\w^{\\prime}y_{b}\\\\w^{\\prime}\\end{bmatrix}, \\mathbf{H}_{ab} = \\begin{bmatrix} h_{11}&h_{12}&h_{13}\\\\h_{21}&h_{22}&h_{23}\\\\h_{31}&h_{32}&h_{33} \\end{bmatrix}.\n", "\\end{equation}" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def estimate_homography(p1, p2):\n", " A = np.zeros((8,9))\n", " # Homography matrix\n", " for i in range(4): # Using the corners\n", " A[i*2,:] = [ p1[i][0], p1[i][1], 1, 0, 0, 0, -p2[i][0]*p1[i][0], -p2[i][0]*p1[i][1], -p2[i][0] ]\n", " A[i*2+1,:] = [0, 0, 0, p1[i][0], p1[i][1], 1, -p2[i][1]*p1[i][0], -p2[i][1]*p1[i][1], -p2[i][1] ]\n", "\n", " [U,S,V] = np.linalg.svd(A)\n", " return np.reshape(V[-1,:],(3,3))\n", "\n", "p1 = [(0, 0), (100, 0), (100, 100), (0, 100)] # Some dummy source points\n", "\n", "H = estimate_homography(p1, p2)\n", "\n", "print(H)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * As can be seen from equations above, the resulting point $p^\\prime_b$ is in homogenous form, i.e. before we can use its coordinates, they need to be divided by $w^{\\prime}$. Homography equation allows you to transform the coordinates of each pixel from the original image to its destination coordinates in the target image. Replace the pixels in the target image with the corresponding pixels from your source image.\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "destination = io.imread(\"monitor.jpg\")\n", "source = io.imread(\"trucks.jpg\")\n", "\n", "p1 = [(0, 0), (source.shape[1], 0), (source.shape[1], source.shape[0]), (0, source.shape[0])]\n", "print(p2)\n", "H = estimate_homography(p1, p2)\n", "\n", "# * Iterate over the source image and map every source pixel to destination one:\n", "# * Generate its homogeneous coordinate and project it using matrix H\n", "# * Obtain coordinates in the destination image by normalizing x an y with w and rounding\n", "# * Copy values from source to destination (be careful about the out-of-image coordinates)\n", "# * Display the resulting image\n", "\n", "# TODO: write the wrapping algorithm and a testing script\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * **(5 points)** What is the problem with the pixel mapping approach that we have used in the previous task? Write a better pixel mapping that you have discussed at the lectures that will not have the same problems. Test the base and improved approaches by using the following reference points: `p1 = [(50, 50), (400, 50), (600, 600), (40, 400)]`. Note that increasing the resolution of the source image before projection is not a valid solution." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# TODO" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * **(5 points)** You have probably implemented mapping as a double for-loop in Python. To practice matrix operations, try implementing the entire process (forward or backward projection) without explicit for-loops." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# TODO" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Assignment 3: Blending images\n", "----\n", "\n", "Another more sophisticated image manipulation technique is image blending. The simplest way to do blending is by combining the two images based on the information from the mask, use the color information from the background image if the mask is `0` and color information from foreground image if the mask is `1`. An extension of this technique uses mask values as weights when summing up two images, in this case the mask is used as the alpha (transparency) mask of the foreground that is blended upon the background image. \n", "\n", "* Implement a function `blend_alpha` that receives two color images and a mask and combines them using equation:\n", "\n", " \\begin{equation}\n", " \\mathbf{M}_i = \\alpha_i \\mathbf{F}_i + (1 - \\alpha_i) \\mathbf{B}_i,\n", " \\end{equation}\n", "\n", " You can assume that the mask and both images are of the same size. Remember to convert the image data to floating point data type for the calculation and then back to uint8. Test the function by loading image from `eagle.jpg` as foreground image, image from file `underwater.jpg` as background image and mask from file `eagle_mask.png` and visualizes the result. " ] }, { "cell_type": "code", "execution_count": 110, "metadata": {}, "outputs": [], "source": [ "def blend_alpha(F, B, alpha):\n", " #TODO: writhe a simple blending function\n", " pass\n", "\n", "#TODO: write a testing script\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " * As you have heard at the lectures, a more realistic merging can be obtained by taking care of individual frequency bands using a Laplace pyramid. This approach automatically blends higher frequencies in the image with a more precise mask and lower frequencies with a more smoothed mask. For this task you have to first implement function `gaussian_pyramid` to compute an increasingly more blurred image and then proceed to `laplacian_pyramid` that computes the Laplacian pyramid as is explained in the lecture slides. Again, be careful regarding data types, also remember that floating point operations introduce errors so it is a good practice to clip values to a valid interval using `np.clip`. You can use function `skimage.filters.gaussian` to calculate images filtered with a Gaussian (you have to set parameter `preserve_range` to `True`). Test the correctness by visualizing the layers of the pyramid. Experiment with sigma parameter for Gaussian kernel as well as the number of pyramid levels." ] }, { "cell_type": "code", "execution_count": 101, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from skimage import filters\n", "import math\n", "\n", "def gaussian_pyramid(I, levels):\n", " # TODO: write function that generates Gaussian pyramid for a given image\n", " pass\n", "\n", "def laplacian_pyramid(I, levels):\n", " # TODO: write function that generates Laplacian pyramid for a given image\n", " pass\n", " " ] }, { "attachments": { "image.png": { "image/png": "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" } }, "cell_type": "markdown", "metadata": {}, "source": [ "* (**5 points**) Implement a function `blend_laplace` that performs merging using frequency separation. If operating on color images you will have to do this for every channel separately and combine the result. Write a script that tests the function using the same input as before and visualizes the result. Besides image pairs from the previous tasks also test the method on the pair of images `autumn1.jpg` and `autumn2.jpg` together with mask from `autumn_mask.png` and compare how the images are stitched together using Laplace blending in comparison to regular smoothed mask. \n", "\n", " Finally test also on pair of images `eye.jpg` and `hand.jpg` together with mask from `eye_mask.png`. A reference for the last pair is the image below. ![image.png](attachment:image.png)" ] }, { "cell_type": "code", "execution_count": 111, "metadata": {}, "outputs": [], "source": [ "def blend_laplace(F, B, alpha):\n", " # 1. Compute the Laplace pyramids for background and foreground images.\n", " # 2. Compute the Gaussian pyramid for the mask.\n", " # 3. Combine corresponding layers of all three pyramids using weighted averaging (as done in the previous task).\n", " # 4. Calculate the resulting image by flattening the resulting pyramid (summing up the layers together into a single image).\n", " # TODO\n", " pass\n", "\n", "# TODO: use the function\n" ] } ], "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.7.3" } }, "nbformat": 4, "nbformat_minor": 2 }