class_03_1_IP_Manipulation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center> 👉 class_03_1 IP » _Image Manipulation - Enhancement, Sharpenning, Smoothing, Histogram_ </center>\n",
    "\n",
    "### » English (all) and Korean (some) for better understandings from now on\n",
    "\n",
    "## ▶ Image Enhancement Techniques\n",
    "\n",
    "Image enhancement is the process of improving the quality and appearance of an image.   \n",
    "- It can be used to correct flaws or defects in an image, or to simply make an image more visually appealing.   \n",
    "\n",
    "Image enhancement techniques can be applied to a wide range of images, including photographs, scans, and digital images.   \n",
    "- Some common goals of image enhancement include increasing contrast, sharpness, and colorfulness; reducing noise and blur; and correcting distortion and other defects.  \n",
    "\n",
    "Image enhancement techniques can be applied manually using image editing software, or automatically using algorithms and computer programs such as OpenCV.   \n",
    "- we will explore a variety of image enhancement techniques that can be performed using OpenCV and Python.   \n",
    "- OpenCV is a powerful, open-source computer vision library that provides a wide range of image processing and computer vision algorithms.   \n",
    "- By combining the capabilities of OpenCV with the versatility of Python, we can easily implement a variety of image enhancement techniques to improve the quality and appearance of our images. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ▶ Adjusting brightness and contrast  \n",
    "\n",
    "Adjusting the brightness and contrast of an image can significantly affect its visual appeal and effectiveness.   \n",
    "- It can also help to correct defects or flaws in the image and make it easier to see details.   \n",
    "- Finding the right balance of brightness and contrast is important for creating an attractive and effective image.\n",
    "\n",
    "There are several ways to adjust the brightness and contrast of an image using OpenCV and Python.   \n",
    "- One common method is to use the **cv2.addWeighted()** function,   \n",
    ">- which allows you to adjust the brightness by adding a scalar value to each pixel in the image, \n",
    ">- and the contrast by scaling the pixel values.  \n",
    "\n",
    "    - Brightness (명도)는 이미지의 전반적인 명암. \n",
    "    - Contrast (대비)는 이미지의 밝고 어두운 톤의 범위.\n",
    "\n",
    "~ Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from matplotlib.pyplot import figure\n",
    "\n",
    "image = cv2.imread('./images/messi2.jpeg')\n",
    "  \n",
    "brightness = 10  # Adjust the brightness by adding 10 to each pixel value\n",
    "contrast = 2.3  # Adjusts the contrast by scaling the pixel values by 2.3\n",
    "image2 = cv2.addWeighted(image, contrast, np.zeros(image.shape, image.dtype), 0, brightness)\n",
    "\n",
    "# cv2.imwrite('modified_image.jpg', image2) # Save the image\n",
    "\n",
    "figure(figsize=(15, 10), dpi=100)  \n",
    "\n",
    "plt.subplot(1, 2, 1), plt.title(\"Original\"), plt.imshow(image)\n",
    "plt.subplot(1, 2, 2), plt.title(\"Adj Brt+10 & cntrst+2.3\"), plt.imshow(image2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ● Another method for adjusting the brightness and contrast of an image   \n",
    "\n",
    "- is to use the **cv2.convertScaleAbs()** function,   \n",
    ">- which allows you to adjust the brightness and contrast using a combination of scaling and shifting the pixel values.  \n",
    "\n",
    "- The brightness and contrast are adjusted using a combination of scaling and shifting the pixel values.   \n",
    ">- You can adjust the values of alpha and beta to achieve the desired level of brightness and contrast.  \n",
    ">- Adjust the brightness and contrast \n",
    "> $$ g(i,j) = α⋅f(i,j) + β$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "  \n",
    "image = cv2.imread('./images/messi2.jpeg')\n",
    "  \n",
    "# Adjust the brightness and contrast \n",
    "alpha = 1.5  # control Contrast by 1.5\n",
    "beta = 50  # control brightness by 50\n",
    "image2 = cv2.convertScaleAbs(image, alpha=alpha, beta=beta)\n",
    "  \n",
    "# cv2.imwrite('Brightness & contrast.jpg', image2)\n",
    "\n",
    "figure(figsize=(15, 10), dpi=100)  \n",
    "\n",
    "plt.subplot(1, 2, 1), plt.title(\"Original\"), plt.imshow(image)\n",
    "plt.subplot(1, 2, 2), plt.title(\"Adj Brt beta=50 & cntrst alpha=1.5\"), plt.imshow(image2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "def BrtCnst_ctrl(bright=0):\n",
    "    bright = cv2.getTrackbarPos('bright', 'Brt_Contrast_Window')\n",
    "    contrast = cv2.getTrackbarPos('contrast', 'Brt_Contrast_Window')\n",
    "    result = apply_brightness_contrast(img,bright,contrast)\n",
    "    cv2.namedWindow('Ajusted_Result', cv2.WINDOW_NORMAL)\n",
    "#     cv2.resizeWindow(\"Ajusted_Result\", 400, 500)\n",
    "    cv2.imshow('Ajusted_Result', result)\n",
    "    \n",
    "def apply_brightness_contrast(input_img, brightness = 255, contrast = 127):\n",
    "    brightness = map(brightness, 0, 510, -255, 255)\n",
    "    contrast = map(contrast, 0, 254, -127, 127)\n",
    "    if brightness != 0:\n",
    "        if brightness > 0:\n",
    "            shadow = brightness\n",
    "            highlight = 255\n",
    "        else:\n",
    "            shadow = 0\n",
    "            highlight = 255 + brightness\n",
    "        alpha_b = (highlight - shadow)/255\n",
    "        gamma_b = shadow\n",
    "        buf = cv2.addWeighted(input_img, alpha_b, input_img, 0, gamma_b)\n",
    "    else:\n",
    "        buf = input_img.copy()\n",
    "    if contrast != 0:\n",
    "        f = float(131 * (contrast + 127)) / (127 * (131 - contrast))\n",
    "        alpha_c = f\n",
    "        gamma_c = 127*(1-f)\n",
    "        buf = cv2.addWeighted(buf, alpha_c, buf, 0, gamma_c)\n",
    "    cv2.putText(buf,'B:{},C:{}'.format(brightness,contrast),(10, 150), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)\n",
    "    return buf\n",
    "\n",
    "def map(x, in_min, in_max, out_min, out_max):\n",
    "    return int((x-in_min) * (out_max-out_min) / (in_max-in_min) + out_min)\n",
    "\n",
    "original = cv2.imread('./images/messi2.jpeg', 1)\n",
    "img = original.copy()\n",
    "cv2.namedWindow('Brt_Contrast_Window', cv2.WINDOW_NORMAL)\n",
    "bright = 255\n",
    "contrast = 127\n",
    "cv2.createTrackbar('bright', 'Brt_Contrast_Window', bright, 2*255, BrtCnst_ctrl) # Brightness value range -255 to 255\n",
    "cv2.createTrackbar('contrast', 'Brt_Contrast_Window', contrast, 2*127, BrtCnst_ctrl) # Contrast value range -127 to 127\n",
    "BrtCnst_ctrl(0)\n",
    "cv2.imshow('Brt_Contrast_Window', original)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ▶ Sharpening Image\n",
    "\n",
    "Sharpening is the process of enhancing the edges and fine details in an image to make it appear sharper and more defined.  \n",
    "One common method for sharpening images using OpenCV and Python is to use the cv2.filter2D() function, which convolves the image with a kernel.   \n",
    "The kernel can be designed to enhance the edges in the image, resulting in a sharper image.\n",
    "- kernels are used for the process of blurring images, sharpening images, embossing, edge detection, and much more.   \n",
    "- A kernel is known by other names such as:\n",
    ">- Convolution Matrix, Mask or Matrix/Array.\n",
    "\n",
    "- it is the kernel that brings about a change in pixel formation and intensity when multiplied with the pixels in the original image.  \n",
    "- multiplying by a particular kernel (array of values) will bring about a specific change in the image presentation.  \n",
    "- A few of the commonly used kernels are as follows:\n",
    "### cv2 Kernels\n",
    "<img src = './images/kernel.png' align='left' width=400 height=600>  <img src = './images/kernel2.png' width=400 height=600>  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "img_cat = plt.imread('./images/cats/cat.jpg')\n",
    "img_dog = plt.imread('./images/dogs/01.jpg')\n",
    "print(img_dog.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "krnl_sp1 = np.array([[-1,-1,-1],\n",
    "                   [-1,5,-1],\n",
    "                   [-1,-1,-1]])\n",
    "krnl_sp2 = np.array([[-1,-1,-1],\n",
    "                   [-1,9,-1],\n",
    "                   [-1,-1,-1]])\n",
    "\n",
    "# filter 2D\n",
    "img_dog_sp = cv2.filter2D(img_dog, -1, krnl_sp2 ) # -1 for depth\n",
    "img_cat_sp = cv2.filter2D(img_cat, -1, krnl_sp2 ) # -1 for depth\n",
    "\n",
    "fig, axs = plt.subplots(1,4,figsize=(15,15))\n",
    "axs[0].imshow(img_dog), axs[0].axis('off'), axs[0].set_title('img_dog')\n",
    "axs[1].imshow(img_dog_sp), axs[1].axis('off'), axs[1].set_title('img_dog sharpened img')\n",
    "axs[2].imshow(img_cat), axs[2].axis('off'), axs[2].set_title('img_cat')\n",
    "axs[3].imshow(img_cat_sp), axs[3].axis('off'), axs[3].set_title('img_cat sharpened img')\n",
    "plt.show()  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ● Another method for sharpening images  ;\n",
    "\n",
    "- is to use the **cv2.Laplacian()** function,   \n",
    ">- which calculates the Laplacian of an image and returns the result as a sharpened image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sharpened_image2_dog = cv2.Laplacian(img_dog, cv2.CV_64F) # You can adjust the depth of the output image using the cv2.CV_64F parameter.\n",
    "sharpened_image2_cat = cv2.Laplacian(img_cat, cv2.CV_64F)\n",
    "\n",
    "fig, axs = plt.subplots(1,4,figsize=(15,15))\n",
    "axs[0].imshow(img_dog), axs[0].axis('off'), axs[0].set_title('img_dog')\n",
    "axs[1].imshow(sharpened_image2_dog), axs[1].axis('off'), axs[1].set_title(' Laplacian sharpened img')\n",
    "axs[2].imshow(img_cat), axs[2].axis('off'), axs[2].set_title('img_cat')\n",
    "axs[3].imshow(sharpened_image2_cat), axs[3].axis('off'), axs[3].set_title('Laplacian sharpened img')\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ▶ Blurring Img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "krnl_blr = np.ones((3,3), np.float32) / 9\n",
    "img_dog_blr = cv2.filter2D(img_dog, -1, krnl_blr )\n",
    "img_cat_blr = cv2.filter2D(img_cat, -1, krnl_blr )\n",
    "\n",
    "fig, axs = plt.subplots(1,4,figsize=(15,15))\n",
    "axs[0].imshow(img_dog), axs[0].axis('off'), axs[0].set_title('img_dog')\n",
    "axs[1].imshow(img_dog_blr), axs[1].axis('off'), axs[1].set_title('img_dog_blr img')\n",
    "axs[2].imshow(img_cat), axs[2].axis('off'), axs[2].set_title('img_cat')\n",
    "axs[3].imshow(img_cat_blr), axs[3].axis('off'), axs[3].set_title('img_cat_blr img')\n",
    "plt.show()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kernel_3x3 = np.ones((3, 3), np.float32) / 9\n",
    "kernel_7x7 = np.ones((7, 7), np.float32) / 49\n",
    "img_dog_blr = cv2.filter2D(img_dog, -1, kernel_3x3 )\n",
    "img_cat_blr = cv2.filter2D(img_cat, -1, kernel_3x3 )\n",
    "img_dog_blr2 = cv2.filter2D(img_dog, -1, kernel_7x7 )\n",
    "img_cat_blr2 = cv2.filter2D(img_cat, -1, kernel_7x7 )\n",
    "\n",
    "\n",
    "import matplotlib.pylab as plt\n",
    "from matplotlib.pyplot import figure\n",
    "figure(figsize=(15, 10), dpi=100)\n",
    "\n",
    "titles = ['org_dog', 'kernel_3x3', 'kernel_7x7', 'org_cat','kernel_3x3','kernel_7x7']\n",
    "images = [img_dog, img_dog_blr, img_dog_blr2, img_cat, img_cat_blr, img_cat_blr2 ]\n",
    "\n",
    "for i in range(6):\n",
    "    plt.subplot(2, 3, i+1), plt.imshow(images[i])\n",
    "    plt.title(titles[i]), plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ▶ Removing noise from images  \n",
    "\n",
    "Noise reduction is the process of removing or reducing unwanted noise or artifacts from an image. \n",
    "There are several techniques for reducing noise, including using filters such as the median filter or the Gaussian filter.   \n",
    "It is important to apply noise reduction judiciously to avoid blur or loss of detail in the image.\n",
    "\n",
    "One common method for removing noise from images using the **cv2.medianBlur()** function is to use a median filter.   \n",
    "- The median filter works by replacing each pixel in the image with the median value of a set of neighboring pixels.   \n",
    "- This can help to smooth out noise and reduce artifacts in the image.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "img_cat = plt.imread('./images/cats/cat.jpg')\n",
    "img_dog = plt.imread('./images/dogs/01.jpg')\n",
    "# print(img_dog.shape)\n",
    "filtered_image_cat = cv2.medianBlur(img_cat, 5) # You can adjust the kernel size, odd no.\n",
    "filtered_image_dog = cv2.medianBlur(img_dog, 7)\n",
    "\n",
    "fig, axs = plt.subplots(1,4,figsize=(15,15))\n",
    "axs[0].imshow(img_dog), axs[0].axis('off'), axs[0].set_title('img_dog')\n",
    "axs[1].imshow(filtered_image_dog), axs[1].axis('off'), axs[1].set_title('medianBlur img')\n",
    "axs[2].imshow(img_cat), axs[2].axis('off'), axs[2].set_title('img_cat')\n",
    "axs[3].imshow(filtered_image_cat), axs[3].axis('off'), axs[3].set_title('medianBlur img')\n",
    "plt.show()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ● Another method for removing noise from images :\n",
    "\n",
    "- is to use a Gaussian filter,   \n",
    "- which uses a weighted average of neighboring pixels to smooth out noise and reduce artifacts.   \n",
    "- You can use the **cv2.GaussianBlur()** function to apply a Gaussian filter to an image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "img_cat = plt.imread('./images/cats/cat.jpg')\n",
    "img_dog = plt.imread('./images/dogs/01.jpg')\n",
    "# print(img_dog.shape)\n",
    "filtered_image2_dog = cv2.GaussianBlur(img_dog, (7, 7), 0) # You can adjust the kernel size, odd no.\n",
    "filtered_image2_cat = cv2.GaussianBlur(img_cat, (7, 7), 0)\n",
    "\n",
    "fig, axs = plt.subplots(1,4,figsize=(15,15))\n",
    "axs[0].imshow(img_dog), axs[0].axis('off'), axs[0].set_title('img_dog')\n",
    "axs[1].imshow(filtered_image2_dog), axs[1].axis('off'), axs[1].set_title('GaussianBlur img')\n",
    "axs[2].imshow(img_cat), axs[2].axis('off'), axs[2].set_title('img_cat')\n",
    "axs[3].imshow(filtered_image2_cat), axs[3].axis('off'), axs[3].set_title('GaussianBlur img')\n",
    "plt.show()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ▶ Histogram  \n",
    "\n",
    "A histogram is a graph of a frequency distribution table.\n",
    "- Gives you overall idea about the intensity distribution of an image.  \n",
    "\n",
    "To put it simply, it is a graph of how many things there are.\n",
    "Displaying the pixel values of an image as a histogram helps you analyze the image.\n",
    "- For example, count how many pixels with a pixel value of 1,   \n",
    "- how many pixels with 2 pixels,   \n",
    "- and how many pixels with 255 pixels in the entire image, etc.\n",
    "\n",
    "By doing this, you can determine the distribution of the pixels in color and contrast.  \n",
    "\n",
    "~ Syntax:  \n",
    "    \n",
    "* **plt.hist(img.ravel(),maxNo,[range])**  \n",
    "\n",
    "~ Pameters: \n",
    "    \n",
    "- img.ravel() : src img and histo function\n",
    "- maxNo : max number of pixel - 256  \n",
    "- range : pixel range - 0 ~ 256        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import cv2\n",
    "from matplotlib.pyplot import figure\n",
    "\n",
    "figure(figsize=(5, 5), dpi=80)\n",
    "\n",
    "# img = cv2.imread('./images/blank.jpg') # \n",
    "img = np.zeros((200,200), np.uint8) # black img\n",
    "\n",
    "plt.imshow(img, cmap='gray') \n",
    "plt.show()\n",
    "\n",
    "cv2.imshow('img', img)\n",
    "cv2.waitKey()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(img.ravel(),256,[0,256])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add white img on the black img\n",
    "cv2.rectangle(img, (0, 100), (200,200), 255, -1) # below half change to white (fm 0 width, 100 h)\n",
    "\n",
    "plt.hist(img.ravel(),256,[0,256])\n",
    "plt.show()\n",
    "\n",
    "cv2.imshow('img', img)\n",
    "cv2.waitKey()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv2.rectangle(img, (0, 100), (200,200), 255, -1) # below half change to white (fm 0 width, 100 h)\n",
    "cv2.rectangle(img, (0, 50), (100,100), 127, -1)\n",
    "\n",
    "plt.hist(img.ravel(),256,[0,256])\n",
    "plt.show()\n",
    "\n",
    "cv2.imshow('img', img)\n",
    "cv2.waitKey()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = cv2.imread('./images/lena.jpg',0)\n",
    "\n",
    "plt.hist(img.ravel(),256,[0,256])\n",
    "plt.show()\n",
    "\n",
    "cv2.imshow('img', img)\n",
    "cv2.waitKey()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ● Get BGR values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = cv2.imread('./images/lena.jpg')\n",
    "\n",
    "b,g,r = cv2.split(img)\n",
    "\n",
    "# plt.hist(img.ravel(),256,[0,256])\n",
    "plt.hist(b.ravel(),256,[0,256])\n",
    "plt.hist(g.ravel(),256,[0,256])\n",
    "plt.hist(r.ravel(),256,[0,256])\n",
    "plt.show()\n",
    "\n",
    "cv2.imshow('img', img)\n",
    "cv2.imshow('b', b)\n",
    "cv2.imshow('g', g)\n",
    "cv2.imshow('r', r)\n",
    "cv2.waitKey()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ● Opencv-python cv2 method  \n",
    "\n",
    "~ Syntax:\n",
    "    \n",
    "- **cv2.calHist([img], [channel], mask, [histSize], [ranges])**  \n",
    "\n",
    "~ Parameters:\n",
    "    \n",
    "- [img]: [img]\n",
    "- [channel]: list type - one chnl: [0], two chnls: [0, 1], three chnls: [0, 1, 2]\n",
    "- mask: Histogram counts only the pixels specified in the mask, None : all\n",
    "- histSize: No of Bin, one chnl: [256], two chnls: [256, 256], three chnls: [256, 256, 256]\n",
    "- ranges: RGB - [0, 256]\n",
    "\n",
    "~ Example: Plotting Histograms using Matplotlib plotting functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = cv2.imread('./images/lena.jpg')\n",
    "\n",
    "hist = cv2.calcHist([img], [0], None, [256], [0,256])\n",
    "\n",
    "plt.plot(hist),plt.title('Hist_cv2')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "img = cv2.imread('./images/lena.jpg')\n",
    "\n",
    "color = ('b','g','r')\n",
    "for i,col in enumerate(color):\n",
    "    hist = cv2.calcHist([img],[i],None,[256],[0,256])\n",
    "    plt.plot(hist,color = col)\n",
    "    plt.xlim([0,256])\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "CV-py36",
   "language": "python",
   "name": "cv_py36"
  },
  "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.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}