Alignment-10Band.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Active Image Alignment - 10-band\n",
    "\n",
    "Note: This notebook specifically demonstrates alignment and stack creation for 10-band data.  For alignment of 5-band (RedEdge) and 6-band (Altum) data, pr more details about alignment in general, see the \"Active Image Alignment\" notebook.\n",
    "\n",
    "\n",
    "## Opening Images\n",
    "\n",
    "As we have done in previous examples, we use the micasense.capture class to open, radiometrically correct, and visualize the 10 bands of a RedEdge-MX Dual (Red+Blue) capture.\n",
    "\n",
    "First, we'll load the `autoreload` extension.  This lets us change underlying code (such as library functions) without having to reload the entire workbook and kernel. This is useful in this workbook because the cell that runs the alignment can take a long time to run, so with `autoreload` extension we can update the code after the alignment step for analysis and visualization without needing to re-compute the alignments each time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, glob\n",
    "import micasense.capture as capture\n",
    "%matplotlib inline\n",
    "\n",
    "panelNames = None\n",
    "paneCap = None\n",
    "\n",
    "imagePath = os.path.join('.','data','10BANDSET','000')\n",
    "imageNames = glob.glob(os.path.join(imagePath,'IMG_0431_*.tif'))\n",
    "panelNames = glob.glob(os.path.join(imagePath,'IMG_0000_*.tif'))\n",
    "\n",
    "# Allow this code to align both radiance and reflectance images; bu excluding\n",
    "# a definition for panelNames above, radiance images will be used\n",
    "# For panel images, efforts will be made to automatically extract the panel information\n",
    "# but if the panel/firmware is before Altum 1.3.5, RedEdge 5.1.7 the panel reflectance\n",
    "# will need to be set in the panel_reflectance_by_band variable.\n",
    "# Note: radiance images will not be used to properly create NDVI/NDRE images below.\n",
    "if panelNames is not None:\n",
    "    panelCap = capture.Capture.from_filelist(panelNames)\n",
    "else:\n",
    "    panelCap = None\n",
    "\n",
    "capture = capture.Capture.from_filelist(imageNames)\n",
    "\n",
    "if panelCap is not None:\n",
    "    if panelCap.panel_albedo() is not None:\n",
    "        panel_reflectance_by_band = panelCap.panel_albedo()\n",
    "    else:\n",
    "        raise IOError(\"Comment this lne and set panel_reflectance_by_band here\")\n",
    "        panel_reflectance_by_band = [0.65]*len(imageNames)\n",
    "    panel_irradiance = panelCap.panel_irradiance(panel_reflectance_by_band)    \n",
    "    img_type = \"reflectance\"\n",
    "    capture.plot_undistorted_reflectance(panel_irradiance)\n",
    "else:\n",
    "    if capture.dls_present():\n",
    "        img_type='reflectance'\n",
    "        capture.plot_undistorted_reflectance(capture.dls_irradiance())\n",
    "    else:\n",
    "        img_type = \"radiance\"\n",
    "        capture.plot_undistorted_radiance()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unwarp and Align\n",
    "\n",
    "Alignment is a three step process:\n",
    "\n",
    "1. Images are unwarped using the built-in lens calibration\n",
    "1. A transformation is found to align each band to a common band\n",
    "1. The aligned images are combined and cropped, removing pixels which don't overlap in all bands.\n",
    "\n",
    "We provide utilities to find the alignement transformations within a single capture.  Our experience shows that once a good alignmnet transformation is found, it tends to be stable over a flight and, in most cases, over many flights.  The transformation may change if the camera undergoes a shock event (such as a hard landing or drop) or if the temperature changes substantially between flights.  In these events a new transformation may need to be found.\n",
    "\n",
    "Further, since this approach finds a 2-dimensional (affine) transformation between images, it won't work when the parallax between bands results in a 3-dimensional depth field.  This can happen if very close to the target or when targets are visible at significantly different ranges, such as a nearby tree or building against a background much farther way. In these cases it will be necessary to use photogrammetry techniques to find a 3-dimensional mapping between images.\n",
    "\n",
    "For best alignment results it's good to select a capture which has features which visible in all bands.  Man-made objects such as cars, roads, and buildings tend to work very well, while captures of only repeating crop rows tend to work poorly.  Remember, once a good transformation has been found for flight, it can be generally be applied across all of the images.\n",
    "\n",
    "It's also good to use an image for alignment which is taken near the same level above ground as the rest of the flights. Above approximately 35m AGL, the alignement will be consistent. However, if images taken closer to the ground are used, such as panel images, the same alignment transformation will not work for the flight data.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import micasense.imageutils as imageutils\n",
    "import micasense.plotutils as plotutils\n",
    "\n",
    "## Alignment settings\n",
    "match_index = 4 # Index of the band, here we use green\n",
    "max_alignment_iterations = 20\n",
    "warp_mode = cv2.MOTION_HOMOGRAPHY # MOTION_HOMOGRAPHY or MOTION_AFFINE. For Altum images only use HOMOGRAPHY\n",
    "pyramid_levels = 3 # for 10-band imagery we use a 3-level pyramid. In some cases\n",
    "\n",
    "print(\"Alinging images. Depending on settings this can take from a few seconds to many minutes\")\n",
    "# Can potentially increase max_iterations for better results, but longer runtimes\n",
    "warp_matrices, alignment_pairs = imageutils.align_capture(capture,\n",
    "                                                          ref_index = match_index,\n",
    "                                                          max_iterations = max_alignment_iterations,\n",
    "                                                          warp_mode = warp_mode,\n",
    "                                                          pyramid_levels = pyramid_levels)\n",
    "\n",
    "print(\"Finished Aligning, warp matrices={}\".format(warp_matrices))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Crop Aligned Images\n",
    "After finding image alignments we may need to remove pixels around the edges which aren't present in every image in the capture.  To do this we use the affine transforms found above and the image distortions from the image metadata.  OpenCV provides a couple of handy helpers for this task in the  `cv2.undistortPoints()` and `cv2.transform()` methods.  These methods takes a set of pixel coordinates and apply our undistortion matrix and our affine transform, respectively.  So, just as we did when registering the images, we first apply the undistortion process the coordinates of the image borders, then we apply the affine transformation to that result. The resulting pixel coordinates tell us where the image borders end up after this pair of transformations, and we can then crop the resultant image to these coordinates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cropped_dimensions, edges = imageutils.find_crop_bounds(capture, warp_matrices, warp_mode=warp_mode)\n",
    "im_aligned = imageutils.aligned_capture(capture, warp_matrices, warp_mode, cropped_dimensions, match_index, img_type=img_type)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize Aligned Images\n",
    "\n",
    "Once the transformation has been found, it can be verified by composting the aligned images to check alignment. The image 'stack' containing all bands can also be exported to a multi-band TIFF file for viewing in extrernal software such as QGIS.  Usef ul componsites are a naturally colored RGB as well as color infrared, or CIR. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# figsize=(30,23) # use this size for full-image-resolution display\n",
    "figsize=(16,13)   # use this size for export-sized display\n",
    "\n",
    "rgb_band_indices = [capture.band_names().index('Red'),capture.band_names().index('Green'),capture.band_names().index('Blue-444')]\n",
    "cir_band_indices = [capture.band_names().index('NIR'),capture.band_names().index('Red'),capture.band_names().index('Green')]\n",
    "\n",
    "# Create a normalized stack for viewing\n",
    "im_display = np.zeros((im_aligned.shape[0],im_aligned.shape[1],im_aligned.shape[2]), dtype=np.float32 )\n",
    "\n",
    "im_min = np.percentile(im_aligned[:,:,rgb_band_indices].flatten(), 0.5)  # modify these percentiles to adjust contrast\n",
    "im_max = np.percentile(im_aligned[:,:,rgb_band_indices].flatten(), 99.5)  # for many images, 0.5 and 99.5 are good values\n",
    "\n",
    "# for rgb true color, we use the same min and max scaling across the 3 bands to \n",
    "# maintain the \"white balance\" of the calibrated image\n",
    "for i in rgb_band_indices:\n",
    "    im_display[:,:,i] =  imageutils.normalize(im_aligned[:,:,i], im_min, im_max)\n",
    "\n",
    "rgb = im_display[:,:,rgb_band_indices]\n",
    "\n",
    "# for cir false color imagery, we normalize the NIR,R,G bands within themselves, which provides\n",
    "# the classical CIR rendering where plants are red and soil takes on a blue tint\n",
    "for i in cir_band_indices:\n",
    "    im_display[:,:,i] =  imageutils.normalize(im_aligned[:,:,i])\n",
    "\n",
    "cir = im_display[:,:,cir_band_indices]\n",
    "fig, axes = plt.subplots(1, 2, figsize=figsize)\n",
    "axes[0].set_title(\"Red-Green-Blue Composite\")\n",
    "axes[0].imshow(rgb)\n",
    "axes[1].set_title(\"Color Infrared (CIR) Composite\")\n",
    "axes[1].imshow(cir)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Image Enhancement\n",
    "\n",
    "There are many techniques for image enhancement, but one which is commonly used to improve the visual sharpness of imagery is the unsharp mask.  Here we apply an unsharp mask to the RGB image to improve the visualization, and then apply a gamma curve to make the darkest areas brighter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an enhanced version of the RGB render using an unsharp mask\n",
    "gaussian_rgb = cv2.GaussianBlur(rgb, (9,9), 10.0)\n",
    "gaussian_rgb[gaussian_rgb<0] = 0\n",
    "gaussian_rgb[gaussian_rgb>1] = 1\n",
    "unsharp_rgb = cv2.addWeighted(rgb, 1.5, gaussian_rgb, -0.5, 0)\n",
    "unsharp_rgb[unsharp_rgb<0] = 0\n",
    "unsharp_rgb[unsharp_rgb>1] = 1\n",
    "\n",
    "# Apply a gamma correction to make the render appear closer to what our eyes would see\n",
    "gamma = 1.4\n",
    "gamma_corr_rgb = unsharp_rgb**(1.0/gamma)\n",
    "fig = plt.figure(figsize=figsize)\n",
    "plt.imshow(gamma_corr_rgb, aspect='equal')\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Image Export\n",
    "\n",
    "Composite images can be exported to JPEG or PNG format using the `imageio` package.  These images may be useful for visualization or thumbnailing, and creating RGB thumbnails of a set of images can provide a convenient way to browse the imagery in a more visually appealing way that browsing the raw imagery.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import imageio\n",
    "imtype = 'png' # or 'jpg'\n",
    "imageio.imwrite('rgb.'+imtype, (255*gamma_corr_rgb).astype('uint8'))\n",
    "imageio.imwrite('cir.'+imtype, (255*cir).astype('uint8'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stack Export\n",
    "\n",
    "We can export the image easily stacks using the `gdal` library (http://www.glal.org). Once exported, these image stacks can be opened in software such as QGIS and raster operations such as NDVI or NDRE computation can be done in that software.  At this time the stacks don't include any geographic information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from osgeo import gdal, gdal_array\n",
    "rows, cols, bands = im_display.shape\n",
    "driver = gdal.GetDriverByName('GTiff')\n",
    "filename = \"bbggrreeen\" #blue,blue,green,green,red,red,rededge,rededge,rededge,nir\n",
    "\n",
    "sort_by_wavelength = True # set to false if you want stacks in camera-band-index order\n",
    "    \n",
    "outRaster = driver.Create(filename+\".tiff\", cols, rows, bands, gdal.GDT_UInt16, options = [ 'INTERLEAVE=BAND','COMPRESS=DEFLATE' ])\n",
    "try:\n",
    "    if outRaster is None:\n",
    "        raise IOError(\"could not load gdal GeoTiff driver\")\n",
    "\n",
    "    if sort_by_wavelength:\n",
    "        eo_list = list(np.argsort(capture.center_wavelengths()))\n",
    "    else:\n",
    "        eo_list = capture.eo_indices()\n",
    "\n",
    "    for outband,inband in enumerate(eo_list):\n",
    "        outband = outRaster.GetRasterBand(outband+1)\n",
    "        outdata = im_aligned[:,:,inband]\n",
    "        outdata[outdata<0] = 0\n",
    "        outdata[outdata>2] = 2   #limit reflectance data to 200% to allow some specular reflections\n",
    "        outband.WriteArray(outdata*32768) # scale reflectance images so 100% = 32768\n",
    "        outband.FlushCache()\n",
    "\n",
    "    for outband,inband in enumerate(capture.lw_indices()):\n",
    "        outband = outRaster.GetRasterBand(len(eo_list)+outband+1)\n",
    "        outdata = (im_aligned[:,:,inband]+273.15) * 100 # scale data from float degC to back to centi-Kelvin to fit into uint16\n",
    "        outdata[outdata<0] = 0\n",
    "        outdata[outdata>65535] = 65535\n",
    "        outband.WriteArray(outdata)\n",
    "        outband.FlushCache()\n",
    "finally:\n",
    "    outRaster = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Notes on Alignment and Stack Usage\n",
    "\n",
    "\"Stacks\" as described above are useful in a number of processing cases.  For example, at the time of this writing, many photogrammetry suites could import and process stack files without significantly impacting the radiometric processing which has already been accomplished.  \n",
    "\n",
    "Running photogrammetry on stack files instead of raw image files has both advantages and drawbacks. The primary advantage has been found to be an increase in processing speed and a reduction in program memory usage. As the photogrammetric workflow generally operates on luminance images and may not use color information, stacked images may require similar resources and be processed at a similar speed as single-band images.  This is because one band of the stack can be used to generate the matching feature space while the others are ignored for matching purposes. This reduces the feature space 5-fold over matching using all images separately.\n",
    "\n",
    "One disadvantage is that stacking images outside of the photogrammetric workflow may result in poor image matching.  The RedEdge is known to have stable lens characteristics over the course of normal operation, but variations in temperature or impacts to the camera through handling or rough landings may change the image alignment parameters.  For this reason, we recommend finding a matching transformation for each flight (each take-off and landing).  Alignment transformations from multiple images within a flight can be compared to find the best transformation to apply to the set of the flight.  While not described or supported in this generic implementation, some matching algorithms can use a \"seed\" value as a starting point to speed up matching.  For most cases, this seed could be the transformation found in a previous flight, or another source of a known good transformation.    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NDVI Computation\n",
    "\n",
    "For raw index computation on single images, the numpy package provides a simple way to do math and simple visualizatoin on images.  Below, we compute and visualize an image histogram and then use that to pick a colormap range for visualizing the NDVI of an image. \n",
    "\n",
    "### Plant Classification\n",
    "\n",
    "After computing the NDVI and prior to displaying it, we use a very rudimentary method for focusing on the plants and removing the soil and shadow information from our images and histograms. Below we remove non-plant pixels by setting to zero any pixels in the image where the NIR reflectance is less than 20%.  This helps to ensure that the NDVI and NDRE histograms aren't skewed substantially by soil noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from micasense import plotutils\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "nir_band = [name.lower() for name in capture.band_names()].index('nir')\n",
    "red_band = [name.lower() for name in capture.band_names()].index('red')\n",
    "\n",
    "np.seterr(divide='ignore', invalid='ignore') # ignore divide by zero errors in the index calculation\n",
    "\n",
    "# Compute Normalized Difference Vegetation Index (NDVI) from the NIR(3) and RED (2) bands\n",
    "ndvi = (im_aligned[:,:,nir_band] - im_aligned[:,:,red_band]) / (im_aligned[:,:,nir_band] + im_aligned[:,:,red_band])\n",
    "\n",
    "# remove shadowed areas (mask pixels with NIR reflectance < 20%))\n",
    "if img_type == 'reflectance':\n",
    "    ndvi = np.ma.masked_where(im_aligned[:,:,nir_band] < 0.20, ndvi) \n",
    "elif img_type == 'radiance':\n",
    "    lower_pct_radiance = np.percentile(im_aligned[:,:,3],  10.0)\n",
    "    ndvi = np.ma.masked_where(im_aligned[:,:,nir_band] < lower_pct_radiance, ndvi) \n",
    "    \n",
    "# Compute and display a histogram\n",
    "ndvi_hist_min = np.min(ndvi)\n",
    "ndvi_hist_max = np.max(ndvi)\n",
    "fig, axis = plt.subplots(1, 1, figsize=(10,4))\n",
    "axis.hist(ndvi.ravel(), bins=512, range=(ndvi_hist_min, ndvi_hist_max))\n",
    "plt.title(\"NDVI Histogram\")\n",
    "plt.show()\n",
    "\n",
    "min_display_ndvi = 0.45 # further mask soil by removing low-ndvi values\n",
    "#min_display_ndvi = np.percentile(ndvi.flatten(),  5.0)  # modify with these percentilse to adjust contrast\n",
    "max_display_ndvi = np.percentile(ndvi.flatten(), 99.5)  # for many images, 0.5 and 99.5 are good values\n",
    "masked_ndvi = np.ma.masked_where(ndvi < min_display_ndvi, ndvi)\n",
    "\n",
    "#reduce the figure size to account for colorbar\n",
    "figsize=np.asarray(figsize) - np.array([3,2])\n",
    "\n",
    "#plot NDVI over an RGB basemap, with a colorbar showing the NDVI scale\n",
    "fig, axis = plotutils.plot_overlay_withcolorbar(gamma_corr_rgb, \n",
    "                                    masked_ndvi, \n",
    "                                    figsize = figsize, \n",
    "                                    title = 'NDVI filtered to only plants over RGB base layer',\n",
    "                                    vmin = min_display_ndvi,\n",
    "                                    vmax = max_display_ndvi)\n",
    "fig.savefig('ndvi_over_rgb.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NDRE Computation\n",
    "\n",
    "In the same manner, we can compute, filter, and display another index useful for the RedEdge camera, the Normalized Difference Red Edge (NDRE) index.  We also filter out shadows and soil to ensure our display focuses only on the plant health."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Compute Normalized Difference Red Edge Index from the NIR(3) and RedEdge(4) bands\n",
    "rededge_band = [name.lower() for name in capture.band_names()].index('red edge')\n",
    "ndre = (im_aligned[:,:,nir_band] - im_aligned[:,:,rededge_band]) / (im_aligned[:,:,nir_band] + im_aligned[:,:,rededge_band])\n",
    "\n",
    "# Mask areas with shadows and low NDVI to remove soil\n",
    "masked_ndre = np.ma.masked_where(ndvi < min_display_ndvi, ndre)\n",
    "\n",
    "# Compute a histogram\n",
    "ndre_hist_min = np.min(masked_ndre)\n",
    "ndre_hist_max = np.max(masked_ndre)\n",
    "fig, axis = plt.subplots(1, 1, figsize=(10,4))\n",
    "axis.hist(masked_ndre.ravel(), bins=512, range=(ndre_hist_min, ndre_hist_max))\n",
    "plt.title(\"NDRE Histogram (filtered to only plants)\")\n",
    "plt.show()\n",
    "\n",
    "min_display_ndre = np.percentile(masked_ndre, 5)\n",
    "max_display_ndre = np.percentile(masked_ndre, 99.5)\n",
    "\n",
    "fig, axis = plotutils.plot_overlay_withcolorbar(gamma_corr_rgb, \n",
    "                                    masked_ndre, \n",
    "                                    figsize=figsize, \n",
    "                                    title='NDRE filtered to only plants over RGB base layer',\n",
    "                                    vmin=min_display_ndre,vmax=max_display_ndre)\n",
    "fig.savefig('ndre_over_rgb.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Red vs NIR Reflectance\n",
    "\n",
    "Finally, we show a classic agricultural remote sensing output in the tassled cap plot.  This plot can be useful for visualizing row crops and plots the Red Reflectance channel on the X-axis against the NIR reflectance channel on the Y-axis. This plot also clearly shows the line of the soil in that space.  The tassled cap view isn't very useful for this arid data set; however, we can see the \"badge of trees\" of high NIR reflectance and relatively low red reflectance. This provides an example of one of the uses of aligned images for single capture analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "x_band = red_band\n",
    "y_band = nir_band\n",
    "x_max = np.max(im_aligned[:,:,x_band])\n",
    "y_max = np.max(im_aligned[:,:,y_band])\n",
    "\n",
    "fig = plt.figure(figsize=(12,12))\n",
    "plt.hexbin(im_aligned[:,:,x_band],im_aligned[:,:,y_band],gridsize=640,bins='log',extent=(0,x_max,0,y_max))\n",
    "ax = fig.gca()\n",
    "ax.set_xlim([0,x_max])\n",
    "ax.set_ylim([0,y_max])\n",
    "plt.xlabel(\"{} Reflectance\".format(capture.band_names()[x_band]))\n",
    "plt.ylabel(\"{} Reflectance\".format(capture.band_names()[y_band]))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print warp_matrices for usage elsewhere, such as Batch Processing\n",
    "Last, we output the warp_matrices that we got for this image stack for usage elsewhere. Currently these can be used in the `Batch Processing.ipynb` notebook to save reflectance-compensated stacks of images to a directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "print(warp_matrices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "Copyright (c) 2017-2018 MicaSense, Inc.  For licensing information see the [project git repository](https://github.com/micasense/imageprocessing)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  },
  "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": 2
}