Lab10_Tasks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab10 Mapping\n",
    "----------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create static maps using Geopandas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# import necessary modules, e.g geopandas, matplotlib\n",
    "# %matplotlib inline\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Read files of Hays county, Texas from data/Hays folder\n",
    "# including the blockgroup (HaysBG00.shp), roads(Hays_roads.shp), \n",
    "# and landmarks(Hays_landmarks.shp)\n",
    "blockgroup = \n",
    "roads = \n",
    "landmarks = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# check the coordinate system of the 3 layers, are they the same?\n",
    "# if yes, we can continue, if not you need to reproject them to the same crs.\n",
    "# hint：using == to compare.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# make a visualization using the .plot() in Geopandas.\n",
    "# Visualize the block group based on column \"POP2000\". \n",
    "# set transparency as 0.5, color map as Blues\n",
    "my_map = \n",
    "\n",
    "# Add roads on top of the blockgroup\n",
    "# (use ax parameter to define the map on top of which \n",
    "# the second items are plotted)\n",
    "\n",
    "\n",
    "# Add metro on top of the previous map\n",
    "\n",
    "\n",
    "# Remove the empty white-space around the axes, \n",
    "# using .tight_layout()\n",
    "plt.tight_layout();\n",
    "\n",
    "# Save the figure as png file with resolution of 300 dpi, hint: use .savefig()\n",
    "plt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a simple interaction map using Bokeh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Import necessary functionalities (figure, save) from bokeh.plotting.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Initialize the plot (p) and give it a title \"Task 2 plot\"\n",
    "# hint figure(title = \"?\")\n",
    "p = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# import numpy\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create a list of 100 x-coordinates using numpy.random.random()\n",
    "x_coords = \n",
    "# Create a list of 100 y-coordinates using numpy.random.random()\n",
    "y_coords = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Plot the points using .circle(). \n",
    "# Let’s give it a blue color and size of 5.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Save the plot by passing the plot -object and output path\n",
    "# hint: save(obj = ?, filename = ?)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating interactive maps using Bokeh and Geopandas from shapefile(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# import geopandas\n",
    "\n",
    "# Read the landmarks(Hays_landmarks.shp) from data/Hays folder\n",
    "landmarks = \n",
    "# check the data using .head()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# create a function called getPointCoords() which will return   \n",
    "# the x or y coordinate of a given geometry.\n",
    "def getPointCoords(row, geom, coord_type):\n",
    "    \"\"\"Calculates coordinates ('x' or 'y') of a Point geometry\"\"\"\n",
    "    if coord_type == 'x':\n",
    "        return row[geom].x\n",
    "    elif coord_type == 'y':\n",
    "        return row[geom].y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Use the function by calling .apply() function.\n",
    "# Calculate x coordinates\n",
    "# hint: dataframe.apply(functionname, geom = \"geometry column name\", coord_type='x or y', axis=1)\n",
    "landmarks['x'] = \n",
    "# Calculate y coordinates\n",
    "landmarks['y'] = \n",
    "# Let's see what we have now using .head()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Make a copy and drop the geometry column\n",
    "p_df = landmarks.drop('geometry', axis=1).copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# from bokeh.models import ColumnDataSource\n",
    "\n",
    "#convert that pandas DataFrame into a ColumnDataSource.\n",
    "psource = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Initialize our plot figure with title (\"Task3 map\")\n",
    "p = \n",
    "# Plot the points using .circle(). \n",
    "# Let’s give it a green color and size of 5.\n",
    "\n",
    "# Save the plot by passing the plot -object and output path\n",
    "# hint: save(obj = ?, filename = ?)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 4: Multiple layer map: Polygon map with Points and Lines**\n",
    "\n",
    "It is of course possible to add different layers on top of each other. Let’s visualize a map showing accessibility in Helsinki Region and place a metro line and the address points on top of that.\n",
    "\n",
    "1st step: Import necessary modules and read the Shapefiles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from bokeh.plotting import figure, save\n",
    "from bokeh.models import ColumnDataSource, HoverTool, LogColorMapper\n",
    "import geopandas as gpd\n",
    "import pysal as ps\n",
    "import numpy as np\n",
    "# Read files\n",
    "grid = gpd.read_file(r\"data\\TravelTimes_to_5975375_RailwayStation.shp\")\n",
    "points = gpd.read_file(r\"data\\addresses.shp\")\n",
    "metro = gpd.read_file(r\"data\\metro.shp\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# make the coordinate reference system the same in every one of the layers. \n",
    "points= points.to_crs(crs=grid.crs)\n",
    "metro= metro.to_crs(crs=grid.crs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def getXYCoords(geometry, coord_type):\n",
    "    \"\"\" Returns either x or y coordinates from  geometry coordinate sequence. Used with LineString and Polygon geometries.\"\"\"\n",
    "    if coord_type == 'x':\n",
    "        return geometry.coords.xy[0]\n",
    "    elif coord_type == 'y':\n",
    "        return geometry.coords.xy[1]\n",
    "\n",
    "def getPolyCoords(geometry, coord_type):\n",
    "    \"\"\" Returns Coordinates of Polygon using the Exterior of the Polygon.\"\"\"\n",
    "    ext = geometry.exterior\n",
    "    return getXYCoords(ext, coord_type)\n",
    "\n",
    "def getLineCoords(geometry, coord_type):\n",
    "    \"\"\" Returns Coordinates of Linestring object.\"\"\"\n",
    "    return getXYCoords(geometry, coord_type)\n",
    "\n",
    "def getPointCoords(geometry, coord_type):\n",
    "    \"\"\" Returns Coordinates of Point object.\"\"\"\n",
    "    if coord_type == 'x':\n",
    "        return geometry.x\n",
    "    elif coord_type == 'y':\n",
    "        return geometry.y\n",
    "\n",
    "def multiGeomHandler(multi_geometry, coord_type, geom_type):\n",
    "    \"\"\"\n",
    "    Function for handling multi-geometries. Can be MultiPoint, MultiLineString or MultiPolygon.\n",
    "    Returns a list of coordinates where all parts of Multi-geometries are merged into a single list.\n",
    "    Individual geometries are separated with np.nan which is how Bokeh wants them.\n",
    "    # Bokeh documentation regarding the Multi-geometry issues can be found here (it is an open issue)\n",
    "    # https://github.com/bokeh/bokeh/issues/2321\n",
    "    \"\"\"\n",
    "\n",
    "    for i, part in enumerate(multi_geometry):\n",
    "        # On the first part of the Multi-geometry initialize the coord_array (np.array)\n",
    "        if i == 0:\n",
    "            if geom_type == \"MultiPoint\":\n",
    "                coord_arrays = np.append(getPointCoords(part, coord_type), np.nan)\n",
    "            elif geom_type == \"MultiLineString\":\n",
    "                coord_arrays = np.append(getLineCoords(part, coord_type), np.nan)\n",
    "            elif geom_type == \"MultiPolygon\":\n",
    "                coord_arrays = np.append(getPolyCoords(part, coord_type), np.nan)\n",
    "        else:\n",
    "            if geom_type == \"MultiPoint\":\n",
    "                coord_arrays = np.concatenate([coord_arrays, np.append(getPointCoords(part, coord_type), np.nan)])\n",
    "            elif geom_type == \"MultiLineString\":\n",
    "                coord_arrays = np.concatenate([coord_arrays, np.append(getLineCoords(part, coord_type), np.nan)])\n",
    "            elif geom_type == \"MultiPolygon\":\n",
    "                coord_arrays = np.concatenate([coord_arrays, np.append(getPolyCoords(part, coord_type), np.nan)])\n",
    "\n",
    "    # Return the coordinates\n",
    "    return coord_arrays\n",
    "\n",
    "\n",
    "def getCoords(row, geom, coord_type):\n",
    "    \"\"\"\n",
    "    Returns coordinates ('x' or 'y') of a geometry (Point, LineString or Polygon) as a list (if geometry is LineString or Polygon).\n",
    "    Can handle also MultiGeometries.\n",
    "    \"\"\"\n",
    "    # Get geometry\n",
    "    geom = row[geom]\n",
    "\n",
    "    # Check the geometry type\n",
    "    gtype = geom.geom_type\n",
    "\n",
    "    # \"Normal\" geometries\n",
    "    # -------------------\n",
    "\n",
    "    if gtype == \"Point\":\n",
    "        return getPointCoords(geom, coord_type)\n",
    "    elif gtype == \"LineString\":\n",
    "        return list( getLineCoords(geom, coord_type) )\n",
    "    elif gtype == \"Polygon\":\n",
    "        return list( getPolyCoords(geom, coord_type) )\n",
    "\n",
    "    # Multi geometries\n",
    "    # ----------------\n",
    "\n",
    "    else:\n",
    "        return list( multiGeomHandler(geom, coord_type, gtype) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2nd step: Let’s now apply the functions that we have created and parse the x and y coordinates for all of our datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Get the Polygon x and y coordinates\n",
    "grid['x'] = grid.apply(getCoords, geom='geometry', coord_type='x', axis=1)\n",
    "grid['y'] = grid.apply(getCoords, geom='geometry', coord_type='y', axis=1)\n",
    "# Calculate x and y coordinates of the line\n",
    "metro['x'] = metro.apply(getCoords, geom='geometry', coord_type='x', axis=1)\n",
    "metro['y'] = metro.apply(getCoords, geom='geometry', coord_type='y', axis=1)\n",
    "# Calculate x and y coordinates of the points\n",
    "points['x'] = points.apply(getCoords, geom='geometry', coord_type='x', axis=1)\n",
    "points['y'] = points.apply(getCoords, geom='geometry', coord_type='y', axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s now classify the travel times of our grid int 5 minute intervals until 200 minutes using a pysal classifier called User_Defined that allows to set our own criteria for class intervals. But first we need to replace the No Data values with a large number so that they wouldn’t be seen as the “best” accessible areas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>car_m_d</th>\n",
       "      <th>car_m_t</th>\n",
       "      <th>car_r_d</th>\n",
       "      <th>car_r_t</th>\n",
       "      <th>from_id</th>\n",
       "      <th>pt_m_d</th>\n",
       "      <th>pt_m_t</th>\n",
       "      <th>pt_m_tt</th>\n",
       "      <th>pt_r_d</th>\n",
       "      <th>pt_r_t</th>\n",
       "      <th>pt_r_tt</th>\n",
       "      <th>to_id</th>\n",
       "      <th>walk_d</th>\n",
       "      <th>walk_t</th>\n",
       "      <th>geometry</th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>pt_r_tt_ud</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>32297</td>\n",
       "      <td>43</td>\n",
       "      <td>32260</td>\n",
       "      <td>48</td>\n",
       "      <td>5785640</td>\n",
       "      <td>32616</td>\n",
       "      <td>116</td>\n",
       "      <td>147</td>\n",
       "      <td>32616</td>\n",
       "      <td>108</td>\n",
       "      <td>139</td>\n",
       "      <td>5975375</td>\n",
       "      <td>32164</td>\n",
       "      <td>459</td>\n",
       "      <td>POLYGON ((382000.0001358641 6697750.000038058,...</td>\n",
       "      <td>[382000.000136, 381750.000136, 381750.000136, ...</td>\n",
       "      <td>[6697750.00004, 6697750.00004, 6698000.00004, ...</td>\n",
       "      <td>27</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>32508</td>\n",
       "      <td>43</td>\n",
       "      <td>32471</td>\n",
       "      <td>49</td>\n",
       "      <td>5785641</td>\n",
       "      <td>32822</td>\n",
       "      <td>119</td>\n",
       "      <td>145</td>\n",
       "      <td>32822</td>\n",
       "      <td>111</td>\n",
       "      <td>133</td>\n",
       "      <td>5975375</td>\n",
       "      <td>29547</td>\n",
       "      <td>422</td>\n",
       "      <td>POLYGON ((382250.0001358146 6697750.000038053,...</td>\n",
       "      <td>[382250.000136, 382000.000136, 382000.000136, ...</td>\n",
       "      <td>[6697750.00004, 6697750.00004, 6698000.00004, ...</td>\n",
       "      <td>26</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   car_m_d  car_m_t  car_r_d  car_r_t  from_id  pt_m_d  pt_m_t  pt_m_tt  \\\n",
       "0    32297       43    32260       48  5785640   32616     116      147   \n",
       "1    32508       43    32471       49  5785641   32822     119      145   \n",
       "\n",
       "   pt_r_d  pt_r_t  pt_r_tt    to_id  walk_d  walk_t  \\\n",
       "0   32616     108      139  5975375   32164     459   \n",
       "1   32822     111      133  5975375   29547     422   \n",
       "\n",
       "                                            geometry  \\\n",
       "0  POLYGON ((382000.0001358641 6697750.000038058,...   \n",
       "1  POLYGON ((382250.0001358146 6697750.000038053,...   \n",
       "\n",
       "                                                   x  \\\n",
       "0  [382000.000136, 381750.000136, 381750.000136, ...   \n",
       "1  [382250.000136, 382000.000136, 382000.000136, ...   \n",
       "\n",
       "                                                   y  pt_r_tt_ud  \n",
       "0  [6697750.00004, 6697750.00004, 6698000.00004, ...          27  \n",
       "1  [6697750.00004, 6697750.00004, 6698000.00004, ...          26  "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Replace No Data values (-1) with large number (999)\n",
    "grid = grid.replace(-1, 999)\n",
    "# Classify our travel times into 5 minute classes until 200 minutes\n",
    "# Create a list of values where minumum value is 5, maximum value is 200 and step is 5.\n",
    "breaks = [x for x in range(5, 200, 5)]\n",
    "# Initialize the classifier and apply it\n",
    "classifier = ps.User_Defined.make(bins=breaks)\n",
    "pt_classif = grid[['pt_r_tt']].apply(classifier)\n",
    "# Rename the classified column\n",
    "pt_classif.columns = ['pt_r_tt_ud']\n",
    "# Join it back to the grid layer\n",
    "grid = grid.join(pt_classif)\n",
    "grid.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okey, so we have many columns but the new one that we just got is the last one, i.e. pt_r_tt_ud that contains the classes that we reclassified based on the public transportation travel times on 5 minute intervals.\n",
    "\n",
    "3rd step: Let’s now convert our GeoDataFrames into Bokeh ColumnDataSources (without geometry columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Make a copy, drop the geometry column and create ColumnDataSource\n",
    "m_df = metro.drop('geometry', axis=1).copy()\n",
    "msource = ColumnDataSource(m_df)\n",
    "# Make a copy, drop the geometry column and create ColumnDataSource\n",
    "p_df = points.drop('geometry', axis=1).copy()\n",
    "psource = ColumnDataSource(p_df)\n",
    "# Make a copy, drop the geometry column and create ColumnDataSource\n",
    "g_df = grid.drop('geometry', axis=1).copy()\n",
    "gsource = ColumnDataSource(g_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okey, now we are ready to roll and visualize our layers.\n",
    "\n",
    "4th step: For visualizing the Polygons we need to define the color palette that we are going to use. There are many different ones available but we are now going to use a palette called RdYlBu and use eleven color-classes for the values (defined as RdYlBu11). Let’s prepare our color_mapper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Let's first do some coloring magic that converts the color palet into map numbers (it's okey not to understand)\n",
    "from bokeh.palettes import RdYlBu11 as palette\n",
    "from bokeh.models import LogColorMapper\n",
    "# Create the color mapper\n",
    "color_mapper = LogColorMapper(palette=palette)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda2\\envs\\arc104\\lib\\site-packages\\bokeh\\io\\saving.py:125: UserWarning: save() called but no resources were supplied and output_file(...) was never called, defaulting to resources.CDN\n",
      "  warn(\"save() called but no resources were supplied and output_file(...) was never called, defaulting to resources.CDN\")\n",
      "C:\\ProgramData\\Anaconda2\\envs\\arc104\\lib\\site-packages\\bokeh\\io\\saving.py:138: UserWarning: save() called but no title was supplied and output_file(...) was never called, using default title 'Bokeh Plot'\n",
      "  warn(\"save() called but no title was supplied and output_file(...) was never called, using default title 'Bokeh Plot'\")\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'J:\\\\UNM\\\\Syllabus\\\\GEOG428528\\\\Lab10\\\\data\\\\travel_time_map2.html'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Now we are ready to visualize our polygons and add the metro line and the points on top of that. Polygons are visualized using patches objects in Bokeh.\n",
    "\n",
    "# Initialize our figure\n",
    "p = figure(title=\"Travel times with Public transportation to Central Railway station\")\n",
    "# Plot grid\n",
    "p.patches('x', 'y', source=gsource, fill_color={'field': 'pt_r_tt_ud', 'transform': color_mapper}, fill_alpha=1.0, line_color=\"black\", line_width=0.05)\n",
    "# Add metro on top of the same figure\n",
    "p.multi_line('x', 'y', source=msource, color=\"red\", line_width=2)\n",
    "# Add points on top (as black points)\n",
    "p.circle('x', 'y', size=3, source=psource, color=\"black\")\n",
    "\n",
    "# Save the figure\n",
    "outfp = r\"data\\travel_time_map2.html\"\n",
    "save(p, outfp)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "229px",
    "left": "1046px",
    "right": "20px",
    "top": "110.5px",
    "width": "234px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}