02_Images.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QuUAgQFQlsJU"
      },
      "source": [
        "# Tutorial 02 - OpenCV\n",
        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Digital-Media/di_cv/blob/main/02_Images.ipynb)\n",
        "\n",
        "## Dr. David C. Schedl\n",
        "\n",
        "Note: this tutorial is geared towards students **experienced in general programming** and aims to introduce you to OpenCV.\n",
        "\n",
        "Adapted from: \n",
        "* http://6.869.csail.mit.edu/fa19/schedule.html (written by Julie Ganeshan; @MIT)\n",
        "\n",
        "Useful links:\n",
        "* OpenCV Tutorials: https://docs.opencv.org/master/d9/df8/tutorial_root.html\n",
        "* Image Processing in Pyhton: https://github.com/xn2333/OpenCV/blob/master/Seminar_Image_Processing_in_Python.ipynb\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GVOsLEGclsJZ"
      },
      "source": [
        "# Contents\n",
        "\n",
        "Table of Contents  \n",
        "- [Images in Python](#Images-in-Python)\n",
        "    - Plain Python images\n",
        "    - Numpy arrays\n",
        "    - Grayscale images\n",
        "- [Image Statistics](#Simple-Image-Statistics)\n",
        "- [OpenCV (Computer Vision)](#OpenCV)\n",
        "    - Reading images\n",
        "    - Channel and Image Formats\n",
        "    - Showing images\n",
        "    - Color channels\n",
        "    - Manipulating images\n",
        "    - Writing images\n",
        "- [Point Operations](#Point-Operations)\n",
        "- [Color Spaces][#color-spaces]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "weMMc2WZlsJc"
      },
      "source": [
        "# Initilization"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zkUzZ6lWK_S5"
      },
      "source": [
        "Let's import useful libraries, first."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Gpvh7PPVlsJg"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import cv2 # openCV\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import plotly.graph_objects as go\n",
        "import plotly.express as px\n",
        "import plotly.io as pio"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DnGyZdM2LH71"
      },
      "source": [
        "We work with images today. So let's download some.\n",
        "You can download images with the Unix/Windows command `curl`. Images are in the local filesystem after downloading.\n",
        "\n",
        "Image sources:\n",
        "\n",
        "* [Place Kitten](https://placekitten.com/) - Of course, we will use pictures of cats! We use the base Place Kitten URL followed by a width and height separated by backslashes ''/''. For example, use the URL `https://placekitten.com/500/300` to fetch a cat image with a width of 500px and height of 300px.\n",
        "* A picture of [Van Gogh from wikimedia](https://upload.wikimedia.org/wikipedia/commons/thumb/b/b2/Vincent_van_Gogh_-_Self-Portrait_-_Google_Art_Project.jpg/842px-Vincent_van_Gogh_-_Self-Portrait_-_Google_Art_Project.jpg) in a decent resolution. \n",
        "* You can use any other image, if you want."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XTgznuO-LMMH",
        "outputId": "df1f181b-e95e-423f-ddc9-71ae71512ca7",
        "tags": []
      },
      "outputs": [],
      "source": [
        "!curl -o \"cat.jpg\" \"http://placekitten.com/367/480\" --silent\n",
        "!curl -o \"gogh.jpg\" \"https://upload.wikimedia.org/wikipedia/commons/thumb/3/32/Vincent_van_Gogh_-_National_Gallery_of_Art.JPG/367px-Vincent_van_Gogh_-_National_Gallery_of_Art.JPG\" --silent"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Images in Python <a name=\"Images-in-Python\" id=\"Images-in-Python\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Plain python image\n",
        "\n",
        "We start with images in plain Python. \n",
        "Let's start simple with a binary image (0 or 1). <br>\n",
        "We only use 0 and 1 for the pixels, the datatype, however, is `int` and not `bool`. <br>\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# define the pixels of a binary (0/1) 8x8 image with a smiley face\n",
        "pixels_binary = [\n",
        "#col:0  1  2  3  4  5  6  7 \n",
        "    [0, 0, 1, 1, 1, 1, 0, 0], # row 0  \n",
        "    [0, 1, 0, 0, 0, 0, 1, 0], # row 1\n",
        "    [1, 0, 1, 0, 0, 1, 0, 1], # row 2\n",
        "    [1, 0, 0, 0, 0, 0, 0, 1], # row 3\n",
        "    [1, 0, 1, 0, 0, 1, 0, 1], # row 4\n",
        "    [1, 0, 0, 1, 1, 0, 0, 1], # row 5\n",
        "    [0, 1, 0, 0, 0, 0, 1, 0], # row 6\n",
        "    [0, 0, 1, 1, 1, 1, 0, 0]  # row 7\n",
        "]\n",
        "\n",
        "# display the binary image with plotly\n",
        "fig = px.imshow(pixels_binary)\n",
        "# per default plotly uses a blue-2-yellow colormap. To set the colormap to gray uncomment the following line:\n",
        "# fig.layout.coloraxis.colorscale = \"gray\"\n",
        "fig.show()\n",
        "\n",
        "# Note that row is the v or y axis and column is the u or x axis.\n",
        "print(pixels_binary[2]) # retrieves row 2 (the eyes)\n",
        "print(type(pixels_binary[0][0])) # the datatype in python is integer!\n",
        "# ERROR: pixels_binary[0,0] # this is not valid in python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Numpy Images\n",
        "\n",
        "We can also use NumPy arrays to store images. <br>\n",
        "From the last tutorial, we know that with NumPy we can efficiently store matrices and define a datatype. <br>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "np_binary = np.array(pixels_binary, dtype=bool) # convert to numpy array\n",
        "\n",
        "# display the binary image with plotly\n",
        "fig = px.imshow(np_binary)\n",
        "# per default plotly uses a blue-2-yellow colormap. To set the colormap to gray uncomment the following line:\n",
        "# fig.layout.coloraxis.colorscale = \"gray\"\n",
        "fig.show()\n",
        "\n",
        "print(np_binary[2]) # retrieves row 2 (the eyes)\n",
        "print(type(np_binary[0][0])) # the datatype in python is integer!\n",
        "print(np_binary[0,0]) # this is not valid in plain python, but works in numpy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Grayscale Images"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# define the pixels of an 8-bit grayscale (0-255) image with a smiley face\n",
        "pixels_grayscale = np.asarray([\n",
        "#col:  0    1    2    3    4    5    6    7 \n",
        "    [  0,   0, 125, 125, 125, 125,   0,   0], # row 0  \n",
        "    [  0, 125,   0,   0,   0,   0, 125,   0], # row 1\n",
        "    [125,   0, 255,   0,   0, 255,   0, 125], # row 2\n",
        "    [125,   0,   0,   0,   0,   0,   0, 125], # row 3\n",
        "    [125,   0, 180,   0,   0, 180,   0, 125], # row 4\n",
        "    [125,   0,   0, 180, 180,   0,   0, 125], # row 5\n",
        "    [  0, 125,   0,   0,   0,   0, 125,   0], # row 6\n",
        "    [  0,   0, 125, 125, 125, 125,   0,   0]  # row 7\n",
        "], dtype=np.uint8)\n",
        "\n",
        "# display the binary image with plotly\n",
        "fig = px.imshow(pixels_grayscale)\n",
        "fig.layout.coloraxis.colorscale = \"gray\"\n",
        "fig.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Simple Image Statistics 📝 <a name=\"Simple-Image-Statistics\"></a>\n",
        "\n",
        "Let's compute some simple statistics on the image with NumPy. <br>\n",
        "It is very simple (typically one line of code). <br>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "pixel_count = pixels_grayscale.shape[0] * pixels_grayscale.shape[1]\n",
        "min_value = np.min(pixels_grayscale)\n",
        "max_value = np.max(pixels_grayscale)\n",
        "mean_value = np.mean(pixels_grayscale)\n",
        "std_value = np.std(pixels_grayscale)\n",
        "# somewhat special: the median is the value that is in the middle of the sorted list of values\n",
        "median_value = np.median(pixels_grayscale)\n",
        "\n",
        "\n",
        "print(f\"image statistics: pixel_count={pixel_count}, min={min_value}, max={max_value}, mean={mean_value}, std={std_value}, median={median_value}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 📝 Exercise 01\n",
        "\n",
        "With NumPy all statistic computations are one-liner (see above). \n",
        "Let's also compute the statistics without NumPy. <br>\n",
        "How would you compute the statistics using for loops?\n",
        "You can compare your results to the NumPy results. <br>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Todo: manually compute the statistics\n",
        "m_min, m_max, m_mean, m_std, m_median = 255, 0, 0, 0, 0\n",
        "\n",
        "\n",
        "print(f\"manual image statistics: min={m_min}, max={m_max}, mean={m_mean}, std={m_std}, median={m_median}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RfdV9IkflsT_"
      },
      "source": [
        "# OpenCV <a name=\"opencv\" id=\"opencv\" ></a>\n",
        "\n",
        "OpenCV is an extremely popular computer vision library built in C++, with many powerful tools for CV. It lets you read, write, and show images and videos, read from webcam streams, find matching keypoints between two images, and more.\n",
        "\n",
        "OpenCV is written in C++, however, there is a Python library that uses these optimized C++ libraries, and exposes an API using NumPy arrays!\n",
        "\n",
        "Let's import OpenCV"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QvZMt995lsUA"
      },
      "outputs": [],
      "source": [
        "import cv2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AKjPEnsTlsUD"
      },
      "source": [
        "## Reading images\n",
        "\n",
        "You can use the `imread` function to read in an image from a filepath."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mhdy1tN_lsUE"
      },
      "outputs": [],
      "source": [
        "image = cv2.imread(\"gogh.jpg\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1J28iYBklsUF"
      },
      "source": [
        "Images in OpenCV are represented as NumPy arrays, so we have the full power of NumPy at our disposal!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BklZk6RJlsUG",
        "outputId": "b95d3f89-2eb3-4580-e8db-ca3afe87e25f"
      },
      "outputs": [],
      "source": [
        "type(image), image.shape, image.dtype"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yrp_h0RllsUI"
      },
      "source": [
        "## Channels and image formats\n",
        "The shape of a color image is (height, width, colors BGR) \\\n",
        "While it may seem strange that the height is first, it's because OpenCV treats images as \"Rows\" and \"Columns\" of an image. The \"height\" of an image is the number of rows!\n",
        "\n",
        "Color images consist of \"channels\" - each color we can render is some combination of red, green, and blue (OR, in the case of a grayscale image, gray)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ik6aUO75lsUJ",
        "outputId": "38bd41f7-4eda-4020-a281-234792fd6be6"
      },
      "outputs": [],
      "source": [
        "image.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s7XtSj29lsUN"
      },
      "source": [
        "You can see each pixel is represented by 3 values (uint8 means they are between 0 and 255)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CUOUHsFdlsUQ",
        "outputId": "ffbf5754-aa64-4e33-d7ad-5b9238b72ca1"
      },
      "outputs": [],
      "source": [
        "image[0,0] # Get the pixel located at (0,0) from the top left"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uaa3_J_flsUY"
      },
      "source": [
        "## Showing the image "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C0QD2dOclsUZ"
      },
      "source": [
        "We have multiple possibilities to show an image with OpenCV. \n",
        "If you're running scripted Python (not Jupyter notebook) the `cv2.imshow` command will display an image. However, this causes problems in jupyter notebooks (see [this issue](https://github.com/jupyter/notebook/issues/3935)). \n",
        "In Google Colab, you can can use the following function as replacement: `from google.colab.patches import cv2_imshow`.\n",
        "\n",
        "We will directly use Plotly or Matplotlif for showing images. Use whatever you prefer."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bb99ZO08TN6f"
      },
      "source": [
        "## Display with Matplotlib and Plotly\n",
        "\n",
        "We can plot an image with matplotlib. This is very useful if you want to draw on top of images. OpenCV provides basic functions, but Matplotlib is much better (e.g., dashed lines are not possible with OpenCV).\n",
        "\n",
        "Since images are numpy array this should be easy, right?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "id": "C3FT51uRTkI6",
        "outputId": "017574de-1d98-4dfc-b487-f8befec4ab21"
      },
      "outputs": [],
      "source": [
        "plt.imshow(image)\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We can also directly display NumPy arrays with Plotly. \n",
        "Plotly has one big advantage over Matplotlib: it is interactive!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# display the image with plotly\n",
        "fig = px.imshow(image)\n",
        "fig.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fzc0htGqlsUU"
      },
      "source": [
        "\n",
        "**Colors are not right! What is happening?**\n",
        "\n",
        "By default, color images are opened by OpenCV as BGR, meaning the values for a given pixel are ordered \"blue, green, red\".\n",
        "\n",
        "We can use the `cv2.cvtColor` function to change which color system our image is in."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "id": "nYFD7gb1lsUV",
        "outputId": "0ad09454-c8cd-47a0-9742-6a31558ccd38"
      },
      "outputs": [],
      "source": [
        "image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
        "plt.imshow(image_rgb)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H1eFaTIelsUb"
      },
      "source": [
        "Matplotlib and Plotly (like most libraries) assumes images are in the **RGB** format. OpenCV assumes that images are in the **BGR** format. So, we'll convert colors before showing the image. Here is a function to show OpenCV images with matplotlib."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q1M69bUGlsUc"
      },
      "outputs": [],
      "source": [
        "def imshow(image, library = 'plotly', *args, **kwargs):\n",
        "    image = np.clip(image, 0, 255).astype(np.uint8)\n",
        "    if len(image.shape) == 3:\n",
        "      # Height, width, channels\n",
        "      # Assume BGR, do a conversion  \n",
        "      image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
        "    else:\n",
        "      # Height, width - must be grayscale\n",
        "      # convert to RGB, since matplotlib will plot in a weird colormap (instead of black = 0, white = 1)\n",
        "      \n",
        "      image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)\n",
        "\n",
        "    if library == 'matplotlib':\n",
        "      # Draw the image\n",
        "      plt.imshow(image, *args, **kwargs)\n",
        "      # We'll also disable drawing the axes and tick marks in the plot, since it's actually an image\n",
        "      plt.axis('off')\n",
        "      # Make sure it outputs\n",
        "      plt.show()\n",
        "    elif library == 'plotly':\n",
        "      fig = px.imshow(image, *args, **kwargs)\n",
        "      fig.show()\n",
        "\n",
        "imshow(image, library='plotly')\n",
        "imshow(image, library='matplotlib')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MAWGcridRP4h"
      },
      "source": [
        "## Color channels\n",
        "\n",
        "Let's seperate the color channels and display them:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "WUnb4agORPC6",
        "outputId": "c79bc112-e530-4f12-a3c4-a6b49fb5b30c"
      },
      "outputs": [],
      "source": [
        "c1, c2, c3 = image[:,:,0], image[:,:,1], image[:,:,2]\n",
        "\n",
        "# let's display them\n",
        "imshow(c1)\n",
        "imshow(c2)\n",
        "imshow(c3)\n",
        "\n",
        "# or in a row by concatinating them\n",
        "imshow( np.concatenate((c1,c2,c3), axis=1) )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2HnYFtCOlsUi"
      },
      "source": [
        "## Manipulating images\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xp2T7RjElsUl"
      },
      "source": [
        "### Changing individual channels\n",
        "\n",
        "\n",
        "We also can manipulate it by doing anything we would to a normal array. Let's make an image that includes the *green* channel as the *blue* channel and *red* channels, and nothing in the green channels."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 515
        },
        "id": "d1Zo26CFlsUm",
        "outputId": "644d9606-c78a-407b-beb8-dd5ee267c356"
      },
      "outputs": [],
      "source": [
        "empty_arr = np.zeros(c2.shape, dtype=np.uint8)\n",
        "\n",
        "# Stack them, making the 3rd axis\n",
        "manipulated_image = np.stack([ c1, empty_arr, c3, ], axis=2)\n",
        "print(\"Created image of shape\",manipulated_image.shape)\n",
        "imshow(manipulated_image)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gjWQYjYVlsUt"
      },
      "source": [
        "## Writing an Image"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6VM0EQJhlsUt"
      },
      "source": [
        "The `imwrite` function can write out an image. Let's write out the image we just made, so we can use it later!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uB7vl5ehlsUu",
        "outputId": "176eef6f-37a0-4e5b-f2d1-81dfdd12df07"
      },
      "outputs": [],
      "source": [
        "output_path = os.path.join(\"output.png\")\n",
        "cv2.imwrite(output_path, manipulated_image)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OCG0F5m7lsUw"
      },
      "source": [
        "We should be able to read that image directly from the file. Let's try!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 515
        },
        "id": "T79N7N7DlsUx",
        "outputId": "c4e43522-f525-447d-dfe6-7c6aa938b4e4"
      },
      "outputs": [],
      "source": [
        "test_read_output = cv2.imread(output_path)\n",
        "print(\"Read file of shape:\",test_read_output.shape, \"type\",test_read_output.dtype)\n",
        "imshow(test_read_output)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oEVrCiEQlsUz"
      },
      "source": [
        "Everything works as expected!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Point Operations 📝 <a name=\"point-operations\" id=\"point-operations\" ></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JHyGmaqu9kTd"
      },
      "source": [
        "## 📝 Exercise 02\n",
        "\n",
        "**Grayscale:** Color is nice, but monochrome images are also very appealing.\n",
        "Displaying a single color channel does not really look nice. So we need a weighted sum of all channels.\n",
        "Typical weights to convert from RGB to grayscale are: \n",
        "> $0.2989 * R + 0.5870 * G + 0.1140 * B$\n",
        "\n",
        "**(a)** Load the image `gogh.jpg`. Convert it to grayscale and display it. Don't forget that channels are BGR.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 497
        },
        "id": "FZickyq-9n-9",
        "outputId": "507c259b-d59f-457a-a90b-5fbd6ea916bb"
      },
      "outputs": [],
      "source": [
        "# Solution (a)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Homegeneous point operation**: We can apply a function to each pixel of an image independently.\n",
        "Let's apply a contrast stretch by 30% to the image. \n",
        "For simplicity, we will use a grayscale image.\n",
        "\n",
        "**(b)** Load the image `gogh.jpg`. Convert it to grayscale and stretch its contrast by 30% before displaying it.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kDJUDbsLu39C"
      },
      "outputs": [],
      "source": [
        "# Solution (b)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Non-homegeneous point operation**: We can  modify pixels of an image based on a second (or multiple other) images.\n",
        "Let's use this idea to alpha blend the `gogh.jpg` image with the `cat.jpg` image. <br>\n",
        "For this operation we need a third image, which will act as the alpha channel. Let's simply use a gradient from left to right. \n",
        "\n",
        "**(c)** Load the images `gogh.jpg` and `cat.jpg`. Convert them to grayscale and alpha blend them with a gradient as alpha channel. Display the result.  <br>\n",
        "\n",
        "For the alpha channel, you can use the following code:\n",
        "```python\n",
        "alpha = np.linspace(0, 1, width)\n",
        "alpha = np.tile(alpha, (height, 1))\n",
        "```\n",
        "\n",
        "A simple point-wise multiplication of matrices can be applied with the `*` operator. <br>\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Solution (c)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**Advanced**: Some advanced operations that you can try out: <br>\n",
        "\n",
        "**(d)**: Can you also do it with color images? <br> \n",
        "**(e)**: Can you apply vignetting (the image gets darker towards the borders) to the image? <br>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Color Spaces in OpenCV <a name=\"color-spaces\" id=\"color-spaces\"></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "OpenCV has a lot of built-in color spaces. We can convert between them using the `cv2.cvtColor` function.\n",
        "Let's try a few of them. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "import plotly \n",
        "img = cv2.imread(\"gogh.jpg\")\n",
        "\n",
        "\n",
        "\n",
        "# display the image\n",
        "def show_channels(lab, title, axis=2):\n",
        "    fig = px.imshow(\n",
        "        lab,\n",
        "        facet_col=axis,\n",
        "    )\n",
        "    assert lab.shape[axis] == len(title)\n",
        "    for i in range(lab.shape[axis]):\n",
        "        fig.layout.annotations[i][\"text\"] = title[i]\n",
        "\n",
        "    # set the colormap to gray\n",
        "    fig.layout.coloraxis.colorscale = \"gray\"\n",
        "    plotly.io.show(fig)\n",
        "\n",
        "show_channels(img, [\"B\", \"G\", \"R\"], axis=2) # RGB\n",
        "\n",
        "# convert to YUV color space\n",
        "img_yuv = cv2.cvtColor(img, cv2.COLOR_BGR2YUV)\n",
        "show_channels(img_yuv, [\"Y\", \"U\", \"V\"], axis=2)\n",
        "\n",
        "# convert to hsv color space\n",
        "hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)\n",
        "show_channels(hsv, [\"H\", \"S\", \"V\"])\n",
        "\n",
        "# convert to lab color space\n",
        "lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)\n",
        "show_channels(lab, [\"L\", \"a\", \"b\"])\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "tXV5YxS7lsU2"
      ],
      "name": "02_OpenCV.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3.8.10 64-bit (microsoft store)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.10"
    },
    "varInspector": {
      "cols": {
        "lenName": 16,
        "lenType": 16,
        "lenVar": 40
      },
      "kernels_config": {
        "python": {
          "delete_cmd_postfix": "",
          "delete_cmd_prefix": "del ",
          "library": "var_list.py",
          "varRefreshCmd": "print(var_dic_list())"
        },
        "r": {
          "delete_cmd_postfix": ") ",
          "delete_cmd_prefix": "rm(",
          "library": "var_list.r",
          "varRefreshCmd": "cat(var_dic_list()) "
        }
      },
      "types_to_exclude": [
        "module",
        "function",
        "builtin_function_or_method",
        "instance",
        "_Feature"
      ],
      "window_display": false
    },
    "vscode": {
      "interpreter": {
        "hash": "0bae4c9257a18836fb2e3dc2d0aeb6355625d596c4075009294ab101cd3e0d3c"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}