02_OpenCV.ipynb

{
  "cells": [
    {
      "attachments": {},
      "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/vco/blob/main/02_OpenCV.ipynb) \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",
        "- [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",
        "    - ..."
      ]
    },
    {
      "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"
      ]
    },
    {
      "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\" \"https://placekitten.com/500/300\"\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\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RfdV9IkflsT_"
      },
      "source": [
        "# OpenCV\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!"
      ]
    },
    {
      "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": [
        "If you're running scripted Python (not Jupyter notebook) The `imshow` command will display an image. However, this cause problems in jupyter notebooks (see [this issue](https://github.com/jupyter/notebook/issues/3935)). \n",
        "\n",
        "In Colab, you can can use the following function as replacement: \n",
        "`from google.colab.patches import cv2_imshow`\n",
        "\n",
        "On my machine, however, I can also display images with imshow (code below). It will halt the execution until you close the image window again."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 218
        },
        "id": "ZZdpYNjTlsUZ",
        "outputId": "af175eed-4b6c-46a5-d255-1046c20fa645"
      },
      "outputs": [],
      "source": [
        "# This line only works if you're running locally\n",
        "# cv2.imshow('test', image)\n",
        "\n",
        "if 'google.colab' in str(get_ipython()):\n",
        "  print('Running on CoLab')\n",
        "  from google.colab.patches import cv2_imshow\n",
        "else:\n",
        "  print('Not running on CoLab')\n",
        "  def cv2_imshow(img):\n",
        "      cv2.imshow('image', img)\n",
        "      cv2.waitKey(0)\n",
        "      cv2.destroyAllWindows()\n",
        "\n",
        "\n",
        "cv2_imshow(image)"
      ]
    },
    {
      "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",
        "cv2_imshow(c1)\n",
        "cv2_imshow(c2)\n",
        "cv2_imshow(c3)\n",
        "\n",
        "# or in a row by concatinating them\n",
        "cv2_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",
        "cv2_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",
        "cv2_imshow(test_read_output)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oEVrCiEQlsUz"
      },
      "source": [
        "Everything works as expected!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bb99ZO08TN6f"
      },
      "source": [
        "## Display with Matplotlib\n",
        "\n",
        "Additionally we can plot an image also 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()"
      ]
    },
    {
      "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 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, *args, **kwargs):\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",
        "      image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)\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()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8PH48J1GTwik"
      },
      "source": [
        "## Try it yourself!\n",
        "\n",
        "You should now be able to do Exercise 1 and 2."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NesYl7DNvbPF"
      },
      "source": [
        "# Examples from slides"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rGEIygiMuMDT"
      },
      "source": [
        "## Bayer Filter\n",
        "\n",
        "Image sensors have a Bayer filter on the sensor elements (pixels). So every 2nd pixel in even rows is red, every 2nd pixel in odd rows is blue, and every 2nd pixel in all rows contains green:\n",
        "\n",
        "|     |  0  |  1  |\n",
        "|---  | --- | --- | \n",
        "|**0**| R   | G   | \n",
        "|**1**| G   | B   |\n",
        "\n",
        "Let's create a `raw` image with such a Bayer pattern from our loaded images. We can use masking and slicing."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 745
        },
        "id": "nnNgFK84uD03",
        "outputId": "5e053b8d-83f9-465f-bcaa-b6a0d46b2d6c"
      },
      "outputs": [],
      "source": [
        "# \n",
        "print(image.shape)\n",
        "red_mask = np.zeros(shape=image.shape[0:2],dtype=bool)\n",
        "green_mask, blue_mask = red_mask.copy(), red_mask.copy()\n",
        "red_mask[0::2,0::2] = True\n",
        "blue_mask[1::2,1::2] = True\n",
        "green_mask[0::2,1::2] = True\n",
        "green_mask[1::2,0::2] = True\n",
        "\n",
        "# display red\n",
        "rsize = np.ceil(np.asarray(red_mask.shape)/2.0).astype(int)\n",
        "reds = image[:,:,2][red_mask].reshape(rsize)\n",
        "#cv2_imshow(reds)\n",
        "\n",
        "# display blue\n",
        "bsize = np.floor(np.asarray(blue_mask.shape)/2.0).astype(int)\n",
        "blues = image[:,:,0][blue_mask].reshape(bsize)\n",
        "#cv2_imshow(blues)\n",
        "\n",
        "# construct a Bayer image:\n",
        "bayer = np.zeros(shape=(*image.shape[0:2],3),dtype=image.dtype)\n",
        "# assing colors (BGR)\n",
        "bayer[:,:,0][blue_mask]  = blues.flatten() # B\n",
        "bayer[:,:,2][red_mask]   = reds.flatten() # R\n",
        "bayer[:,:,1][green_mask] = image[:,:,1][green_mask] # Green\n",
        "imshow(bayer[:16,:16]) # show zoomed in\n",
        "cv2_imshow(bayer)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CSNghk0oU58D"
      },
      "source": [
        "The pattern above shows, what most color image sensors record. The process of converting such a Bayer pattern into a color image is called demosaicing. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YazQWWkS2kDN"
      },
      "source": [
        "## Naive image resizing \n",
        "… by simply throwing away rows and columns (see lecture slides).\n",
        "We can use Python's slicing notation do to so."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 479
        },
        "id": "grtMJQ-9u39B",
        "outputId": "e4b6f262-6c6e-41ca-e671-0e7fe35c3739"
      },
      "outputs": [],
      "source": [
        "def downsample( img ):\n",
        "    return img[0::2,0::2]\n",
        "\n",
        "half = downsample(image)    # 1/2 resolution\n",
        "quad = downsample(half)     # 1/4\n",
        "eighth = downsample(quad)   # 1/8\n",
        "imshow(image)\n",
        "#imshow(half)\n",
        "#imshow(quad)\n",
        "imshow(eighth)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Iw2NXYAlV3jY"
      },
      "source": [
        "Dropping pixels is not a good way to downscale images. It leads to severe aliasing problems (see lecture slides). \n",
        "\n",
        "Let's look compare to a downsampled image by OpenCV's built-in `resize` function."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        },
        "id": "dUSseafEct2K",
        "outputId": "84499bf9-4f15-4274-d7af-c4c31d33fb87"
      },
      "outputs": [],
      "source": [
        "smooth = cv2.resize(image, eighth.shape[1::-1], interpolation=cv2.INTER_AREA)\n",
        "imshow(smooth)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B_XIfCsjdt0x"
      },
      "source": [
        "This looks nicer and does not show any aliasing artefacts. We will discuss the details in the upcoming lectures!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tXV5YxS7lsU2"
      },
      "source": [
        "# OpenCV Exercises"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JHyGmaqu9kTd"
      },
      "source": [
        "## Exercise 1\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": {
        "id": "FOFCWJj2T8MQ"
      },
      "source": [
        "## Exercise 2\n",
        "\n",
        "**Gamma Curve:** 8-bit images are stored non-linear (like our perception). \\\n",
        "A common function used for this non-linear linear mapping is the gamma curve: $ y = x^\\gamma $, where $x$ are the linear values in the range \\[0,1\\]. Gamma is $\\gamma=2.2$ on most systems.\n",
        "\n",
        "**(a)** Linearize the image and display it. Note that displaying a linear image might look weird. \\\n",
        "**(b)** Apply different $\\gamma$ (i.e., 0.5, 1.0, and 1.5) and see whats happening."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 497
        },
        "id": "rW4O5fiQ-U_t",
        "outputId": "37ad2779-8815-4de6-f3bb-4095b5be3540"
      },
      "outputs": [],
      "source": [
        "# Solution (a)\n",
        "gamma = 1/2.2\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 497
        },
        "id": "9zX977oItfhg",
        "outputId": "7d0dde19-7e75-48eb-b9f9-383c3ce3e9c3"
      },
      "outputs": [],
      "source": [
        "# Solution (b)\n",
        "# experiment with different gammas\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kDJUDbsLu39C"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "tXV5YxS7lsU2"
      ],
      "name": "02_OpenCV.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "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.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
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}