v5.1 - Load runs onto graph.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load graph data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished\n"
     ]
    }
   ],
   "source": [
    "import networkx as nx\n",
    "import json\n",
    "import numpy as np\n",
    "import gmplot #for plotting to google maps\n",
    "\n",
    "#load the shapefile generated from an OSMnx pull (see v4.1 OSMnx to generate SHP.ipynb)\n",
    "#g = nx.read_shp('data/from_osmnx/edges/edges.shp')\n",
    "#g = nx.read_shp('data/from_osmnx_2017_05_11/edges/edges.shp')\n",
    "#g = nx.read_shp('data/from_osmnx_2017_05_20/edges/edges.shp')\n",
    "g = nx.read_shp('data/from_osmnx_2017_05_21_all_private/edges/edges.shp')\n",
    "\n",
    "#returns array of coordinates for any edge in the graph\n",
    "def get_path(n0, n1):\n",
    "    \"\"\"If n0 and n1 are connected nodes in the graph, this function\n",
    "    return an array of point coordinates along the road linking\n",
    "    these two nodes.\"\"\"\n",
    "    return np.array(json.loads(g[n0][n1]['Json'])['coordinates'])\n",
    "\n",
    "#returns in KILOMETERS\n",
    "EARTH_R = 6372.8\n",
    "def geocalc(lat0, lon0, lat1, lon1):\n",
    "    \"\"\"Return the distance (in km) between two points in \n",
    "    geographical coordinates.\"\"\"\n",
    "    lat0 = np.radians(lat0)\n",
    "    lon0 = np.radians(lon0)\n",
    "    lat1 = np.radians(lat1)\n",
    "    lon1 = np.radians(lon1)\n",
    "    dlon = lon0 - lon1\n",
    "    y = np.sqrt(\n",
    "        (np.cos(lat1) * np.sin(dlon)) ** 2\n",
    "         + (np.cos(lat0) * np.sin(lat1) \n",
    "         - np.sin(lat0) * np.cos(lat1) * np.cos(dlon)) ** 2)\n",
    "    x = np.sin(lat0) * np.sin(lat1) + \\\n",
    "        np.cos(lat0) * np.cos(lat1) * np.cos(dlon)\n",
    "    c = np.arctan2(y, x)\n",
    "    return EARTH_R * c\n",
    "\n",
    "#Now, we define a function computing a path's length.\n",
    "#This function has been found in StackOverflow. http://stackoverflow.com/questions/8858838/need-help-calculating-geographical-distance\n",
    "\n",
    "#order of lats, lons was incorrect in tutorial! Corrected here\n",
    "def get_path_length(path):\n",
    "    return np.sum(geocalc(path[:-1,1], path[:-1,0], path[1:,1], path[1:,0]))\n",
    "\n",
    "print('finished')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load graph data > Add nodes and connect them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the data (a Shapefile dataset) with NetworkX. \n",
    "This dataset contains detailed information about all roads in San Francisco County. \n",
    "NetworkX's read_shp function returns a graph, where each node is a geographical position, \n",
    "and each edge contains information about the road linking the two nodes.\n",
    "\n",
    "In lieu of Census data, SF Gov has a full, connected graph of streets that can be found here: https://data.sfgov.org/Geographic-Locations-and-Boundaries/Streets-of-San-Francisco/4ugn-hf48"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Shapefile is incomplete, so here we manually create edges known to exist\n",
    "\"\"\"\n",
    "#given two nodes, build a node between them\n",
    "#nodes must be in (lon, lat) tuple\n",
    "def create_edge(a,b):\n",
    "    g.add_edge(a, b)\n",
    "    g[a][b]['Json'] = '{ \"type\": \"LineString\" ,\"coordinates\" : [' + str([p for p in a]) + ', ' + str([p for p in b]) + ']}'\n",
    "\n",
    "\n",
    "#road has a gate at the end of public part\n",
    "p1 = (-122.38385529999999, 37.7423869)\n",
    "p2 = (-122.382517, 37.741975)\n",
    "create_edge(p1, p2) #lon/lat\n",
    "\n",
    "'''extend edge\n",
    "    inputs: an edge, and a tuple representing a non-existent node\n",
    "    outputs: the edge is now extended to a new node (original edge endpoint now a coordinate), that node splits the nearest edge\n",
    "'''\n",
    "def extend_edge(my_edge, my_point):\n",
    "    #for the point, find the edge it's on and split it into two edges, connected at the point\n",
    "    split_edge(my_point)\n",
    "    \n",
    "    #for the edge, find the closest end point and create a new edge to the point\n",
    "    closest, farthest = orient_edge_endpoints(my_point[::-1], my_edge)\n",
    "    create_edge(closest, my_point[::-1])\n",
    "    \n",
    "'''split an edge with a given point on it\n",
    "    inputs: the point that is being added to the graph\n",
    "    output: the edge, previously A-B is now two edges, A-C & C-B\n",
    "'''\n",
    "def split_edge(my_point):\n",
    "    my_edge = find_closest_edge(my_point)\n",
    "    create_edge(my_edge[0], my_point[::-1])\n",
    "    create_edge(my_edge[1], my_point[::-1])\n",
    "    \n",
    "#given a point, return the closest edge; optionally return its distance\n",
    "def find_closest_edge(my_point, method='all', return_distance=False):\n",
    "\n",
    "    min_distance_to_coord_edge = 100\n",
    "\n",
    "#iterate through edges and record distance to closest point on edge\n",
    "    for n0, n1 in g.edges_iter():\n",
    "\n",
    "#use two methods to look for closest road: (1) by line segment using perpendicular distance, (2) by edge's coordinates\n",
    "#(2) is necessary for curving roads...I think\n",
    "        if n0 == n1:\n",
    "            continue\n",
    "        \n",
    "        my_distance_perp = distance_from_line(n0[::-1], n1[::-1], my_point)\n",
    "        my_distance_coord = distance_from_edge_coord(n0,n1,my_point)\n",
    "        \n",
    "        #for debugging\n",
    "        if method == 'perp':\n",
    "            my_distance = my_distance_perp\n",
    "        elif method == 'coord':\n",
    "            my_distance = my_distance_coord\n",
    "        else:\n",
    "            my_distance = min(my_distance_perp, my_distance_coord)\n",
    "        \n",
    "        if my_distance < min_distance_to_coord_edge:\n",
    "            min_distance_to_coord_edge = my_distance\n",
    "            closest_edge = [n0, n1]\n",
    "            \n",
    "    if return_distance:\n",
    "        return closest_edge, min_distance_to_coord_edge\n",
    "            \n",
    "    return closest_edge\n",
    "\n",
    "#for a given point, find the edge it is closest to\n",
    "#first, find it's closest point on an infinite line defined by two nodes\n",
    "#use https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line#Line_defined_by_two_points\n",
    "#if that point IS NOT actually between the nodes, take the closest node\n",
    "\n",
    "def distance_from_line(p,q,x):\n",
    "\n",
    "#==Part 1===\n",
    "#p & q make a line; how far is x from this infinite line?\n",
    "\n",
    "#vertical traverse\n",
    "    a = p[1] - q[1]\n",
    "\n",
    "#horizontal traverse\n",
    "    b = q[0] - p[0]\n",
    "\n",
    "#ax+by+c = 0\n",
    "    c = -a * p[0] - b * p[1]\n",
    "\n",
    "    \n",
    "    \n",
    "#==Part 2== does this closest-line-point actually lie between nodes?\n",
    "#Ax + By + C = 0 ==> y = (-Ax - C)/B\n",
    "\n",
    "#first, calculate what the closest point is, holding x constant\n",
    "#second, calculate the distance between that closest point and the actual point\n",
    "#finally, check whether the closest point actually lies on the line between the edge's endpoints\n",
    "#if not, use the closest endpoint\n",
    "\n",
    "    if b == 0:\n",
    "# vertical line: ==> x = (-C - By) / A ==> x = -C / A\n",
    "#thus, ignore y and only take the distance between x and the latitude of our point\n",
    "    #print('vertical line')\n",
    "        dist =  abs(a*x[0] + c) / abs(a)\n",
    "        closest_y = x[1]\n",
    "\n",
    "# horizontal line: ==> y = (-Ax - C) / B ==> y = -C / B\n",
    "#thus, ignore x and only take the distance between y and longitude of our point\n",
    "    elif a == 0:\n",
    "    #print('horizontal line')\n",
    "        dist = abs(b* x[1] + c) / abs(b)\n",
    "        closest_y = -c / b\n",
    "    \n",
    "\n",
    "#not a vertical or horizontal line? proceed with full formula\n",
    "    elif a * b != 0:\n",
    "#distance = |Ax0 + By0 + C| / sqrt(a^2 + b^s)\n",
    "    #print('diagnoal line')\n",
    "        dist = abs(a*x[0] + b*x[1] + c) / (a**2 + b**2)**0.5\n",
    "        closest_y = (-1 * a * x[0] - c) / b\n",
    "    \n",
    "    else:\n",
    "        print('error!')\n",
    "        return\n",
    "\n",
    "#lat&lon must be constrained by nodes' lat/lons\n",
    "    p_x = distance_points(p, [x[0], closest_y])\n",
    "    q_x = distance_points(q, [x[0], closest_y])\n",
    "    p_q = distance_points(p,q)\n",
    "\n",
    "    error = 1e-10\n",
    "    if(abs(p_x + q_x - p_q) < error):\n",
    "        return dist\n",
    "    \n",
    "#print('closest point not on edge')\n",
    "    return min(distance_points(p,x), distance_points(q,x))\n",
    "\n",
    "#given two 2-d points, return their distance\n",
    "def distance_points(a,b):\n",
    "    return np.sqrt((a[0] - b[0])**2 + (a[1] - b[1])**2)\n",
    "\n",
    "def distance_from_edge_coord(a,b,my_point):\n",
    "    path = get_path(a,b)\n",
    "    my_distances = np.sum((path[:,::-1] - my_point)**2, axis=1)\n",
    "    return min(my_distances**0.5)\n",
    "\n",
    "'''orient edge endpoints\n",
    "    inputs: a node and an edge, in any orientation\n",
    "    outputs: two nodes (the edge's endpoints) in order of closest and farthest\n",
    "'''\n",
    "def orient_edge_endpoints(my_node, my_edge):\n",
    "    distance_0 = distance_points(my_node, my_edge[0])\n",
    "    distance_1 = distance_points(my_node, my_edge[1])\n",
    "    \n",
    "    #if a tie, arbitrarily take the first point\n",
    "    if distance_0 <= distance_1:\n",
    "        return my_edge[0], my_edge[1]\n",
    "    if distance_1 < distance_0:\n",
    "        return my_edge[1], my_edge[0]\n",
    "    \n",
    "this_point = (37.7999762, -122.413069)\n",
    "this_edge = [(-122.4124276, 37.7997612), (-122.41301, 37.799689)]\n",
    "#not needed with openstreetmap edits\n",
    "#extend_edge(this_edge, this_point)\n",
    "\n",
    "#being directional means being unable to find edges unless in correct order\n",
    "#so switch to unidirected\n",
    "g = g.to_undirected()\n",
    "\n",
    "sg_all = list(nx.connected_component_subgraphs(g.to_undirected()))\n",
    "\n",
    "#grab the biggest subgraph\n",
    "max_len = -1\n",
    "sg_final = sg_all[0]\n",
    "for sg in sg_all:\n",
    "    x = len(sg)\n",
    "    if x > max_len:\n",
    "        max_len = x\n",
    "        sg_final = sg\n",
    "        \n",
    "# establish all the nodes\n",
    "nodes = np.array(sg_final.nodes())\n",
    "\n",
    "#update graph by computing the distance between any two connected nodes\n",
    "for n0, n1 in sg_final.edges_iter():\n",
    "    path = get_path(n0, n1)\n",
    "    distance = get_path_length(path)\n",
    "    sg_final.edge[n0][n1]['distance'] = distance\n",
    "    \n",
    "print('finished')    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Load graph data > Visually see graph on a map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://github.com/vgm64/gmplot\n",
    "library for googplotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Plotting the full graph\n",
    "\"\"\"\n",
    "\n",
    "#for an edge, pull all coordinates\n",
    "def pull_coords(my_edge):\n",
    "    return np.array(json.loads(g[e[0]][e[1]]['Json'])['coordinates'])\n",
    "\n",
    "#plot said coordinates from ALL edges in Shapefile\n",
    "a_map = gmplot.GoogleMapPlotter.from_geocode(\"San Francisco\")\n",
    "\n",
    "for e in g.edges_iter():\n",
    "    a_map.plot(pull_coords(e)[:,1], pull_coords(e)[:,0], 'red', edge_width=2, alpha=0.5)\n",
    "\n",
    "a_map.draw('test plots/v5 using OSMnx all.html')\n",
    "print('finished')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load run history"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load run history > map a KML"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Plot runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2014-01-13 00:00:00\n",
      "2014-01-19 00:00:00\n",
      "2014-07-15 00:00:00\n",
      "2014-08-28 00:00:00\n",
      "2014-12-16 00:00:00\n",
      "2015-01-10 00:00:00\n",
      "2015-03-28 00:00:00\n",
      "2015-07-08 00:00:00\n",
      "2016-01-06 00:00:00\n",
      "2016-07-11 00:00:00\n",
      "2016-08-15 00:00:00\n",
      "2016-08-15 00:00:00\n",
      "2016-11-15 00:00:00\n",
      "2016-11-16 00:00:00\n",
      "2016-11-24 00:00:00\n",
      "2016-11-27 00:00:00\n",
      "2016-11-29 00:00:00\n",
      "2016-11-30 00:00:00\n",
      "2016-12-15 00:00:00\n",
      "2017-01-03 00:00:00\n",
      "2017-01-08 00:00:00\n",
      "2017-01-09 00:00:00\n",
      "2017-01-30 00:00:00\n",
      "2017-03-05 00:00:00\n",
      "2017-03-07 00:00:00\n",
      "2017-03-11 00:00:00\n",
      "2017-03-11 00:00:00\n",
      "2017-03-16 00:00:00\n",
      "2017-03-20 00:00:00\n",
      "2017-03-22 00:00:00\n",
      "2017-03-23 00:00:00\n",
      "2017-03-25 00:00:00\n",
      "2017-03-26 00:00:00\n",
      "2017-03-26 00:00:00\n",
      "2017-03-28 00:00:00\n",
      "2017-03-31 00:00:00\n",
      "2017-04-03 00:00:00\n",
      "2017-04-05 00:00:00\n",
      "2017-04-08 00:00:00\n",
      "2017-04-11 00:00:00\n",
      "2017-04-12 00:00:00\n",
      "2017-04-13 00:00:00\n",
      "2017-04-16 00:00:00\n",
      "2017-04-18 00:00:00\n",
      "2017-04-20 00:00:00\n",
      "2017-04-24 00:00:00\n",
      "2017-04-25 00:00:00\n",
      "2017-04-26 00:00:00\n",
      "2017-05-01 00:00:00\n",
      "2017-05-02 00:00:00\n",
      "2017-05-03 00:00:00\n",
      "2017-05-07 00:00:00\n",
      "2017-05-08 00:00:00\n",
      "2017-05-12 00:00:00\n",
      "2017-05-13 00:00:00\n",
      "2017-05-17 00:00:00\n",
      "2017-05-18 00:00:00\n",
      "2017-05-19 00:00:00\n",
      "2017-05-21 00:00:00\n",
      "2017-05-21 00:00:00\n",
      "2017-05-31 00:00:00\n",
      "2017-06-01 00:00:00\n",
      "2017-06-07 00:00:00\n",
      "2017-06-13 00:00:00\n",
      "2017-06-16 00:00:00\n",
      "all runs mapped\n"
     ]
    }
   ],
   "source": [
    "import glob\n",
    "from datetime import datetime #when reading TCX, need to convert dates\n",
    "\n",
    "#look for all these files, compare it to the KML dates and add it to the map\n",
    "\n",
    "def pull_from_tcxs(file_pattern, dates, a_map, color):\n",
    "#loop through all matching files\n",
    "    for file in glob.glob(file_pattern):\n",
    "\n",
    "#compare it against dates from KML and only proceed if it is new data \n",
    "        file_date = file.split('tapiriik')[1][1:11]\n",
    "        file_date = datetime.strptime(file_date, '%Y-%m-%d')\n",
    "        if file_date in dates:\n",
    "            continue\n",
    "        print(file_date)\n",
    "\n",
    "#open it via beautifulsoup\n",
    "        soup = BeautifulSoup(open(file), \"html.parser\")\n",
    "\n",
    "#set up arrays for point data\n",
    "        lats = []\n",
    "        lons = []\n",
    "\n",
    "#not all points contain location data, so loop through 'position' tags and grab the parent\n",
    "        for pos in soup.find_all('position'):\n",
    "            tp = pos.parent\n",
    "\n",
    "#pick out the latitude and longitude (lat/lon need to be floats for plotting)\n",
    "            this_lat = float(pos.latitudedegrees.string)\n",
    "            this_lon = float(pos.longitudedegrees.string)\n",
    "\n",
    "#append trackpoint's data to master lists\n",
    "            lats.append(this_lat)\n",
    "            lons.append(this_lon)\n",
    "\n",
    "#add this route to the plot\n",
    "        a_map.plot(lats, lons, color, edge_width=4, alpha=0.3)\n",
    "\n",
    "#given a google map, KML file and color: add to the map for every route manually and record the dates\n",
    "\n",
    "def pull_from_kml(a_map, file, color):\n",
    "#initialize list of dates, will later compare to figure which tcx files needed\n",
    "    dates = []\n",
    "\n",
    "#grab kml file\n",
    "    soup = BeautifulSoup(open(file), \"html.parser\")\n",
    "\n",
    "#loop through all routes (placemark tags)\n",
    "    for p in soup.find_all('placemark'):\n",
    "        #pull date of run\n",
    "        this_date = p.find('name').text\n",
    "        if this_date == 'BLOCKED':\n",
    "            continue\n",
    "        dates.append(datetime.strptime(this_date, '%m/%d/%y'))\n",
    "\n",
    "        #pull out lat/lon pairs for each run\n",
    "        coords = p.coordinates.text.split()\n",
    "\n",
    "        lats = []\n",
    "        lons = []\n",
    "\n",
    "        for c in coords:\n",
    "            this_coord = c.split(',')\n",
    "            lats.append(float(this_coord[1]))\n",
    "            lons.append(float(this_coord[0]))\n",
    "\n",
    "        a_map.plot(lats, lons, color, edge_width=4, alpha=0.3)\n",
    "\n",
    "    return dates\n",
    "\n",
    "#pull from manually built KML\n",
    "file = 'Running SF.kml'\n",
    "\n",
    "#define the map area\n",
    "kml_map = gmplot.GoogleMapPlotter.from_geocode(\"San Francisco\")\n",
    "\n",
    "#generate plot of all the KML based runs\n",
    "kml_dates = pull_from_kml(kml_map, file, 'cornflowerblue')\n",
    "\n",
    "#tcs files are synced from garmin via https://tapiriik.com/\n",
    "files = '../../../Apps/tapiriik/*.tcx'\n",
    "pull_from_tcxs(files, kml_dates, kml_map, 'crimson')\n",
    "\n",
    "#generate all plots\n",
    "kml_map.draw('runs 2017 06 18.html')\n",
    "print('all runs mapped')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# scratch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "130"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.randrange(0,446)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(-122.455143, 37.7926388), (-122.4555011, 37.7933413)]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "this_coord = coord_to_node(this_point)\n",
    "find_closest_edge(this_coord)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "coords = [c[::-1] for c in json.loads(g[(-122.455143, 37.7926388)][(-122.4555011, 37.7933413)]['Json'])['coordinates']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## scratch -> read from GraphML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/29/13\n",
      "plotted to test plots/v5 test_markers - 18.html\n",
      "2/28/13\n",
      "not in SF\n",
      "plotted to test plots/v5 test_markers - 30.html\n",
      "4/17/13\n",
      "not in SF\n",
      "plotted to test plots/v5 test_markers - 43.html\n",
      "5/31/13\n",
      "plotted to test plots/v5 test_markers - 59.html\n",
      "6/13/13\n",
      "plotted to test plots/v5 test_markers - 60.html\n",
      "6/17/13\n",
      "plotted to test plots/v5 test_markers - 61.html\n",
      "10/9/13\n",
      "plotted to test plots/v5 test_markers - 100.html\n",
      "10/17/13\n",
      "plotted to test plots/v5 test_markers - 103.html\n",
      "12/10/13\n",
      "plotted to test plots/v5 test_markers - 123.html\n",
      "6/15/14\n",
      "plotted to test plots/v5 test_markers - 164.html\n",
      "7/24/14\n",
      "plotted to test plots/v5 test_markers - 178.html\n",
      "9/22/14\n",
      "plotted to test plots/v5 test_markers - 200.html\n",
      "10/09/14\n",
      "plotted to test plots/v5 test_markers - 205.html\n",
      "12/15/14\n",
      "plotted to test plots/v5 test_markers - 231.html\n",
      "2/9/15\n",
      "plotted to test plots/v5 test_markers - 257.html\n",
      "9/15/15\n",
      "plotted to test plots/v5 test_markers - 300.html\n",
      "11/25/15\n",
      "plotted to test plots/v5 test_markers - 317.html\n",
      "1/13/16\n",
      "plotted to test plots/v5 test_markers - 331.html\n",
      "2/22/16\n",
      "plotted to test plots/v5 test_markers - 343.html\n",
      "6/27/16\n",
      "not in SF\n",
      "plotted to test plots/v5 test_markers - 387.html\n",
      "8/6/16\n",
      "plotted to test plots/v5 test_markers - 399.html\n"
     ]
    }
   ],
   "source": [
    "for t in test_kmls:\n",
    "    snap_kml(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished\n"
     ]
    }
   ],
   "source": [
    "#pull a route\n",
    "test_kmls = [18, 30, 43] +\\\n",
    "list(range(59, 62)) +\\\n",
    "[100, 103, 123, 130, 164, 178, 200, 205, 231, 257, 300, 317, 331, 343, 387] +\\\n",
    "list(range(399, 401))\n",
    "\n",
    "\n",
    "print('finished')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished\n"
     ]
    }
   ],
   "source": [
    "import networkx as nx\n",
    "from shapely.geometry import LineString\n",
    "from bs4 import BeautifulSoup #library for tcx reading\n",
    "import gmplot #for plotting to google maps\n",
    "import numpy as np\n",
    "\n",
    "#g = nx.read_gpickle(\"2017_05_29 all_private cleaned_coords.gpickle\")\n",
    "#every edge has a 'length' attribute which is in meters\n",
    "\n",
    "g = nx.read_gpickle(\"2017_06_08 all_private cleaned_coords real_multidi.gpickle\")\n",
    "g = g.to_undirected()\n",
    "\n",
    "#grab kml file\n",
    "file = 'Running SF.kml'\n",
    "soup = BeautifulSoup(open(file), \"html.parser\")\n",
    "\n",
    "sg_all = list(nx.connected_component_subgraphs(g.to_undirected()))\n",
    "\n",
    "#grab the biggest subgraph\n",
    "max_len = -1\n",
    "sg_final = sg_all[0]\n",
    "for sg in sg_all:\n",
    "    x = len(sg)\n",
    "    if x > max_len:\n",
    "        max_len = x\n",
    "        sg_final = sg\n",
    "        \n",
    "# establish all the nodes\n",
    "nodes = np.array(sg_final.nodes())\n",
    "\n",
    "print('finished')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#given two 2-d points, return their distance\n",
    "def distance_points(a,b):\n",
    "    return np.sqrt((a[0] - b[0])**2 + (a[1] - b[1])**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def snap_kml(t):\n",
    "    a_run = soup.find_all('placemark')[t]\n",
    "    print(a_run.find('name').get_text())\n",
    "\n",
    "#pull out lat/lon pairs for each run\n",
    "    a_run_coords = a_run.coordinates.text.split()\n",
    "\n",
    "    a_map = plot_kml(a_run_coords)\n",
    "    location = 'test plots/v5 test_markers - ' + str(t) + '.html'\n",
    "    a_map.draw(location)\n",
    "    \n",
    "    print('plotted to ' + location)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished\n"
     ]
    }
   ],
   "source": [
    "#given a KML run, plot it on google maps\n",
    "#inferring closest nodes, edges\n",
    "def plot_kml(my_coords):\n",
    "#a_run = soup.find_all('placemark')[130]\n",
    "#a_run_coords = a_run.coordinates.text.split()\n",
    "#my_coords = a_run_coords\n",
    "\n",
    "    threshold = 25 / 100000\n",
    "    from_nodes = []\n",
    "    to_nodes = []\n",
    "    keys = []\n",
    "    colors = []\n",
    "\n",
    "    sf_limit = 1.0\n",
    "\n",
    "    a_map = gmplot.GoogleMapPlotter.from_geocode(\"San Francisco\")\n",
    "\n",
    "    lats = []\n",
    "    lons = []\n",
    "\n",
    "    #take apart the individual points\n",
    "    for c in my_coords:\n",
    "        this_coord = c.split(',')\n",
    "        lats.append(float(this_coord[1]))\n",
    "        lons.append(float(this_coord[0]))\n",
    "\n",
    "    for lat, lon in zip(lats, lons):\n",
    "        this_point = (lat, lon)\n",
    "\n",
    "    #if distance is < threshold, then just use the closest node.  Else, find the closest edge.  And plot it \n",
    "\n",
    "    # need to incorporate coordinates within the edge?\n",
    "        closest_node, dist = find_closest_node(this_point, return_distance=True)\n",
    "\n",
    "    #is the run in SF?\n",
    "        if dist > sf_limit:\n",
    "            print('not in SF')\n",
    "            a_map = gmplot.GoogleMapPlotter(lat, lon, 13)\n",
    "            #a_map = gmplot.GoogleMapPlotter.from_geocode(\"San Francisco\")\n",
    "            a_map.scatter(lats, lons, size=15, color='black', marker=False)\n",
    "            #return a_map\n",
    "            break\n",
    "\n",
    "        c_key = 0\n",
    "\n",
    "        if dist < threshold:\n",
    "            my_color = 'blue'\n",
    "            if from_nodes:\n",
    "    #connect the last point to this node\n",
    "                cn = connect_nodes(to_nodes[-1], closest_node)\n",
    "            else: #starting condition\n",
    "                from_nodes.extend([-1, closest_node]) #we'll throw this out later\n",
    "                to_nodes.extend([closest_node])\n",
    "                keys.extend([0])\n",
    "                colors.extend([my_color])\n",
    "                continue\n",
    "\n",
    "\n",
    "        else:\n",
    "#            print('guessing edge for ' + str(this_point) + ', distance: ' + str(dist))\n",
    "            ce, c_key = find_closest_edge(this_point, 'all')\n",
    "            if from_nodes:\n",
    "                #order matters here, we want to connect nodes that are next to each other, rather than make a long journey\n",
    "                cn = connect_edge(to_nodes[-1], ce)\n",
    "\n",
    "\n",
    "            else: #starting condition\n",
    "                cn = ce #just use the edge\n",
    "                from_nodes.extend([-1])\n",
    "            my_color = 'red'\n",
    "\n",
    "    #take the added nodes and pop them on\n",
    "        for cni in cn:\n",
    "            from_nodes.extend([cni])\n",
    "            to_nodes.extend([cni])\n",
    "            keys.extend([0])\n",
    "            colors.extend([my_color])\n",
    "        #correct in case the final edge was added\n",
    "        keys[-1] = c_key\n",
    "\n",
    "        a_map.scatter([lat], [lon], size=15, color=my_color, marker=False)\n",
    "\n",
    "    #remove self-connections\n",
    "    segments = pd.DataFrame(data={'from': from_nodes[1:-1], 'to': to_nodes[1:], 'key': keys[1:], 'color': colors[1:]})\n",
    "    segments = segments[segments['from'] != segments['to']]\n",
    "\n",
    "    segments.apply(lambda s: plot_edge_gmap(s['from'], s['to'], a_map, s['color'], key=s['key']), axis=1)\n",
    "\n",
    "    return a_map\n",
    "\n",
    "#a_map.draw('test plots/v5.2 multigraph kml.html')\n",
    "print('finished')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def find_closest_node(my_point, return_distance=False):\n",
    "    min_d = 100\n",
    "\n",
    "    for n in g.nodes_iter():\n",
    "        c = pull_node_coordinate(n)[::-1]\n",
    "        d = distance_points(c, my_point)\n",
    "        if d < min_d:\n",
    "            min_d = d\n",
    "            closest_n = n\n",
    "\n",
    "    if return_distance:\n",
    "        return closest_n, min_d\n",
    "    return closest_n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#given a node (int) return the coordinate (lon,lat)\n",
    "def pull_node_coordinate(my_node):\n",
    "    return g.node[my_node]['coordinate']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished\n"
     ]
    }
   ],
   "source": [
    "#given a point, return the closest edge with key; optionally return its distance\n",
    "\n",
    "def find_closest_edge(my_point, method='all', return_distance=False):\n",
    "#my_point = my_coord\n",
    "#method='all'\n",
    "#return_distance = True\n",
    "\n",
    "    min_distance_to_coord_edge = 100\n",
    "\n",
    "    #iterate through edges and record distance to closest point on edge\n",
    "    for n0, n1 in g.edges_iter():\n",
    "\n",
    "        n0_coord = g.node[n0]['coordinate']\n",
    "        n1_coord = g.node[n1]['coordinate']\n",
    "\n",
    "        #use two methods to look for closest road: (1) by line segment using perpendicular distance, (2) by edge's coordinates\n",
    "        #(2) is necessary for curving roads...I think\n",
    "        if n0_coord == n1_coord:\n",
    "            continue\n",
    "\n",
    "        #go get closest coordinate in all the edges\n",
    "        my_distance_coord, my_key_coord = distance_from_edge_coord(n0, n1,my_point[::-1])\n",
    "\n",
    "        #loop through all edges' coordinates to find the closest by perp\n",
    "        cs_distances = []\n",
    "        my_distance_perp = 1000\n",
    "        my_key_perp = -1\n",
    "        for k in g[n0][n1]:\n",
    "            cs =  g[n0][n1][k]['coordinates']\n",
    "            for i in range(len(cs)-1):\n",
    "                if cs[i] == cs[i+1]:\n",
    "                    continue\n",
    "                cs_distances.append(distance_from_line(cs[i], cs[i+1], my_point[::-1]))\n",
    "            d = min(cs_distances)\n",
    "            if d < my_distance_perp:\n",
    "                my_distance_perp = d\n",
    "                my_key_perp = k\n",
    "\n",
    "\n",
    "        #for debugging\n",
    "        if (method == 'perp') | (my_distance_perp < my_distance_coord):\n",
    "            my_distance = my_distance_perp\n",
    "            my_key = my_key_perp\n",
    "        elif (method == 'coord') | (my_distance_coord <= my_distance_perp):\n",
    "            my_distance = my_distance_coord\n",
    "            my_key = my_key_coord\n",
    "\n",
    "        if my_distance < min_distance_to_coord_edge:\n",
    "            min_distance_to_coord_edge = my_distance\n",
    "            closest_edge = [n0, n1]\n",
    "            closest_edge_key = my_key\n",
    "\n",
    "    if return_distance:\n",
    "        return closest_edge, closest_edge_key, min_distance_to_coord_edge\n",
    "\n",
    "    return closest_edge, closest_edge_key\n",
    "\n",
    "print('finished')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#given two edge endnodes and a point, return the distance of the closest edge and that edge's key\n",
    "def distance_from_edge_coord(a,b,my_point):\n",
    "#a=65283442\n",
    "#b=65283457\n",
    "#my_point = my_point[::-1]\n",
    "\n",
    "    min_distance = 1000\n",
    "    min_key = -1\n",
    "\n",
    "    for k in g[a][b]:\n",
    "        path = get_path(a,b,k)\n",
    "        my_distances = [distance_points(c,my_point) for c in path]\n",
    "        my_distance = min(my_distances)\n",
    "        if my_distance < min_distance:\n",
    "            min_distance = my_distance\n",
    "            min_key = k\n",
    "    return min_distance, min_key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#returns array of coordinates for any edge in the graph\n",
    "def get_path(n0, n1, k=0):\n",
    "    \"\"\"If n0 and n1 are connected nodes in the graph, this function\n",
    "    return an array of point coordinates along the road linking\n",
    "    these two nodes.\"\"\"\n",
    "    return g[n0][n1][k]['coordinates']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished\n"
     ]
    }
   ],
   "source": [
    "#for a given point, find the edge it is closest to\n",
    "#first, find it's closest point on an infinite line defined by two nodes\n",
    "#use https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line#Line_defined_by_two_points\n",
    "#if that point IS NOT actually between the nodes, take the closest node\n",
    "\n",
    "def distance_from_line(p,q,x):\n",
    "\n",
    "#==Part 1===\n",
    "#p & q make a line; how far is x from this infinite line?\n",
    "\n",
    "#vertical traverse\n",
    "    a = p[1] - q[1]\n",
    "\n",
    "#horizontal traverse\n",
    "    b = q[0] - p[0]\n",
    "\n",
    "#ax+by+c = 0\n",
    "    c = -a * p[0] - b * p[1]\n",
    "\n",
    "    \n",
    "    \n",
    "#==Part 2== does this closest-line-point actually lie between nodes?\n",
    "#Ax + By + C = 0 ==> y = (-Ax - C)/B\n",
    "\n",
    "#first, calculate what the closest point is, holding x constant\n",
    "#second, calculate the distance between that closest point and the actual point\n",
    "#finally, check whether the closest point actually lies on the line between the edge's endpoints\n",
    "#if not, use the closest endpoint\n",
    "\n",
    "    if b == 0:\n",
    "# vertical line: ==> x = (-C - By) / A ==> x = -C / A\n",
    "#thus, ignore y and only take the distance between x and the latitude of our point\n",
    "    #print('vertical line')\n",
    "        dist =  abs(a*x[0] + c) / abs(a)\n",
    "        closest_y = x[1]\n",
    "\n",
    "# horizontal line: ==> y = (-Ax - C) / B ==> y = -C / B\n",
    "#thus, ignore x and only take the distance between y and longitude of our point\n",
    "    elif a == 0:\n",
    "    #print('horizontal line')\n",
    "        dist = abs(b* x[1] + c) / abs(b)\n",
    "        closest_y = -c / b\n",
    "    \n",
    "\n",
    "#not a vertical or horizontal line? proceed with full formula\n",
    "    elif a * b != 0:\n",
    "#distance = |Ax0 + By0 + C| / sqrt(a^2 + b^s)\n",
    "    #print('diagnoal line')\n",
    "        dist = abs(a*x[0] + b*x[1] + c) / (a**2 + b**2)**0.5\n",
    "        closest_y = (-1 * a * x[0] - c) / b\n",
    "    \n",
    "    else:\n",
    "        print('error!')\n",
    "        return\n",
    "\n",
    "#lat&lon must be constrained by nodes' lat/lons\n",
    "    p_x = distance_points(p, [x[0], closest_y])\n",
    "    q_x = distance_points(q, [x[0], closest_y])\n",
    "    p_q = distance_points(p,q)\n",
    "\n",
    "    error = 1e-10\n",
    "    if(abs(p_x + q_x - p_q) < error):\n",
    "        return dist\n",
    "    \n",
    "#print('closest point not on edge')\n",
    "    return min(distance_points(p,x), distance_points(q,x))\n",
    "\n",
    "print('finished')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#given two nodes anywhere on the graph, return all necessary intermediary nodes\n",
    "def connect_nodes(n0, n1):\n",
    "    return nx.shortest_path(sg_final, \n",
    "                        source=n0, \n",
    "                        target=n1,\n",
    "                        weight='length')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#take a node and an edge, orient the edge's endpoints toward the node and return the path connecting the two\n",
    "def connect_edge(my_node, my_edge):\n",
    "    closest, farthest = orient_edge_endpoints(my_node, my_edge)\n",
    "    \n",
    "    #if node is on edge, just return the other edge endpoint\n",
    "    if closest == my_node:\n",
    "        return [farthest]\n",
    "    \n",
    "    my_trio = connect_nodes(my_node, closest)[1:]\n",
    "    my_trio.extend([farthest])\n",
    "    return my_trio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished\n"
     ]
    }
   ],
   "source": [
    "'''orient edge endpoints\n",
    "    inputs: a node and an edge, in any orientation\n",
    "    outputs: two nodes (the edge's endpoints) in order of closest and farthest\n",
    "'''\n",
    "def orient_edge_endpoints(my_node, my_edge):\n",
    "\n",
    "    my_node_coordinate = pull_node_coordinate(my_node)\n",
    "    my_edge_coord_0 = pull_node_coordinate(my_edge[0])\n",
    "    my_edge_coord_1 = pull_node_coordinate(my_edge[1])\n",
    "\n",
    "    distance_0 = distance_points(my_node_coordinate, my_edge_coord_0)\n",
    "    distance_1 = distance_points(my_node_coordinate, my_edge_coord_1)\n",
    "\n",
    "    #if a tie, arbitrarily take the first point\n",
    "    if distance_0 <= distance_1:\n",
    "        return my_edge[0], my_edge[1]\n",
    "    if distance_1 < distance_0:\n",
    "        return my_edge[1], my_edge[0]\n",
    "\n",
    "print('finished')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#given two nodes, add their (default primary) edge to the map\n",
    "def plot_edge_gmap(n0, n1, my_map, color='purple', nodes=False, key=0):\n",
    "#check to make sure nodes aren't the same\n",
    "#n0=65309308\n",
    "#n1=65309306\n",
    "#my_map=gmplot.GoogleMapPlotter.from_geocode(\"San Francisco\")\n",
    "#color='red'\n",
    "#key = 0\n",
    "#nodes=False\n",
    "\n",
    "    if n0 != n1:\n",
    "        my_path = get_path(n0, n1, key)\n",
    "        my_lats = [c[1] for c in my_path]\n",
    "        my_lons = [c[0] for c in my_path]\n",
    "        my_map.plot(my_lats, my_lons, color, edge_width=5, alpha=0.4)\n",
    "\n",
    "        if nodes:\n",
    "            my_map.scatter(my_lats, my_lons, size=5, color=color, marker=False)\n",
    "\n",
    "#        my_map.draw('test plots/v5.2 multigraph kml.html')\n",
    "#        print('mapped')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/18/14\n",
      "guessing edge for (37.790574, -122.42795000000001), distance: 0.000320410190228\n",
      "guessing edge for (37.791354, -122.453839), distance: 0.000455783040488\n",
      "guessing edge for (37.792473, -122.454128), distance: 0.000606439815646\n",
      "guessing edge for (37.792567, -122.45431100000002), distance: 0.000693332568106\n",
      "guessing edge for (37.792516, -122.45470800000001), distance: 0.000452000929199\n",
      "guessing edge for (37.792355, -122.454772), distance: 0.000467101102546\n",
      "guessing edge for (37.79255, -122.45489000000002), distance: 0.000268131385692\n",
      "guessing edge for (37.792651, -122.45553399999999), distance: 0.000391190286157\n",
      "guessing edge for (37.793007, -122.455813), distance: 0.000457206845967\n",
      "guessing edge for (37.798933, -122.45908500000002), distance: 0.000256414118188\n",
      "guessing edge for (37.795788, -122.453356), distance: 0.000371052556929\n",
      "guessing edge for (37.793558, -122.451704), distance: 0.000329138284016\n",
      "guessing edge for (37.793372, -122.451071), distance: 0.000415465774767\n",
      "guessing edge for (37.793092, -122.450995), distance: 0.000675552966092\n",
      "guessing edge for (37.792906, -122.450684), distance: 0.000549898354245\n",
      "guessing edge for (37.792923, -122.45027699999999), distance: 0.000422242821137\n",
      "guessing edge for (37.793067, -122.45015900000001), distance: 0.000330461798086\n",
      "guessing edge for (37.793347, -122.45063099999999), distance: 0.000285295986646\n",
      "guessing edge for (37.79472, -122.45092), distance: 0.000587544423855\n",
      "guessing edge for (37.790574, -122.42795000000001), distance: 0.000320410190228\n",
      "plotted to test plots/v5 test_markers - 130.html\n"
     ]
    }
   ],
   "source": [
    "#130\n",
    "snap_kml(130)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[37.7926388, -122.455143],\n",
       " [37.7926453, -122.4551384],\n",
       " [37.7926867, -122.455095],\n",
       " [37.7927255, -122.4550743],\n",
       " [37.7928151, -122.4550864],\n",
       " [37.7929038, -122.4551098],\n",
       " [37.7929888, -122.4551324],\n",
       " [37.7930681, -122.4551647],\n",
       " [37.7931372, -122.4552294],\n",
       " [37.7931912, -122.4552956],\n",
       " [37.7932957, -122.4554444],\n",
       " [37.7933413, -122.4555011]]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a_map = gmplot.GoogleMapPlotter.from_geocode(\"San Francisco\")\n",
    "my_color = 'red'\n",
    "plot_edge_gmap(65309308, 65309306, a_map, my_color, key=0)\n",
    "a_map.draw('test plots/v5.2 multigraph kml.html')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "from    65309308\n",
       "key            0\n",
       "to      65309306\n",
       "Name: 99, dtype: int64"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "segments.iloc[71]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "my_path = get_path(n0,n1,key)\n",
    "my_lats = [c[1] for c in my_path]\n",
    "my_lons = [c[0] for c in my_path]\n",
    "my_map.plot(my_lats, my_lons, color, edge_width=5, alpha=0.4)\n",
    "my_map.draw('test plots/v5.2 multigraph kml.html')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(-122.4566826, 37.8017177),\n",
       " (-122.4566187, 37.8017135),\n",
       " (-122.4565576, 37.8017037),\n",
       " (-122.4564954, 37.8016883),\n",
       " (-122.4564359, 37.801669),\n",
       " (-122.4563565, 37.8016398),\n",
       " (-122.4561881, 37.8015711)]"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "65308182",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-153-d24da98b0056>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mget_path\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mn1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-16-ad50d0756b2d>\u001b[0m in \u001b[0;36mget_path\u001b[0;34m(n0, n1, k)\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0man\u001b[0m \u001b[0marray\u001b[0m \u001b[0mof\u001b[0m \u001b[0mpoint\u001b[0m \u001b[0mcoordinates\u001b[0m \u001b[0malong\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mroad\u001b[0m \u001b[0mlinking\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     these two nodes.\"\"\"\n\u001b[0;32m----> 6\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mg\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mn0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mn1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'coordinates'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 65308182"
     ]
    }
   ],
   "source": [
    "get_path(n0,n1,key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "segments = pd.DataFrame(data={'from': from_nodes[1:-1], 'to': to_nodes[1:], 'key': keys[1:]})\n",
    "segments = segments[segments['from'] != segments['to']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a_run = soup.find_all('placemark')[130]\n",
    "a_run_coords = a_run.coordinates.text.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#input a messy coord 'lon, lat, 0.0' and return the networkx node (lat, lon)\n",
    "def coord_to_node(c):\n",
    "    this_coord = c.split(',')\n",
    "    lat = float(this_coord[1])\n",
    "    lon = float(this_coord[0])\n",
    "    this_point = (lat, lon)\n",
    "    return this_point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'plot_closest_edge' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-e1ed3df054a3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mthis_point\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma_run_coords\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mplot_closest_edge\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthis_point\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'plot_closest_edge' is not defined"
     ]
    }
   ],
   "source": [
    "this_point = a_run_coords[20]\n",
    "plot_closest_edge(this_point)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mapped to test plots/v5 - closest edge.html\n"
     ]
    }
   ],
   "source": [
    "#def plot_closest_edge(my_point, color='purple'):\n",
    "this_point = a_run_coords[69]\n",
    "my_point = this_point\n",
    "color = 'blue'\n",
    "\n",
    "my_coord = coord_to_node(my_point)\n",
    "my_edge, my_edge_key = find_closest_edge(my_coord, 'all')\n",
    "\n",
    "my_map = gmplot.GoogleMapPlotter(my_coord[0], my_coord[1], 18)\n",
    "plot_edge_gmap(my_edge[0], my_edge[1], my_map, color, key = my_edge_key)\n",
    "\n",
    "my_map.scatter([my_coord[0]], [my_coord[1]], color='red', marker=False, size=5)\n",
    "\n",
    "my_map_file = 'test plots/v5 - closest edge.html'\n",
    "my_map.draw(my_map_file)\n",
    "print('mapped to ' + my_map_file)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "41.6258733755\n",
      "37.7936516 , -122.4503161\n",
      "37.7935466 , -122.450228\n",
      "37.7935164 , -122.4502137\n",
      "37.7934851 , -122.4502101\n",
      "37.7934564 , -122.4502183\n",
      "37.7934317 , -122.4502341\n",
      "37.7933396 , -122.4503458\n",
      "85.3602145105\n",
      "37.7933396 , -122.4503458\n",
      "37.7932633 , -122.4504527\n",
      "37.7932457 , -122.4505056\n",
      "37.7932436 , -122.450549\n",
      "37.793254 , -122.450585\n",
      "37.7932743 , -122.4506267\n",
      "37.793297 , -122.450646\n",
      "37.7933336 , -122.4506655\n",
      "37.7933726 , -122.4506693\n",
      "37.7934014 , -122.4506574\n",
      "37.7934316 , -122.4506296\n",
      "37.7936516 , -122.4503161\n"
     ]
    }
   ],
   "source": [
    "#https://www.darrinward.com/lat-long/\n",
    "for v in g[65283442][65283457].values():\n",
    "    print(v['length'])\n",
    "    for c in v['coordinates']:\n",
    "        print(c[1],',', c[0])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.000581416374042 65309510\n",
      "0.000285295986646 65283442\n",
      "0.00043811319313 65283457\n",
      "0.000810914181662 1769694191\n",
      "0.000534820063204 65316958\n"
     ]
    }
   ],
   "source": [
    "my_map = gmplot.GoogleMapPlotter(my_coord[0], my_coord[1], 18)\n",
    "\n",
    "thresh = 0.001\n",
    "for n in g.nodes_iter():\n",
    "    c = pull_node_coordinate(n)[::-1]\n",
    "    d = distance_points(c, my_coord)\n",
    "    if d < thresh:\n",
    "        my_map.scatter([c[0]], [c[1]], color='red', marker=False, size=d*20000)\n",
    "        print(d, n)\n",
    "        \n",
    "my_map_file = 'test plots/v5.2 - closest nodes.html'\n",
    "my_map.draw(my_map_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Plotting the full graph\n",
    "\"\"\"\n",
    "\n",
    "#plot said coordinates from ALL edges in Shapefile\n",
    "a_map = gmplot.GoogleMapPlotter.from_geocode(\"San Francisco\")\n",
    "\n",
    "plot_edge_gmap(65283442, 65283457, a_map, 'blue')\n",
    "    \n",
    "a_map.draw('test plots/v5 missing edge.html')\n",
    "print('finished')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#northeast \n",
    "g[65283457][65283442][0]['coordinates'] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'coordinate': (-122.4503161, 37.7936516),\n",
       " 'osmid': 65283457,\n",
       " 'x': -122.4503161,\n",
       " 'y': 37.7936516}"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.node[n1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65295762 65295797\n",
      "65295762 65295797\n",
      "65307109 2609017309\n",
      "65307109 2609017309\n",
      "4294017522 4294017571\n",
      "4294017522 4294017571\n",
      "302481936 302481931\n",
      "302481936 302481931\n",
      "1804730958 1804730952\n",
      "1804730958 1804730952\n",
      "1601995449 1601995499\n",
      "1601995449 1601995499\n",
      "890045139 890045140\n",
      "890045139 890045140\n",
      "1601995492 1602010328\n",
      "1601995492 1602010328\n",
      "1785845249 1366261132\n",
      "1785845249 1366261132\n",
      "65350487 65350510\n",
      "65350487 65350510\n",
      "4238705695 4238705696\n",
      "4238705695 4238705696\n",
      "315360356 315360357\n",
      "315360356 315360357\n",
      "2678063292 2678050676\n",
      "2678063292 2678050676\n",
      "1167787178 65375338\n",
      "1167787178 65375338\n",
      "65373362 300759134\n",
      "65373362 300759134\n",
      "3711403248 3454091822\n",
      "3711403248 3454091822\n",
      "3717633583 3718959234\n",
      "3717633583 3718959234\n",
      "4295558436 2875566805\n",
      "4295558436 2875566805\n",
      "4766860604 4766860616\n",
      "4766860604 4766860616\n",
      "2715003792 2715003792\n",
      "2715003792 2715003792\n",
      "65350551 1743527630\n",
      "65350551 1743527630\n",
      "830572057 65280690\n",
      "830572057 65280690\n",
      "866289290 386899314\n",
      "866289290 386899314\n",
      "1041008495 1041008463\n",
      "1041008495 1041008463\n",
      "826990704 826990688\n",
      "826990704 826990688\n",
      "1041008519 1041008458\n",
      "1041008519 1041008458\n",
      "1201407911 1201407935\n",
      "1201407911 1201407935\n",
      "1712523203 1712523441\n",
      "1712523203 1712523441\n",
      "1712523225 1711296870\n",
      "1712523225 1711296870\n",
      "702384203 702384206\n",
      "702384203 702384206\n",
      "4698998909 4698998910\n",
      "4698998909 4698998910\n",
      "1712523437 1712523293\n",
      "1712523437 1712523293\n",
      "2914847058 2914847063\n",
      "2914847058 2914847063\n",
      "2914847067 2914847062\n",
      "2914847067 2914847062\n",
      "3931507133 65317148\n",
      "3931507133 65317148\n",
      "1701772836 1293498475\n",
      "1701772836 1293498475\n",
      "258869953 2179309293\n",
      "258869953 2179309293\n",
      "2282794104 2282794109\n",
      "2282794104 2282794109\n",
      "4548594391 4548575787\n",
      "4548594391 4548575787\n",
      "4761684714 4761684715\n",
      "4761684714 4761684715\n",
      "4387362603 4387362603\n",
      "4387362603 4387362603\n",
      "4070607657 4070609048\n",
      "4070607657 4070609048\n",
      "315362130 315362134\n",
      "315362130 315362134\n",
      "369181167 369181099\n",
      "369181167 369181099\n",
      "702385073 702389611\n",
      "702385073 702389611\n",
      "2382859186 1130730619\n",
      "2382859186 1130730619\n",
      "1402388982 1402389008\n",
      "1402388982 1402389008\n",
      "2653211630 2653213873\n",
      "2653211630 2653213873\n",
      "4548575767 4548575777\n",
      "4548575767 4548575777\n",
      "4162849942 4162849950\n",
      "4162849942 4162849950\n",
      "2643102888 2643102888\n",
      "2643102888 2643102888\n",
      "65375557 4151994143\n",
      "65375557 4151994143\n",
      "2678037417 2678037418\n",
      "2678037417 2678037418\n",
      "65334525 65334525\n",
      "65334525 65334525\n",
      "3506245663 3506245680\n",
      "3506245663 3506245680\n",
      "300453989 300453995\n",
      "300453989 300453995\n",
      "4069158251 4069158229\n",
      "4069158251 4069158229\n",
      "2726269066 3428243925\n",
      "2726269066 3428243925\n",
      "331387080 331387077\n",
      "331387080 331387077\n",
      "280924398 280924401\n",
      "280924398 280924401\n",
      "65311179 297838768\n",
      "65311179 297838768\n",
      "827318979 827319005\n",
      "827318979 827319005\n",
      "1714229778 615144108\n",
      "1714229778 615144108\n",
      "3722628270 3722628255\n",
      "3722628270 3722628255\n",
      "3859911457 3859911486\n",
      "3859911457 3859911486\n",
      "4295220606 4295220600\n",
      "4295220606 4295220600\n",
      "3447483904 3447483907\n",
      "3447483904 3447483907\n",
      "827331754 827331766\n",
      "827331754 827331766\n",
      "2249856333 2249856383\n",
      "2249856333 2249856383\n",
      "1201411453 1201411456\n",
      "1201411453 1201411456\n",
      "1769694124 65326577\n",
      "1769694124 65326577\n",
      "367051685 367051688\n",
      "367051685 367051688\n",
      "702387687 702390474\n",
      "702387687 702390474\n",
      "1602066730 1602066733\n",
      "1602066730 1602066733\n",
      "4234516304 2875566743\n",
      "4234516304 2875566743\n",
      "360879954 360880062\n",
      "360879954 360880062\n",
      "1229920535 1229920746\n",
      "1229920535 1229920746\n",
      "3885158696 3752734678\n",
      "3885158696 3752734678\n",
      "1819433425 4210751651\n",
      "1819433425 4210751651\n",
      "268147028 268147029\n",
      "268147028 268147029\n",
      "1201412723 1201412720\n",
      "1201412723 1201412720\n",
      "3527121588 3527121583\n",
      "3527121588 3527121583\n",
      "65313489 3117917460\n",
      "65313489 3117917460\n",
      "4071190309 4071190586\n",
      "4071190309 4071190586\n",
      "1201412846 1201412844\n",
      "1201412846 1201412844\n",
      "3998587696 3998587697\n",
      "3998587696 3998587697\n",
      "3998587696 3344709644\n",
      "3998587696 3344709644\n",
      "3859911054 3859911055\n",
      "3859911054 3859911055\n",
      "3584465769 3584465769\n",
      "3584465769 3584465769\n",
      "4438400183 4438403857\n",
      "4438400183 4438403857\n",
      "3003882745 3003882746\n",
      "3003882745 3003882746\n",
      "4045348129 2701110280\n",
      "4045348129 2701110280\n",
      "65346922 293759027\n",
      "65346922 293759027\n",
      "2638978411 2908408465\n",
      "2638978411 2908408465\n",
      "343514503 343514503\n",
      "343514503 343514503\n",
      "364486031 364492692\n",
      "364486031 364492692\n",
      "65280384 3117933952\n",
      "65280384 3117933952\n",
      "2641796575 2641796581\n",
      "2641796575 2641796581\n",
      "1250280701 1250280484\n",
      "1250280701 1250280484\n",
      "2641796609 2641796612\n",
      "2641796609 2641796612\n",
      "65281560 65281563\n",
      "65281560 65281563\n",
      "2502204982 2502204982\n",
      "2502204982 2502204982\n",
      "65347132 65318497\n",
      "65347132 65318497\n",
      "1602001523 1602010325\n",
      "1602001523 1602010325\n",
      "4023087053 65295743\n",
      "4023087053 65295743\n",
      "2179309306 2179309306\n",
      "2179309306 2179309306\n",
      "1094164266 1094164300\n",
      "1094164266 1094164300\n",
      "65301581 65299446\n",
      "65301581 65299446\n",
      "2179309448 2179309448\n",
      "2179309448 2179309448\n",
      "3885395949 3885395944\n",
      "3885395949 3885395944\n",
      "3562971075 3562971059\n",
      "3562971075 3562971059\n",
      "3462373344 3462373344\n",
      "3462373344 3462373344\n",
      "65282051 65282049\n",
      "65282051 65282049\n",
      "3101230899 633119937\n",
      "3101230899 633119937\n",
      "828416136 828416136\n",
      "828416136 828416136\n",
      "315072838 315072844\n",
      "315072838 315072844\n",
      "315415386 315415367\n",
      "315415386 315415367\n",
      "1041015136 1041015150\n",
      "1041015136 1041015150\n",
      "65348048 65347976\n",
      "65348048 65347976\n",
      "4361232985 4361233096\n",
      "4361232985 4361233096\n",
      "4289372818 4289372819\n",
      "4289372818 4289372819\n",
      "4770323232 4770323229\n",
      "4770323232 4770323229\n",
      "65348353 65348355\n",
      "65348353 65348355\n",
      "65283028 65283028\n",
      "65283028 65283028\n",
      "4124474163 4124474163\n",
      "4124474163 4124474163\n",
      "370202157 370202141\n",
      "370202157 370202141\n",
      "4045183851 346519585\n",
      "4045183851 346519585\n",
      "3516015825 3516015826\n",
      "3516015825 3516015826\n",
      "610182413 610182409\n",
      "610182413 610182409\n",
      "3344714435 3344714436\n",
      "3344714435 3344714436\n",
      "2686068149 2686068164\n",
      "2686068149 2686068164\n",
      "65283675 65286358\n",
      "65283675 65286358\n",
      "4271220381 4271224904\n",
      "4271220381 4271224904\n",
      "2958796484 258660024\n",
      "2958796484 258660024\n",
      "3368920798 3368920805\n",
      "3368920798 3368920805\n",
      "272538579 65352423\n",
      "272538579 65352423\n",
      "310978387 310978024\n",
      "310978387 310978024\n",
      "3860244355 3860247564\n",
      "3860244355 3860247564\n",
      "300459937 300459940\n",
      "300459937 300459940\n",
      "1308556629 1308556674\n",
      "1308556629 1308556674\n",
      "3749921979 3749921973\n",
      "3749921979 3749921973\n",
      "1268623487 1268623521\n",
      "1268623487 1268623521\n",
      "65349778 65349771\n",
      "65349778 65349771\n",
      "4702185731 4702185727\n",
      "4702185731 4702185727\n",
      "310978898 4527785866\n",
      "310978898 4527785866\n",
      "581074040 581074036\n",
      "581074040 581074036\n",
      "2365086989 2365087054\n",
      "2365086989 2365087054\n",
      "1723738831 3102328772\n",
      "1723738831 3102328772\n",
      "1563110124 1563110124\n",
      "1563110124 1563110124\n",
      "300722989 300723029\n",
      "300722989 300723029\n",
      "300722989 300723029\n",
      "3687459640 3687459647\n",
      "3687459640 3687459647\n",
      "684998736 684998735\n",
      "684998736 684998735\n",
      "1616423803 1616423809\n",
      "1616423803 1616423809\n",
      "4032342950 259669114\n",
      "4032342950 259669114\n",
      "4069457602 4069457593\n",
      "4069457602 4069457593\n",
      "65318046 2265957510\n",
      "65318046 2265957510\n",
      "65285435 65285441\n",
      "65285435 65285441\n",
      "3449466206 359985246\n",
      "3449466206 359985246\n",
      "65318252 65318254\n",
      "65318252 65318254\n",
      "65285504 65282140\n",
      "65285504 65282140\n",
      "65285648 65285650\n",
      "65285648 65285650\n",
      "65285655 65285673\n",
      "65285655 65285673\n",
      "302493276 708533557\n",
      "302493276 708533557\n",
      "65285743 65285748\n",
      "65285743 65285748\n",
      "2701110942 2701110952\n",
      "2701110942 2701110952\n",
      "3722628508 3722628278\n",
      "3722628508 3722628278\n",
      "2477311946 2477311941\n",
      "2477311946 2477311941\n",
      "1727334375 3925261679\n",
      "1727334375 3925261679\n",
      "275427247 275427263\n",
      "275427247 275427263\n",
      "3989403052 3989403040\n",
      "3989403052 3989403040\n",
      "65351660 4027454275\n",
      "65351660 4027454275\n",
      "1593395216 1593395185\n",
      "1593395216 1593395185\n",
      "293820742 293820802\n",
      "293820742 293820802\n",
      "293820742 293820802\n",
      "4070650028 4070650028\n",
      "4070650028 4070650028\n",
      "4037489029 4387363209\n",
      "4037489029 4387363209\n",
      "581251562 581251562\n",
      "581251562 581251562\n",
      "65307835 65322923\n",
      "65307835 65322923\n",
      "761541238 761541252\n",
      "761541238 761541252\n",
      "281555621 281555676\n",
      "281555621 281555676\n",
      "1196897039 1196897039\n",
      "1196897039 1196897039\n",
      "615143784 615143772\n",
      "615143784 615143772\n",
      "297382763 1417636085\n",
      "297382763 1417636085\n",
      "65287088 65287089\n",
      "65287088 65287089\n",
      "1809560873 1809560873\n",
      "1809560873 1809560873\n",
      "764886899 764886902\n",
      "764886899 764886902\n",
      "4087559516 4087559518\n",
      "4087559516 4087559518\n",
      "2282680205 2449852790\n",
      "2282680205 2449852790\n",
      "3527029683 3527029687\n",
      "3527029683 3527029687\n",
      "2356786800 2356786815\n",
      "2356786800 2356786815\n",
      "2179292783 2179292793\n",
      "2179292783 2179292793\n",
      "1777579912 1777579942\n",
      "1777579912 1777579942\n",
      "65288088 65288096\n",
      "65288088 65288096\n",
      "2914847045 2914847049\n",
      "2914847045 2914847049\n",
      "2295478367 298940383\n",
      "2295478367 298940383\n",
      "1602075015 1602075032\n",
      "1602075015 1602075032\n",
      "430971776 430971776\n",
      "430971776 430971776\n",
      "65288792 65288786\n",
      "65288792 65288786\n",
      "3344710356 3344710356\n",
      "3344710356 3344710356\n",
      "65321692 65321696\n",
      "65321692 65321696\n",
      "2506767114 2506767120\n",
      "2506767114 2506767120\n",
      "4759501648 4759501649\n",
      "4759501648 4759501649\n",
      "4614536062 4770323234\n",
      "4614536062 4770323234\n",
      "65289222 4139777609\n",
      "65289222 4139777609\n",
      "65354788 65354799\n",
      "65354788 65354799\n",
      "367017015 367017018\n",
      "367017015 367017018\n",
      "259669701 1350854608\n",
      "259669701 1350854608\n",
      "65355474 65355467\n",
      "65355474 65355467\n",
      "1840603101 259751733\n",
      "1840603101 259751733\n",
      "369180557 369181182\n",
      "369180557 369181182\n",
      "1261518764 1261518753\n",
      "1261518764 1261518753\n",
      "315414612 315414598\n",
      "315414612 315414598\n",
      "2795389094 2795386949\n",
      "2795389094 2795386949\n",
      "2642755852 2642755858\n",
      "2642755852 2642755858\n",
      "4044866236 2179292638\n",
      "4044866236 2179292638\n",
      "4207307568 4207307553\n",
      "4207307568 4207307553\n",
      "65323843 65323843\n",
      "65323843 65323843\n",
      "2992133407 2992133400\n",
      "2992133407 2992133400\n",
      "272516190 272516190\n",
      "272516190 272516190\n",
      "1250280769 1250280769\n",
      "1250280769 1250280769\n",
      "1350854538 1350854600\n",
      "1350854538 1350854600\n",
      "2553955707 2553955709\n",
      "2553955707 2553955709\n",
      "2875573779 2875573798\n",
      "2875573779 2875573798\n",
      "65324578 65298921\n",
      "65324578 65298921\n",
      "65371295 65371295\n",
      "65371295 65371295\n",
      "1593395168 316735419\n",
      "1593395168 316735419\n",
      "695257183 4295226666\n",
      "695257183 4295226666\n",
      "3768240345 3768240350\n",
      "3768240345 3768240350\n",
      "4112599314 4112599318\n",
      "4112599314 4112599318\n",
      "3951020319 3951020319\n",
      "3951020319 3951020319\n",
      "1506920756 65335731\n",
      "1506920756 65335731\n",
      "2286930486 2286930491\n",
      "2286930486 2286930491\n",
      "3951184467 4294010366\n",
      "3951184467 4294010366\n",
      "4505979600 263576054\n",
      "4505979600 263576054\n",
      "4702686362 4702686363\n",
      "4702686362 4702686363\n",
      "3716467623 3716467623\n",
      "3716467623 3716467623\n",
      "4702555329 4702555330\n",
      "4702555329 4702555330\n",
      "358862071 323545679\n",
      "358862071 323545679\n",
      "763645243 763645243\n",
      "763645243 763645243\n",
      "322653582 322655245\n",
      "322653582 322655245\n",
      "334220690 334220690\n",
      "334220690 334220690\n",
      "65359312 65359314\n",
      "65359312 65359314\n",
      "65359312 65336947\n",
      "65359312 65336947\n",
      "4094610913 4094610916\n",
      "4094610913 4094610916\n",
      "65359518 2317961406\n",
      "65359518 2317961406\n",
      "2317635340 65332103\n",
      "2317635340 65332103\n",
      "633687894 633687895\n",
      "633687894 633687895\n",
      "633687894 633687895\n",
      "65357529 4022986140\n",
      "65357529 4022986140\n",
      "65327025 65326982\n",
      "65327025 65326982\n",
      "4575416321 4575416327\n",
      "4575416321 4575416327\n",
      "2245808290 2245808290\n",
      "2245808290 2245808290\n",
      "1152536860 4022986135\n",
      "1152536860 4022986135\n",
      "2912242134 2912242135\n",
      "2912242134 2912242135\n",
      "3393386579 3393387590\n",
      "3393386579 3393387590\n",
      "315417350 315417344\n",
      "315417350 315417344\n",
      "3953107731 663835327\n",
      "3953107731 663835327\n",
      "4702556860 4702556857\n",
      "4702556860 4702556857\n",
      "4184888015 4184888023\n",
      "4184888015 4184888023\n",
      "65361593 65361600\n",
      "65361593 65361600\n",
      "4367088269 4367088268\n",
      "4367088269 4367088268\n",
      "65295645 65295619\n",
      "65295645 65295619\n",
      "65295850 65295853\n",
      "65295850 65295853\n",
      "315414112 315414112\n",
      "315414112 315414112\n",
      "4604253217 4604253217\n",
      "4604253217 4604253217\n",
      "3831814109 3831814109\n",
      "3831814109 3831814109\n",
      "4770323225 4770323228\n",
      "4770323225 4770323228\n",
      "423778271 423778269\n",
      "423778271 423778269\n",
      "2875480081 2875480082\n",
      "2875480081 2875480082\n",
      "1207466331 1207466232\n",
      "1207466331 1207466232\n",
      "65296629 4023019281\n",
      "65296629 4023019281\n",
      "4783986942 4783986948\n",
      "4783986942 4783986948\n",
      "1991825921 1991825925\n",
      "1991825921 1991825925\n",
      "1837716958 1837716958\n",
      "1837716958 1837716958\n",
      "4770323152 4770323153\n",
      "4770323152 4770323153\n",
      "65283205 65283205\n",
      "65283205 65283205\n",
      "65297394 4295140705\n",
      "65297394 4295140705\n",
      "267967742 267967742\n",
      "267967742 267967742\n",
      "4387364212 4387364211\n",
      "4387364212 4387364211\n",
      "999546371 999546737\n",
      "999546371 999546737\n",
      "999546514 999546898\n",
      "999546514 999546898\n",
      "3834699455 3834699857\n",
      "3834699455 3834699857\n",
      "4770323287 2085322417\n",
      "4770323287 2085322417\n",
      "295505887 1511324892\n",
      "295505887 1511324892\n",
      "3924221837 3924221845\n",
      "3924221837 3924221845\n",
      "3924221855 3924223859\n",
      "3924221855 3924223859\n",
      "392814499 392814506\n",
      "392814499 392814506\n",
      "3896059688 3896059688\n",
      "3896059688 3896059688\n",
      "1622598058 1622598076\n",
      "1622598058 1622598076\n",
      "315351488 315351501\n",
      "315351488 315351501\n",
      "2679923297 2679923300\n",
      "2679923297 2679923300\n",
      "768238240 768238246\n",
      "768238240 768238246\n",
      "65283528 298938962\n",
      "65283528 298938962\n",
      "1723633798 4406691712\n",
      "1723633798 4406691712\n",
      "423748901 423749082\n",
      "423748901 423749082\n",
      "4419708251 4419708276\n",
      "4419708251 4419708276\n",
      "4022986161 4022986116\n",
      "4022986161 4022986116\n",
      "1111549576 1111549576\n",
      "1111549576 1111549576\n",
      "4066142103 4066142106\n",
      "4066142103 4066142106\n",
      "2430276002 2430276023\n",
      "2430276002 2430276023\n",
      "2613275179 2613275175\n",
      "2613275179 2613275175\n",
      "599157334 599157340\n",
      "599157334 599157340\n",
      "469718221 469718221\n",
      "469718221 469718221\n",
      "2626529057 2626529064\n",
      "2626529057 2626529064\n",
      "4634241760 4634241774\n",
      "4634241760 4634241774\n",
      "2626529064 2626529066\n",
      "2626529064 2626529066\n",
      "2724724683 2724724692\n",
      "2724724683 2724724692\n",
      "3447483916 3447483918\n",
      "3447483916 3447483918\n",
      "4567789347 4567789347\n",
      "4567789347 4567789347\n",
      "3542904625 3542904640\n",
      "3542904625 3542904640\n",
      "1350266716 1350266756\n",
      "1350266716 1350266756\n",
      "315420640 315420657\n",
      "315420640 315420657\n",
      "65368256 65368298\n",
      "65368256 65368298\n",
      "3833123535 3833123543\n",
      "3833123535 3833123543\n",
      "3753049472 3753049472\n",
      "3753049472 3753049472\n",
      "1840705954 259751741\n",
      "1840705954 259751741\n",
      "65303011 65303047\n",
      "65303011 65303047\n",
      "1711315194 1711315218\n",
      "1711315194 1711315218\n",
      "4719866641 4719866641\n",
      "4719866641 4719866641\n",
      "65369057 65369062\n",
      "65369057 65369062\n",
      "65323679 65305099\n",
      "65323679 65305099\n",
      "3716475845 3716475845\n",
      "3716475845 3716475845\n",
      "1201411592 1201411595\n",
      "1201411592 1201411595\n",
      "65357518 65357521\n",
      "65357518 65357521\n",
      "4140530847 4140530829\n",
      "4140530847 4140530829\n",
      "315358898 315358902\n",
      "315358898 315358902\n",
      "263576149 263576149\n",
      "263576149 263576149\n",
      "3454073849 3454073852\n",
      "3454073849 3454073852\n",
      "2020113650 2020113663\n",
      "2020113650 2020113663\n",
      "3102310141 3102310141\n",
      "3102310141 3102310141\n",
      "1201405888 1201405889\n",
      "1201405888 1201405889\n"
     ]
    }
   ],
   "source": [
    "#do any edges have multiple keys?\n",
    "for a,b in g.edges_iter():\n",
    "    l = len(g[a][b].keys())\n",
    "    if l > 1:\n",
    "        print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: {'coordinates': [(-122.4818602, 37.7883204), (-122.4805385, 37.7882526)],\n",
       "  'highway': 'service',\n",
       "  'length': 116.38921357890044,\n",
       "  'oneway': False,\n",
       "  'osmid': 28690801,\n",
       "  'service': 'parking_aisle'},\n",
       " 1: {'geometry': <shapely.geometry.linestring.LineString at 0x166ca0c57f0>,\n",
       "  'highway': 'service',\n",
       "  'length': 153.46396511852544,\n",
       "  'oneway': False,\n",
       "  'osmid': 28690803,\n",
       "  'service': 'parking_aisle'}}"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g[315360356][315360357]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "GDAL",
   "language": "python",
   "name": "gdal"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}