phys5020_intro_to_itk_student.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/erin5116/phys5020_intr_to_itk/blob/main/phys5020_intro_to_itk.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tJUJ0jX32J5I"
   },
   "source": [
    "<h1 align=\"center\">Introduction to (simple) ITK</h1>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zYfZMv1V3il9"
   },
   "source": [
    "## Setup: Importing the required libraries ##\n",
    "\n",
    "First step in a Python script is to import the libraries with the functions that you want to use.\n",
    "\n",
    "In this tutorial we will use the following libraries:\n",
    "\n",
    "\n",
    "1.   SimpleITK: image registration and segmentation library\n",
    "2.   Numpy: library with mathematical functions\n",
    "3. Matplotlib: library for creating visualisations in Python, we will use the Pyplot function in this tutorial to show the images\n",
    "\n",
    "Run the cell below to import the first two libraries and the plotting function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dJ093kHv3Ndc"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import SimpleITK"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BlF40Gd349qh"
   },
   "source": [
    "Here you should encounter an error message.\n",
    "\n",
    "This is because numpy and matplotlib libraries are pre-installed in Google Collab (and probably most Python installations) but SimpleITK is not.\n",
    "\n",
    "As Google Collab does not have SimpleITK pre-installed, we need to do it ourselves as the first step in this tutorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YWZoopRW2QOt"
   },
   "outputs": [],
   "source": [
    "pip install SimpleITK"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HoLhVmdI5ZTl"
   },
   "source": [
    "Now, you should be able to import SimpleITK.\n",
    "\n",
    "Click into the next cell to type the code to import the library and giving it a short variable (sitk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zcU4uTPh5oVm"
   },
   "outputs": [],
   "source": [
    "# insert code to import the library and giving it a short variable (sitk)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GauzuXQj5rVh"
   },
   "source": [
    "## Working with single images ##\n",
    "\n",
    "Here you will read in the simpleITK logo using the sitk function.\n",
    "It is located in the '/data' folder in your current working directory.\n",
    "\n",
    "Note: in Google Collab, the current working directory is '/content', and the following cell will download the data required for this lab into '/content/phys5020_intro_to_itk/data'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# clone github repository containing the data, comment out if you downloaded the data and have it in your path\n",
    "# !git clone https://github.com/erin5116/phys5020_intro_to_itk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = '/content/phys5020_intro_to_itk/data'\n",
    "# insert code to read the image 'SimpleITK.jpg'\n",
    "\n",
    "\n",
    "# this code plots/visualises the image\n",
    "plt.imshow(sitk.GetArrayViewFromImage(logo)) # gets the numpy array from the image to plot it (visualisation)\n",
    "plt.axis('off');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Retrieve image spatial information ##\n",
    "\n",
    "Fill in the blanks below to retrieve some basic image spatial information.\n",
    "\n",
    "Hint: use {image}.Get{parameter}() to obtain the Origin, Size, Direction, and PixelIDTypeAsString"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to find out where the origin of the image is\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to find out what the size of the image is\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to find out where the image resoluation (pixel spacing) of the image is\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to find out what the direction of the image is\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to find out what is the image pixel type\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Play around with the image! ##\n",
    "\n",
    "Use the cell below to play around with the image using basic array operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "logo_temp = logo[:,:]\n",
    "# insert code here to replace the bottom half of the image \n",
    "# (hint: rows and columns start counting from the top left corner) with 0s\n",
    "\n",
    "\n",
    "plt.imshow(sitk.GetArrayViewFromImage(logo_temp)) # gets the numpy array from the image to plot it (visualisation)\n",
    "plt.axis('off');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "logo_temp = logo[:,:]\n",
    "# insert code here to flip the whole image\n",
    "\n",
    "plt.imshow(sitk.GetArrayViewFromImage(logo_temp)) # gets the numpy array from the image to plot it (visualisation)\n",
    "plt.axis('off');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "logo_temp = logo[:,:]\n",
    "# insert code here to \"brute\" downsample the image by factor of 3\n",
    "\n",
    "plt.imshow(sitk.GetArrayViewFromImage(logo_temp)) # gets the numpy array from the image to plot it (visualisation)\n",
    "plt.axis('off');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with a series of 2D images ##\n",
    "\n",
    "Playing with a single image is fun, but in the clinical setting you usually deal with image volumes that are saved as a series of 2D images, often in DICOM format.\n",
    "\n",
    "Here you will learn how to read a series of DICOM images from a clean folder (only contains one sequnece per folder).\n",
    "\n",
    "Use the cell below to read in the dicom series from /data/dicom_abdominal_phantom using the ImageSeriesReader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = '/content/phys5020_intro_to_itk/data/dicom_abdominal_phantom'\n",
    "\n",
    "# insert code here to read in series of 2D images\n",
    "# hint: assign the reader to a variable\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Retrieve image spatial information ##\n",
    "\n",
    "As you did in the section above, retrieve the spatial information of the image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to find out where the origin of the image is\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to find out what the size of the image is\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to find out where the image resoluation (pixel spacing) of the image is\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to find out what the direction of the image is\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to find out what is the image pixel type\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How does the information compare with the simpleITK logo?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualise the image volume ##\n",
    "\n",
    "As we are working on the cloud with Google Collab today, we won't be able to easily use other softwares to visualise the data. \n",
    "\n",
    "Instead, we can use the old fasioned way as in the section above - use pyplotlib to visualise slice by slice.\n",
    "\n",
    "Use the code in the above section to guide you on how to visualise just one slice in the image volume, starting with the center slice (middle slice in the z axis).\n",
    "\n",
    "\n",
    "Hint: use your knowledge on array operation to pull just one slice of the image. Do it before you use imshow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to pull a slice from the image volume and display it\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use this code to explore and visualse the different slices in this image volume. \n",
    "The phantom object in this image starts around slice 115 and ends around 250."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Segmentation using thresholding ##\n",
    "\n",
    "\n",
    "Let's try out doing a simple segmentation of the image to obtain a mask of the entire phantom.\n",
    "A mask typically is a binary image, with the voxels in the object/region of interest having a value of 1 and the background of 0.\n",
    "\n",
    "Hint: the background noise is around 30 a.u., so use that as your threshold."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code here for thresholding of the image \n",
    "\n",
    "\n",
    "# insert code here to pull a slice from the thresholded image volume and display it\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, try the threshold segmentation with a lower threshold than u used above, e.g. 5 a.u. and visualise slice 176 again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code here for thresholding of the image\n",
    "\n",
    "\n",
    "# insert code here to pull a slice from the thresholded image volume and display it\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What differences do you see?\n",
    "This is an example of the importance of the threshold value when using it in object segmentation.\n",
    "Manual selection of the thresold (and maybe a bit of trial and error) works, but different images can have different background values, so you don't want to be doing this manually all the time!\n",
    "\n",
    "Next, we will try an auto-thresholding algorithm (Otsu Threshold Algorithm original paper [here](https://ieeexplore.ieee.org/document/4310076)).\n",
    "\n",
    "Run the cell below to see the Otsu threshold filter at work!\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "otsu_filter = sitk.OtsuThresholdImageFilter()\n",
    "otsu_filter.SetInsideValue(0)\n",
    "otsu_filter.SetOutsideValue(1)\n",
    "image_thresholded_otsu = otsu_filter.Execute(image)\n",
    "\n",
    "print(otsu_filter.GetThreshold())\n",
    "\n",
    "image_slice = image_thresholded_otsu[:,:,176]\n",
    "plt.imshow(sitk.GetArrayViewFromImage(image_slice)) \n",
    "plt.axis('off');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How does the result compare with the manually selected threshold value?\n",
    "\n",
    "Note: look at how the image filter is used. It may be useful in later exercises :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with label maps ##\n",
    "\n",
    "Thresholding of the image with the filter results in a binary image.\n",
    "\n",
    "Use the LabelShapeStatisticsImageFilter to extract:\n",
    "\n",
    "1) The number of label objects\n",
    "\n",
    "2) Size of each label object (hint: use GetPhysicalSize)\n",
    "\n",
    "3) Bounding box of the largest object\n",
    "\n",
    "Hint: use {function}.Get{parameter}() to extract the Labels, PhysicalSize, and BoundingBox. For the latter two, you need to specify which label you want to obtain the information for."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code here to use the LabelShapeStatisticsImageFilter on the image thresholded using the otsu algorithm\n",
    "\n",
    "\n",
    "# insert code here to print the parameters\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Question: Do you know what units the size of the label region is in?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading DICOM from a folder with mixed data ##\n",
    "\n",
    "Now that you've experienced reading a series of 2D DICOM images from one folder, let's move onto something more challenging.\n",
    "\n",
    "Sometimes the clinical scanners export all image data into one single folder, which can be difficult to sort.\n",
    "\n",
    "Lucky for us, the image series reader in SITK can be used to obtain all the series ID, which is unique to each series, so we can get a quick feel for how many series are in the folder.\n",
    "\n",
    "Run the following cell and fill in the blanks to assess the series ID of the DICOM files in the folder '\\dicoms'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = '/content/phys5020_intro_to_itk/data/dicoms'\n",
    "\n",
    "# insert code here to assign the ImageSeriesReader to a variable and obtain the dicom series ID \n",
    "# hint: GDCMSeriesIDs\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The series ID doesn't provide a whole lot of information about the image, but is useful if you know the ID of the series that you want to read, or can be used to sort the folder (by moving all the 2D DICOMs into different folders, one for each series).\n",
    "\n",
    "For now, let's practice reading a series by specifying its' seriesID"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code here to read the first series in the folder as a 3D image volume\n",
    "files = reader.GetGDCMSeriesFileNames(path,series_IDs[0])\n",
    "reader.SetFileNames(files)\n",
    "image = reader.Execute()\n",
    "\n",
    "image.GetSize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, show the middle slice of the image to have a look at what it is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# insert code here to find out the middle slice of the image, extract it, and plot\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extracting DICOM headers ##\n",
    "\n",
    "Now we are familiar with reading in single and series of images, let's have a look at how we can extract the DICOM headers from the image, which can be useful for our work, e.g. MRI acquisition parameters for mathematical modelling."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Single 2D image ###\n",
    "\n",
    "Let's use the second series in the folder to have a look at how we can quickly extract the DICOM header from a single DICOM file.\n",
    "\n",
    "First, read the first image from the second series."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code here to read the first series in the folder\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, extract the Protocol Name ('00108|1030') from the DICOM header.\n",
    "\n",
    "Hint: use {image}.Get{parameter}({dicom_tag}) to get the MetaData."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to get meta data from the image\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's practice our skills in looping things in Python.\n",
    "\n",
    "Loop through the list of series IDs (from the previous exercise), load the first image, and print the Protocol Name for that series."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code here to loop through series and print protocol name\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is something that might come in handy in a clinical setting, especially if you have many series of images all saved into one folder."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Series of 2D images ###\n",
    "\n",
    "Extracting the DICOM header for a series of 2D images is slightly different.\n",
    "\n",
    "By default, the ImageSeriesReader does not read in the DICOM tags to save time when reading a large number of 2D images.\n",
    "\n",
    "You can turn this on by setting the MetaDataDictionaryArrayUpdateOn in the reader."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to turn the dicom header reading on and execute the reader function\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, extract the protocol name from the reader function, from the first slice.\n",
    "\n",
    "Hint: use {function}.Get{parameter}({slice_number},{dicom_tag}) to get the MetaData."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to get meta data from the reader for the first slice\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Applying denoising filters in SITK ##\n",
    "\n",
    "The first slice in the ACR phantom is useful to evaluate image resolution, and also the effect of denoising filters on the image quality.\n",
    "\n",
    "Try apply the DiscreteGuassianImageFilter and view the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to apply the DiscreteGaussianImageFilter to the image\n",
    "\n",
    "\n",
    "# insert code here to plot and visualise the first slice in the filtered image\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Show the original image and compare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code here to plot and visualise the first slice in the unfiltered image\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try the median image filter and see how that helps with the noise outside the phantom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to apply the MedianImageFilter to the image\n",
    "\n",
    "\n",
    "# insert code here to plot and visualise the first slice in the filtered image\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Converting between Numpy and SITK ##\n",
    "\n",
    "While the SITK image object is great to work with, it is limited to the tools and functions within the libary (for now?!).\n",
    "\n",
    "On the other hand, numpy arrays are well integrated into a number of other useful libraries, or can be used on its own.\n",
    "\n",
    "Let's convert the image volume of the phantom object into numpy and play around with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code here to convert sitk image to numpy array\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try to plot the same slice (first slice) as you did in the above exercise.\n",
    "\n",
    "Hint: Beware of the order of axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to plot the 1st slice\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's go to the sixth slice in the image volume, which we will use for the next exercise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code to plot the 6th slice\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple SNR measurment with Numpy array ##\n",
    "\n",
    "\n",
    "In the previous exercise you should see a uniform part of the phantom, where we can estimate the SNR inside.\n",
    "\n",
    "Use your knowledge with numpy arrays to select a square of 10 x 10 voxels around the centre of the image on slice 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code here to select 10 x 10 voxels around the centre of slice 6\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then estimate the SNR (mean / std) from the center cube "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code here to calculate and print the SNR value\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Thresholding with numpy, and convert back to SITK ##\n",
    "\n",
    "For the last exercise of today, let's threshold the phantom image in Numpy and convert it back into an SITK image. \n",
    "\n",
    "Use your knowledge on the signal intensity in the phantom (hint, the maximum value in the centre of slice 6 is a good estimate of the upper threshold, play around with the image to select a reasonable lower threshold) to manually threshold the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code here to find the range of values in the centre of slice 6\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code here to thershold the image\n",
    "\n",
    "\n",
    "# insert code here to plot the thresholded image and examine whether the threshold values are reasonable\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the thresholded image back to a SITK image, and remember to copy the image spatial information so it matches with the original image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# insert code here to convert the numpy array back into sitk image\n",
    "\n",
    "\n",
    "print(image_label)\n",
    "\n",
    "# insert code here to copy the spatial information from the original image\n",
    "\n",
    "\n",
    "print(image_label)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the end of the tutorial :)\n",
    "\n",
    "Hope you enjoyed it and learned something useful!"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "authorship_tag": "ABX9TyOMe9sGe1+4usIp5UGyVQqr",
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "Untitled0.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}