exploration_trajectory_timestamp_predict_time_not_distance.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for reading and validating data\n",
    "import emeval.input.spec_details as eisd\n",
    "import emeval.input.phone_view as eipv\n",
    "import emeval.input.eval_view as eiev"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualization helpers\n",
    "import emeval.viz.phone_view as ezpv\n",
    "import emeval.viz.eval_view as ezev\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For computation\n",
    "import numpy as np\n",
    "import math\n",
    "import scipy.stats as stats\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import geopandas as gpd\n",
    "import shapely as shp\n",
    "import scipy.interpolate as spi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import arrow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R = 6371000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATASTORE_URL = \"http://cardshark.cs.berkeley.edu\"\n",
    "AUTHOR_EMAIL = \"shankari@eecs.berkeley.edu\"\n",
    "sd_la = eisd.SpecDetails(DATASTORE_URL, AUTHOR_EMAIL, \"unimodal_trip_car_bike_mtv_la\")\n",
    "sd_sj = eisd.SpecDetails(DATASTORE_URL, AUTHOR_EMAIL, \"car_scooter_brex_san_jose\")\n",
    "sd_ucb = eisd.SpecDetails(DATASTORE_URL, AUTHOR_EMAIL, \"train_bus_ebike_mtv_ucb\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import importlib\n",
    "importlib.reload(ezpv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pv_la = eipv.PhoneView(sd_la)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pv_sj = eipv.PhoneView(sd_sj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pv_ucb = eipv.PhoneView(sd_ucb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experimenting with creating temporal reference trajectories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  `shapely.interp1d`: Easy case (timestamp based)\n",
    "\n",
    "Proposed algorithm:\n",
    "- filter out points that are too far away from the spatial ground truth\n",
    "- Next try two approaches:\n",
    "    - map ts -> lat, and ts -> lng *for the filtered points only* for trajectories\n",
    "        - or parts of trajectories (?) that have a reasonable density of filtered points\n",
    "        - reconstitute reference trajectories for new timestamps based on the new functions\n",
    "        - if both trajectories are sufficiently dense, can take mean? can pick one?\n",
    "    - for the remaining points, map (lat,lng) -> ts *for the filtered points only* \n",
    "    - for the remaining points, map distance along line -> ts *for the filtered points only* \n",
    "        - and do the same things for both"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_trip = pv_la.map()[\"android\"][\"ucb-sdb-android-1\"][\"evaluation_ranges\"][1][\"evaluation_trip_ranges\"][0][\"evaluation_section_ranges\"][1]\n",
    "ios_trip = pv_la.map()[\"ios\"][\"ucb-sdb-ios-1\"][\"evaluation_ranges\"][1][\"evaluation_trip_ranges\"][0][\"evaluation_section_ranges\"][1]\n",
    "android_accuracy_df = android_trip[\"location_df\"]\n",
    "ios_accuracy_df = ios_trip[\"location_df\"]\n",
    "gt_leg = sd_la.get_ground_truth_for_leg(android_trip[\"trip_id_base\"], ios_trip[\"trip_id_base\"])\n",
    "gt_linestring = shp.geometry.LineString(coordinates=gt_leg[\"route_coords\"][\"geometry\"][\"coordinates\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_control_gpdf = gpd.GeoDataFrame(\n",
    "        android_accuracy_df, geometry=android_accuracy_df.apply(lambda lr: shp.geometry.Point(lr.longitude, lr.latitude), axis=1))\n",
    "ios_control_gpdf = gpd.GeoDataFrame(\n",
    "        ios_accuracy_df, geometry=ios_accuracy_df.apply(lambda lr: shp.geometry.Point(lr.longitude, lr.latitude), axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_gt_distances = android_control_gpdf.distance(gt_linestring) * (R / 360)\n",
    "ios_gt_distances = ios_control_gpdf.distance(gt_linestring) * (R / 360)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_android_control_gpdf = android_control_gpdf[android_gt_distances <= 5]\n",
    "filtered_ios_control_gpdf = ios_control_gpdf[ios_gt_distances <= 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(filtered_android_control_gpdf)/len(android_control_gpdf), len(filtered_ios_control_gpdf)/len(ios_control_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax_array = plt.subplots(nrows=1, ncols=2, figsize=(20,20))\n",
    "android_control_gpdf.plot(ax=ax_array[0])\n",
    "filtered_android_control_gpdf.plot(ax=ax_array[0])\n",
    "ios_control_gpdf.plot(ax=ax_array[1])\n",
    "filtered_ios_control_gpdf.plot(ax=ax_array[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "len(android_control_gpdf), len(ios_control_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.interpolate as sci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_lat_fn = sci.interp1d(x=filtered_android_control_gpdf.ts, y=filtered_android_control_gpdf.latitude, fill_value=\"extrapolate\")\n",
    "android_lon_fn = sci.interp1d(x=filtered_android_control_gpdf.ts, y=filtered_android_control_gpdf.longitude, fill_value=\"extrapolate\")\n",
    "ios_lat_fn = sci.interp1d(x=filtered_ios_control_gpdf.ts, y=filtered_ios_control_gpdf.latitude, fill_value=\"extrapolate\")\n",
    "ios_lon_fn = sci.interp1d(x=filtered_ios_control_gpdf.ts, y=filtered_ios_control_gpdf.longitude, fill_value=\"extrapolate\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_ts_range = np.arange(android_trip[\"start_ts\"], android_trip[\"end_ts\"], 1)\n",
    "new_fmt_time_range = [arrow.get(ts).to(sd_la.eval_tz) for ts in new_ts_range]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_lat = android_lat_fn(new_ts_range)\n",
    "new_android_lng = android_lon_fn(new_ts_range)\n",
    "new_ios_lat = ios_lat_fn(new_ts_range)\n",
    "new_ios_lng = ios_lon_fn(new_ts_range)\n",
    "new_android_gpdf = gpd.GeoDataFrame({\n",
    "    \"latitude\": new_android_lat,\n",
    "    \"longitude\": new_android_lng,\n",
    "    \"ts\": new_ts_range,\n",
    "    \"fmt_time\": new_fmt_time_range,\n",
    "    \"geometry\": [shp.geometry.Point(x, y) for x, y in zip(new_android_lng, new_android_lat)]\n",
    "})\n",
    "new_ios_gpdf = gpd.GeoDataFrame({\n",
    "    \"latitude\": new_ios_lat,\n",
    "    \"longitude\": new_ios_lng,\n",
    "    \"ts\": new_ts_range,\n",
    "    \"fmt_time\": new_fmt_time_range,\n",
    "    \"geometry\": [shp.geometry.Point(x, y) for x, y in zip(new_ios_lng, new_ios_lat)]\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_gpdf[[\"fmt_time\", \"geometry\"]].head(), new_ios_gpdf[[\"fmt_time\", \"geometry\"]].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "distances = new_android_gpdf.distance(gt_linestring) * (R/360); distances.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_mask = distances <= 2; np.nonzero(np.logical_not(valid_mask))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_new_android_gpdf = new_android_gpdf[new_android_gpdf.distance(gt_linestring) * (R/360) <= 5]; filtered_new_android_gpdf.head()\n",
    "filtered_new_ios_gpdf = new_ios_gpdf[new_android_gpdf.distance(gt_linestring) * (R/360) <= 5]; filtered_new_ios_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax_array = plt.subplots(nrows=1, ncols=2, figsize=(20,20))\n",
    "new_android_gpdf.plot(ax=ax_array[0])\n",
    "filtered_new_android_gpdf.plot(ax=ax_array[0])\n",
    "new_ios_gpdf.plot(ax=ax_array[1])\n",
    "filtered_new_ios_gpdf.plot(ax=ax_array[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NAN = float(\"nan\")\n",
    "merged_gpdf = pd.merge(filtered_new_android_gpdf, filtered_new_ios_gpdf, on=\"ts\", how=\"outer\", suffixes=(\"_a\", \"_i\")); merged_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_row(loc_row):\n",
    "    # print(\"merging %s\" % loc_row)\n",
    "    if pd.isnull(loc_row.geometry_i):\n",
    "        assert not np.isnull(loc_row.geometry_a)\n",
    "        final_geom = loc_row.geometry_a\n",
    "    elif pd.isnull(loc_row.geometry_a):\n",
    "        assert not pd.isnull(loc_row.geometry_i)\n",
    "        final_geom = loc_row.geometry_i\n",
    "    else:\n",
    "        assert not pd.isnull(loc_row.geometry_i) and not pd.isnull(loc_row.geometry_a)\n",
    "        midpoint = shp.geometry.LineString(coordinates=[loc_row.geometry_a, loc_row.geometry_i]).interpolate(0.5, normalized=True)\n",
    "        # print(midpoint)\n",
    "        final_geom = midpoint\n",
    "    return {\n",
    "        \"ts\": loc_row.ts,\n",
    "        \"fmt_time\": arrow.get(loc_row.ts).to(\"America/Los_Angeles\"),\n",
    "        \"longitude\": final_geom.x,\n",
    "        \"latitude\": final_geom.y,\n",
    "        \"geometry\": final_geom\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reference_gpdf = gpd.GeoDataFrame(data=list(merged_gpdf.apply(merge_row, axis=1))); reference_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_ratio = len(filtered_new_android_gpdf)/len(new_android_gpdf)\n",
    "assert valid_ratio == len(filtered_new_ios_gpdf)/len(new_ios_gpdf)\n",
    "valid_ratio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import geojson as gj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import folium"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "curr_map = folium.Map()\n",
    "gt_leg_gj = sd_ucb.get_geojson_for_leg(gt_leg)\n",
    "sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(filtered_new_android_gpdf.longitude, new_android_gpdf.latitude))),properties={\"style\": {\"color\": \"red\"}, \"ts\": list(new_android_gpdf.ts)})\n",
    "old_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(android_control_gpdf.longitude, android_control_gpdf.latitude))),properties={\"style\": {\"color\": \"yellow\"}, \"ts\": list(android_control_gpdf.ts)})\n",
    "filtered_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(reference_gpdf.longitude, reference_gpdf.latitude))),properties={\"style\": {\"color\": \"blue\"}, \"ts\": list(reference_gpdf.ts)})\n",
    "gt_leg_gj_feature = folium.GeoJson(gt_leg_gj, name=\"ground_truth\")\n",
    "gt_leg_gj_points = ezpv.get_point_markers(gt_leg_gj[2], name=\"ground_truth_points\", color=\"green\")\n",
    "sensed_leg_gj_feature = folium.GeoJson(sensed_section_gj, name=\"sensed_values\")\n",
    "old_sensed_leg_gj_feature = folium.GeoJson(old_sensed_section_gj, name=\"old sensed_values\")\n",
    "filtered_sensed_leg_gj_feature = folium.GeoJson(filtered_sensed_section_gj, name=\"filtered sensed_values\")\n",
    "sensed_leg_gj_points = ezpv.get_point_markers(sensed_section_gj, name=\"sensed_points\", color=\"red\", tz=\"America/Los_Angeles\")\n",
    "old_sensed_leg_gj_points = ezpv.get_point_markers(old_sensed_section_gj, name=\"old_sensed_points\", color=\"yellow\", tz=\"America/Los_Angeles\")\n",
    "filtered_sensed_leg_gj_points = ezpv.get_point_markers(filtered_sensed_section_gj, name=\"filtered_sensed_points\", color=\"blue\", tz=\"America/Los_Angeles\")\n",
    "curr_map.add_child(gt_leg_gj_feature)\n",
    "curr_map.add_child(gt_leg_gj_points)\n",
    "curr_map.add_child(sensed_leg_gj_feature)\n",
    "curr_map.add_child(sensed_leg_gj_points)\n",
    "curr_map.add_child(old_sensed_leg_gj_feature)\n",
    "curr_map.add_child(old_sensed_leg_gj_points)\n",
    "curr_map.add_child(filtered_sensed_leg_gj_feature)\n",
    "curr_map.add_child(filtered_sensed_leg_gj_points)\n",
    "curr_map.fit_bounds(sensed_leg_gj_feature.get_bounds())\n",
    "folium.LayerControl().add_to(curr_map)\n",
    "curr_map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  `shapely.interp1d`: Hard case (android locations are just really messed up)\n",
    "\n",
    "- Works poorly with tolerance = 2m (25% valid ratio)\n",
    "- Increasing tolerance to 5m bumps up the valid ratio to 50%, but then it introduces points that are not really close enough to ground truth (e.g. around loc 219)\n",
    "- Increasing tolerance to 10m bumps up the valid ratio to 63%, but then it makes the ground truth even worse (e.g. around loc 250-268 and 390-393)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_trip = pv_la.map()[\"android\"][\"ucb-sdb-android-1\"][\"evaluation_ranges\"][0][\"evaluation_trip_ranges\"][0]\n",
    "ios_trip = pv_la.map()[\"ios\"][\"ucb-sdb-ios-1\"][\"evaluation_ranges\"][0][\"evaluation_trip_ranges\"][0]\n",
    "android_accuracy_df = android_trip[\"location_df\"]\n",
    "ios_accuracy_df = ios_trip[\"location_df\"]\n",
    "gt_leg = sd_la.get_ground_truth_for_leg(android_trip[\"trip_id_base\"], ios_trip[\"trip_id_base\"])\n",
    "gt_linestring = shp.geometry.LineString(coordinates=gt_leg[\"route_coords\"][\"geometry\"][\"coordinates\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_control_gpdf = gpd.GeoDataFrame(\n",
    "        android_accuracy_df, geometry=android_accuracy_df.apply(lambda lr: shp.geometry.Point(lr.longitude, lr.latitude), axis=1))\n",
    "ios_control_gpdf = gpd.GeoDataFrame(\n",
    "        ios_accuracy_df, geometry=ios_accuracy_df.apply(lambda lr: shp.geometry.Point(lr.longitude, lr.latitude), axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_gt_distances = android_control_gpdf.distance(gt_linestring) * (R / 360)\n",
    "ios_gt_distances = ios_control_gpdf.distance(gt_linestring) * (R / 360)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_android_control_gpdf = android_control_gpdf[android_gt_distances <= 5]\n",
    "filtered_ios_control_gpdf = ios_control_gpdf[ios_gt_distances <= 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(filtered_android_control_gpdf)/len(android_control_gpdf), len(filtered_ios_control_gpdf)/len(ios_control_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax_array = plt.subplots(nrows=1, ncols=2, figsize=(20,20))\n",
    "android_control_gpdf.plot(ax=ax_array[0])\n",
    "filtered_android_control_gpdf.plot(ax=ax_array[0])\n",
    "ios_control_gpdf.plot(ax=ax_array[1])\n",
    "filtered_ios_control_gpdf.plot(ax=ax_array[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "len(android_control_gpdf), len(ios_control_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.interpolate as sci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_lat_fn = sci.interp1d(x=filtered_android_control_gpdf.ts, y=filtered_android_control_gpdf.latitude, fill_value=\"extrapolate\")\n",
    "android_lon_fn = sci.interp1d(x=filtered_android_control_gpdf.ts, y=filtered_android_control_gpdf.longitude, fill_value=\"extrapolate\")\n",
    "ios_lat_fn = sci.interp1d(x=filtered_ios_control_gpdf.ts, y=filtered_ios_control_gpdf.latitude, fill_value=\"extrapolate\")\n",
    "ios_lon_fn = sci.interp1d(x=filtered_ios_control_gpdf.ts, y=filtered_ios_control_gpdf.longitude, fill_value=\"extrapolate\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_ts_range = np.arange(android_trip[\"start_ts\"], android_trip[\"end_ts\"], 1)\n",
    "new_fmt_time_range = [arrow.get(ts).to(sd_la.eval_tz) for ts in new_ts_range]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_lat = android_lat_fn(new_ts_range)\n",
    "new_android_lng = android_lon_fn(new_ts_range)\n",
    "new_ios_lat = ios_lat_fn(new_ts_range)\n",
    "new_ios_lng = ios_lon_fn(new_ts_range)\n",
    "new_android_gpdf = gpd.GeoDataFrame({\n",
    "    \"latitude\": new_android_lat,\n",
    "    \"longitude\": new_android_lng,\n",
    "    \"ts\": new_ts_range,\n",
    "    \"fmt_time\": new_fmt_time_range,\n",
    "    \"geometry\": [shp.geometry.Point(x, y) for x, y in zip(new_android_lng, new_android_lat)]\n",
    "})\n",
    "new_ios_gpdf = gpd.GeoDataFrame({\n",
    "    \"latitude\": new_ios_lat,\n",
    "    \"longitude\": new_ios_lng,\n",
    "    \"ts\": new_ts_range,\n",
    "    \"fmt_time\": new_fmt_time_range,\n",
    "    \"geometry\": [shp.geometry.Point(x, y) for x, y in zip(new_ios_lng, new_ios_lat)]\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "new_android_gpdf[[\"fmt_time\", \"geometry\"]].head(), new_ios_gpdf[[\"fmt_time\", \"geometry\"]].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "distances = new_android_gpdf.distance(gt_linestring) * (R/360); distances.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "valid_mask = distances <= 2; np.nonzero(np.logical_not(valid_mask))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_gpdf[\"distance_along\"] = new_android_gpdf.geometry.apply(lambda p: gt_linestring.project(p))\n",
    "new_ios_gpdf[\"distance_along\"] = new_ios_gpdf.geometry.apply(lambda p: gt_linestring.project(p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "filtered_new_android_gpdf = new_android_gpdf[new_android_gpdf.distance(gt_linestring) * (R/360) <= 5]; filtered_new_android_gpdf.head()\n",
    "filtered_new_ios_gpdf = new_ios_gpdf[new_ios_gpdf.distance(gt_linestring) * (R/360) <= 5]; filtered_new_ios_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ezpv.display_map_detail_from_df(curr_map=None, sel_location_df=filtered_new_android_gpdf[filtered_new_android_gpdf.distance_along.diff() < 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax_array = plt.subplots(nrows=1, ncols=2, figsize=(20,20))\n",
    "# new_android_gpdf.plot(ax=ax_array[0])\n",
    "filtered_new_android_gpdf.plot(ax=ax_array[0])\n",
    "# new_ios_gpdf.plot(ax=ax_array[1])\n",
    "filtered_new_ios_gpdf.plot(ax=ax_array[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NAN = float(\"nan\")\n",
    "merged_gpdf = pd.merge(filtered_new_android_gpdf, filtered_new_ios_gpdf, on=\"ts\", how=\"outer\", suffixes=(\"_a\", \"_i\")).sort_values(by=\"ts\", axis=\"index\"); merged_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_row(loc_row):\n",
    "    # print(\"merging %s\" % loc_row)\n",
    "    if pd.isnull(loc_row.geometry_i):\n",
    "        assert not np.isnull(loc_row.geometry_a)\n",
    "        final_geom = loc_row.geometry_a\n",
    "    elif pd.isnull(loc_row.geometry_a):\n",
    "        assert not pd.isnull(loc_row.geometry_i)\n",
    "        final_geom = loc_row.geometry_i\n",
    "    else:\n",
    "        assert not pd.isnull(loc_row.geometry_i) and not pd.isnull(loc_row.geometry_a)\n",
    "        choice_series = gpd.GeoSeries([loc_row.geometry_a, loc_row.geometry_i])\n",
    "        closer_idx = choice_series.distance(gt_linestring).idxmin()\n",
    "        final_geom = choice_series.loc[closer_idx]\n",
    "    return {\n",
    "        \"ts\": loc_row.ts,\n",
    "        \"fmt_time\": arrow.get(loc_row.ts).to(\"America/Los_Angeles\"),\n",
    "        \"longitude\": final_geom.x,\n",
    "        \"latitude\": final_geom.y,\n",
    "        \"geometry\": final_geom\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "distance_so_far = 0\n",
    "reference_gpdf = gpd.GeoDataFrame(data=list(merged_gpdf.apply(merge_row_with_distance, axis=1))); reference_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reference_gpdf = reference_gpdf[reference_gpdf.latitude.notnull()]; len(reference_gpdf)/len(new_ts_range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This looks good in this small view, but looking at it in a map, we can see some weirdnesses at the end and at the curve on Miramonte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import arrow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import folium"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "importlib.reload(ezpv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "curr_map = folium.Map()\n",
    "gt_leg_gj = sd_ucb.get_geojson_for_leg(gt_leg)\n",
    "sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(filtered_new_android_gpdf.longitude, filtered_new_android_gpdf.latitude))),properties={\"style\": {\"color\": \"red\"}, \"ts\": list(filtered_new_android_gpdf.ts)})\n",
    "i_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(filtered_new_ios_gpdf.longitude, filtered_new_ios_gpdf.latitude))),properties={\"style\": {\"color\": \"purple\"}, \"ts\": list(filtered_new_ios_gpdf.ts)})\n",
    "old_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(android_control_gpdf.longitude, android_control_gpdf.latitude))),properties={\"style\": {\"color\": \"yellow\"}, \"ts\": list(android_control_gpdf.ts)})\n",
    "filtered_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(reference_gpdf.longitude, reference_gpdf.latitude))),properties={\"style\": {\"color\": \"blue\"}, \"ts\": list(reference_gpdf.ts)})\n",
    "gt_leg_gj_feature = folium.GeoJson(gt_leg_gj, name=\"ground_truth\")\n",
    "gt_leg_gj_points = ezpv.get_point_markers(gt_leg_gj[2], name=\"ground_truth_points\", color=\"green\")\n",
    "sensed_leg_gj_feature = folium.GeoJson(sensed_section_gj, name=\"sensed_values (android)\")\n",
    "i_sensed_leg_gj_feature = folium.GeoJson(i_sensed_section_gj, name=\"sensed_values (ios)\")\n",
    "old_sensed_leg_gj_feature = folium.GeoJson(old_sensed_section_gj, name=\"old sensed_values\")\n",
    "filtered_sensed_leg_gj_feature = folium.GeoJson(filtered_sensed_section_gj, name=\"filtered sensed_values\")\n",
    "sensed_leg_gj_points = ezpv.get_point_markers(sensed_section_gj, name=\"sensed_points(android) \", color=\"red\", tz=\"America/Los_Angeles\")\n",
    "i_sensed_leg_gj_points = ezpv.get_point_markers(i_sensed_section_gj, name=\"sensed_points (ios)\", color=\"purple\", tz=\"America/Los_Angeles\")\n",
    "old_sensed_leg_gj_points = ezpv.get_point_markers(old_sensed_section_gj, name=\"old_sensed_points\", color=\"yellow\", tz=\"America/Los_Angeles\")\n",
    "filtered_sensed_leg_gj_points = ezpv.get_point_markers(filtered_sensed_section_gj, name=\"filtered_sensed_points\", color=\"blue\", tz=\"America/Los_Angeles\")\n",
    "curr_map.add_child(gt_leg_gj_feature)\n",
    "curr_map.add_child(gt_leg_gj_points)\n",
    "curr_map.add_child(sensed_leg_gj_feature)\n",
    "curr_map.add_child(sensed_leg_gj_points)\n",
    "curr_map.add_child(i_sensed_leg_gj_feature)\n",
    "curr_map.add_child(i_sensed_leg_gj_points)\n",
    "curr_map.add_child(old_sensed_leg_gj_feature)\n",
    "curr_map.add_child(old_sensed_leg_gj_points)\n",
    "curr_map.add_child(filtered_sensed_leg_gj_feature)\n",
    "curr_map.add_child(filtered_sensed_leg_gj_points)\n",
    "curr_map.fit_bounds(sensed_leg_gj_feature.get_bounds())\n",
    "folium.LayerControl().add_to(curr_map)\n",
    "curr_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged_gpdf.loc[919:953].sort_values(by=\"ts\", axis=\"index\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reference_gpdf[reference_gpdf.distance_along < 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  `shapely.interp1d`: Temporal accuracy check\n",
    "\n",
    "Now let's check this for the temporal accuracy motivating use case\n",
    "Note that for `merge_row`, this returns the kinds of zigzags that we see in the raw data.\n",
    "I wonder if, at least on android, fused location collection uses some kind of closeness distance metric like we do, which fails like we do here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_trip = pv_ucb.map()[\"android\"][\"ucb-sdb-android-1\"][\"evaluation_ranges\"][0][\"evaluation_trip_ranges\"][0][\"evaluation_section_ranges\"][5]\n",
    "ios_trip = pv_ucb.map()[\"ios\"][\"ucb-sdb-ios-1\"][\"evaluation_ranges\"][0][\"evaluation_trip_ranges\"][0][\"evaluation_section_ranges\"][5]\n",
    "android_accuracy_df = android_trip[\"location_df\"]\n",
    "ios_accuracy_df = ios_trip[\"location_df\"]\n",
    "gt_leg = sd_ucb.get_ground_truth_for_leg(\"mtv_to_berkeley_sf_bart\", \"subway_underground\")\n",
    "gt_linestring = shp.geometry.LineString(coordinates=gt_leg[\"route_coords\"][\"geometry\"][\"coordinates\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_control_gpdf = gpd.GeoDataFrame(\n",
    "        android_accuracy_df, geometry=android_accuracy_df.apply(lambda lr: shp.geometry.Point(lr.longitude, lr.latitude), axis=1))\n",
    "ios_control_gpdf = gpd.GeoDataFrame(\n",
    "        ios_accuracy_df, geometry=ios_accuracy_df.apply(lambda lr: shp.geometry.Point(lr.longitude, lr.latitude), axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_gt_distances = android_control_gpdf.distance(gt_linestring) * (R / 360)\n",
    "ios_gt_distances = ios_control_gpdf.distance(gt_linestring) * (R / 360)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_android_control_gpdf = android_control_gpdf[android_gt_distances <= 5]\n",
    "filtered_ios_control_gpdf = ios_control_gpdf[ios_gt_distances <= 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(filtered_android_control_gpdf)/len(android_control_gpdf), len(filtered_ios_control_gpdf)/len(ios_control_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax_array = plt.subplots(nrows=1, ncols=2, figsize=(20,20))\n",
    "android_control_gpdf.plot(ax=ax_array[0])\n",
    "filtered_android_control_gpdf.plot(ax=ax_array[0])\n",
    "ios_control_gpdf.plot(ax=ax_array[1])\n",
    "filtered_ios_control_gpdf.plot(ax=ax_array[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_android_control_gpdf.ts.iloc[0], filtered_android_control_gpdf.ts.iloc[-1], filtered_ios_control_gpdf.ts.iloc[0], filtered_ios_control_gpdf.ts.iloc[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "len(android_control_gpdf), len(ios_control_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.interpolate as sci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_lat_fn = sci.interp1d(x=filtered_android_control_gpdf.ts, y=filtered_android_control_gpdf.latitude, fill_value=\"extrapolate\")\n",
    "android_lon_fn = sci.interp1d(x=filtered_android_control_gpdf.ts, y=filtered_android_control_gpdf.longitude, fill_value=\"extrapolate\")\n",
    "ios_lat_fn = sci.interp1d(x=filtered_ios_control_gpdf.ts, y=filtered_ios_control_gpdf.latitude, fill_value=\"extrapolate\")\n",
    "ios_lon_fn = sci.interp1d(x=filtered_ios_control_gpdf.ts, y=filtered_ios_control_gpdf.longitude, fill_value=\"extrapolate\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_ts_range = np.arange(android_trip[\"start_ts\"], android_trip[\"end_ts\"], 1)\n",
    "new_fmt_time_range = [arrow.get(ts).to(sd_la.eval_tz) for ts in new_ts_range]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_lat = android_lat_fn(new_ts_range)\n",
    "new_android_lng = android_lon_fn(new_ts_range)\n",
    "new_ios_lat = ios_lat_fn(new_ts_range)\n",
    "new_ios_lng = ios_lon_fn(new_ts_range)\n",
    "new_android_gpdf = gpd.GeoDataFrame({\n",
    "    \"latitude\": new_android_lat,\n",
    "    \"longitude\": new_android_lng,\n",
    "    \"ts\": new_ts_range,\n",
    "    \"fmt_time\": new_fmt_time_range,\n",
    "    \"geometry\": [shp.geometry.Point(x, y) for x, y in zip(new_android_lng, new_android_lat)]\n",
    "})\n",
    "new_ios_gpdf = gpd.GeoDataFrame({\n",
    "    \"latitude\": new_ios_lat,\n",
    "    \"longitude\": new_ios_lng,\n",
    "    \"ts\": new_ts_range,\n",
    "    \"fmt_time\": new_fmt_time_range,\n",
    "    \"geometry\": [shp.geometry.Point(x, y) for x, y in zip(new_ios_lng, new_ios_lat)]\n",
    "})\n",
    "new_android_gpdf[\"error\"] = new_android_gpdf.distance(gt_linestring) * (R/360)\n",
    "new_ios_gpdf[\"error\"] = new_ios_gpdf.distance(gt_linestring) * (R/360)\n",
    "new_android_gpdf[\"distance_along\"] = new_android_gpdf.distance(gt_linestring) * (R/360)\n",
    "new_ios_gpdf[\"distance_along\"] = new_ios_gpdf.distance(gt_linestring) * (R/360)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "new_android_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].head(), new_ios_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].tail(), new_ios_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_gpdf.error[new_android_gpdf.error == new_android_gpdf.error.iloc[-1]].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].loc[1210:1220], new_ios_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].loc[1210:1220]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "filtered_new_android_gpdf = new_android_gpdf[new_android_gpdf.error <= 5]\n",
    "filtered_new_ios_gpdf = new_ios_gpdf[new_ios_gpdf.error <= 5]\n",
    "filtered_new_android_gpdf.fmt_time.head(), filtered_new_android_gpdf.fmt_time.tail(), filtered_new_ios_gpdf.fmt_time.head(), filtered_new_ios_gpdf.fmt_time.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax_array = plt.subplots(nrows=2, ncols=2, figsize=(20,20))\n",
    "new_android_gpdf.plot(ax=ax_array[0][0])\n",
    "filtered_new_android_gpdf.plot(ax=ax_array[0][1])\n",
    "new_ios_gpdf.plot(ax=ax_array[1][0])\n",
    "filtered_new_ios_gpdf.plot(ax=ax_array[1][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NAN = float(\"nan\")\n",
    "merged_gpdf = pd.merge(filtered_new_android_gpdf, filtered_new_ios_gpdf, on=\"ts\", how=\"outer\", suffixes=(\"_a\", \"_i\")).sort_values(by=\"ts\", axis=\"index\"); merged_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_row(loc_row):\n",
    "    # print(\"merging %s\" % loc_row)\n",
    "    if pd.isnull(loc_row.geometry_i):\n",
    "        assert not np.isnull(loc_row.geometry_a)\n",
    "        final_geom = loc_row.geometry_a\n",
    "    elif pd.isnull(loc_row.geometry_a):\n",
    "        assert not pd.isnull(loc_row.geometry_i)\n",
    "        final_geom = loc_row.geometry_i\n",
    "    else:\n",
    "        assert not pd.isnull(loc_row.geometry_i) and not pd.isnull(loc_row.geometry_a)\n",
    "        choice_series = gpd.GeoSeries([loc_row.geometry_a, loc_row.geometry_i])\n",
    "        closer_idx = choice_series.distance(gt_linestring).idxmin()\n",
    "        final_geom = choice_series.loc[closer_idx]\n",
    "    return {\n",
    "        \"ts\": loc_row.ts,\n",
    "        \"fmt_time\": arrow.get(loc_row.ts).to(\"America/Los_Angeles\"),\n",
    "        \"longitude\": final_geom.x,\n",
    "        \"latitude\": final_geom.y,\n",
    "        \"geometry\": final_geom\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use a variable outside the function to store distance so far\n",
    "# TODO: figure out whether it is better to do this or to write a loop manually\n",
    "distance_so_far = 0\n",
    "def merge_row_with_distance(loc_row):\n",
    "    global distance_so_far\n",
    "    source = None\n",
    "    more_details = False\n",
    "    # print(\"merging %s at distance %s\" % (loc_row, distance_so_far))\n",
    "    if 1020 <= loc_row.name <= 1030:\n",
    "        more_details = True\n",
    "        print(\"merging %s at distance %s\" % (loc_row, distance_so_far))\n",
    "    if pd.isnull(loc_row.geometry_i):\n",
    "        assert not pd.isnull(loc_row.geometry_a)\n",
    "        final_geom = loc_row.geometry_a\n",
    "        source = \"android\"\n",
    "    elif pd.isnull(loc_row.geometry_a):\n",
    "        assert not pd.isnull(loc_row.geometry_i)\n",
    "        final_geom = loc_row.geometry_i\n",
    "        source = \"ios\"\n",
    "    else:\n",
    "        assert not pd.isnull(loc_row.geometry_i) and not pd.isnull(loc_row.geometry_a)\n",
    "        choice_series = gpd.GeoSeries([loc_row.geometry_a, loc_row.geometry_i])\n",
    "        distance_along_line_series = choice_series.apply(lambda p: gt_linestring.project(p))\n",
    "        if more_details:\n",
    "            print(\"distance_along_line = %s\" % distance_along_line_series)\n",
    "        distance_from_last_series = distance_along_line_series.apply(lambda d: d - distance_so_far)\n",
    "        if more_details:\n",
    "            print(\"distance_from_last_series = %s\" % distance_from_last_series)\n",
    "\n",
    "        # assert not (distance_from_last_series < 0).all(), \"distance_so_far = %s, distance_from_last = %s\" % (distance_so_far, distance_from_last_series)\n",
    "        if (distance_from_last_series < 0).all():\n",
    "            if more_details:\n",
    "                print(\"all distances are negative, skipping...\")\n",
    "            return {\n",
    "                \"ts\": loc_row.ts,\n",
    "                \"fmt_time\": arrow.get(loc_row.ts).to(\"America/Los_Angeles\"),\n",
    "                \"longitude\": np.nan,\n",
    "                \"latitude\": np.nan,\n",
    "                \"geometry\": shp.geometry.Point()\n",
    "            }\n",
    "        else:\n",
    "            if (distance_from_last_series < 0).any():\n",
    "                # avoid going backwards along the linestring (wonder how this works with San Jose u-turn)\n",
    "                closer_idx = distance_from_last_series.idxmax()\n",
    "                if more_details:\n",
    "                    print(\"one distance is going backwards, found closer_idx = %d\" % closer_idx)\n",
    "\n",
    "            else:\n",
    "                closer_idx = choice_series.distance(gt_linestring).idxmin()\n",
    "                if more_details:\n",
    "                    print(\"both distances are positive, found closer_idx = %d\" % closer_idx)\n",
    "\n",
    "            if closer_idx == 0:\n",
    "                source = \"android\"\n",
    "            else:\n",
    "                source = \"ios\"\n",
    "            final_geom = choice_series.loc[closer_idx]\n",
    "        \n",
    "    distance_so_far = gt_linestring.project(final_geom)\n",
    "    return {\n",
    "        \"ts\": loc_row.ts,\n",
    "        \"fmt_time\": arrow.get(loc_row.ts).to(\"America/Los_Angeles\"),\n",
    "        \"longitude\": final_geom.x,\n",
    "        \"latitude\": final_geom.y,\n",
    "        \"geometry\": final_geom,\n",
    "        \"distance_along\": gt_linestring.project(final_geom),\n",
    "        \"error\": final_geom.distance(gt_linestring),\n",
    "        \"source\": source\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "distance_so_far = 0\n",
    "reference_gpdf = gpd.GeoDataFrame(data=list(merged_gpdf.apply(merge_row_with_distance, axis=1))); reference_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "reference_gpdf = reference_gpdf[reference_gpdf.latitude.notnull()]; len(reference_gpdf)/len(new_ts_range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "len(filtered_new_android_gpdf)/len(new_android_gpdf), len(filtered_new_ios_gpdf)/len(new_ios_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import folium"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "curr_map = folium.Map()\n",
    "gt_leg_gj = sd_ucb.get_geojson_for_leg(gt_leg)\n",
    "sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(filtered_new_android_gpdf.longitude, filtered_new_android_gpdf.latitude))),properties={\"style\": {\"color\": \"red\"}, \"ts\": list(filtered_new_android_gpdf.ts)})\n",
    "i_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(filtered_new_ios_gpdf.longitude, filtered_new_ios_gpdf.latitude))),properties={\"style\": {\"color\": \"purple\"}, \"ts\": list(filtered_new_ios_gpdf.ts)})\n",
    "old_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(android_control_gpdf.longitude, android_control_gpdf.latitude))),properties={\"style\": {\"color\": \"yellow\"}, \"ts\": list(android_control_gpdf.ts)})\n",
    "filtered_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(reference_gpdf.longitude, reference_gpdf.latitude))),properties={\"style\": {\"color\": \"blue\"}, \"ts\": list(reference_gpdf.ts)})\n",
    "gt_leg_gj_feature = folium.GeoJson(gt_leg_gj, name=\"ground_truth\")\n",
    "gt_leg_gj_points = ezpv.get_point_markers(gt_leg_gj[2], name=\"ground_truth_points\", color=\"green\")\n",
    "sensed_leg_gj_feature = folium.GeoJson(sensed_section_gj, name=\"sensed_values (android)\")\n",
    "i_sensed_leg_gj_feature = folium.GeoJson(i_sensed_section_gj, name=\"sensed_values (ios)\")\n",
    "old_sensed_leg_gj_feature = folium.GeoJson(old_sensed_section_gj, name=\"old sensed_values\")\n",
    "filtered_sensed_leg_gj_feature = folium.GeoJson(filtered_sensed_section_gj, name=\"filtered sensed_values\")\n",
    "sensed_leg_gj_points = ezpv.get_point_markers(sensed_section_gj, name=\"sensed_points(android) \", color=\"red\", tz=\"America/Los_Angeles\")\n",
    "i_sensed_leg_gj_points = ezpv.get_point_markers(i_sensed_section_gj, name=\"sensed_points (ios)\", color=\"purple\", tz=\"America/Los_Angeles\")\n",
    "old_sensed_leg_gj_points = ezpv.get_point_markers(old_sensed_section_gj, name=\"old_sensed_points\", color=\"yellow\", tz=\"America/Los_Angeles\")\n",
    "filtered_sensed_leg_gj_points = ezpv.get_point_markers(filtered_sensed_section_gj, name=\"filtered_sensed_points\", color=\"blue\", tz=\"America/Los_Angeles\")\n",
    "curr_map.add_child(gt_leg_gj_feature)\n",
    "curr_map.add_child(gt_leg_gj_points)\n",
    "curr_map.add_child(sensed_leg_gj_feature)\n",
    "curr_map.add_child(sensed_leg_gj_points)\n",
    "curr_map.add_child(i_sensed_leg_gj_feature)\n",
    "curr_map.add_child(i_sensed_leg_gj_points)\n",
    "curr_map.add_child(old_sensed_leg_gj_feature)\n",
    "curr_map.add_child(old_sensed_leg_gj_points)\n",
    "curr_map.add_child(filtered_sensed_leg_gj_feature)\n",
    "curr_map.add_child(filtered_sensed_leg_gj_points)\n",
    "curr_map.fit_bounds(sensed_leg_gj_feature.get_bounds())\n",
    "folium.LayerControl().add_to(curr_map)\n",
    "curr_map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  `shapely.interp1d`: Temporal accuracy check\n",
    "\n",
    "Let's try to stop the interpolation at the point where we have data instead of extrapolating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_trip = pv_ucb.map()[\"android\"][\"ucb-sdb-android-1\"][\"evaluation_ranges\"][0][\"evaluation_trip_ranges\"][0][\"evaluation_section_ranges\"][5]\n",
    "ios_trip = pv_ucb.map()[\"ios\"][\"ucb-sdb-ios-1\"][\"evaluation_ranges\"][0][\"evaluation_trip_ranges\"][0][\"evaluation_section_ranges\"][5]\n",
    "android_accuracy_df = android_trip[\"location_df\"]\n",
    "ios_accuracy_df = ios_trip[\"location_df\"]\n",
    "gt_leg = sd_ucb.get_ground_truth_for_leg(\"mtv_to_berkeley_sf_bart\", \"subway_underground\")\n",
    "gt_linestring = shp.geometry.LineString(coordinates=gt_leg[\"route_coords\"][\"geometry\"][\"coordinates\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_control_gpdf = gpd.GeoDataFrame(\n",
    "        android_accuracy_df, geometry=android_accuracy_df.apply(lambda lr: shp.geometry.Point(lr.longitude, lr.latitude), axis=1))\n",
    "ios_control_gpdf = gpd.GeoDataFrame(\n",
    "        ios_accuracy_df, geometry=ios_accuracy_df.apply(lambda lr: shp.geometry.Point(lr.longitude, lr.latitude), axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_gt_distances = android_control_gpdf.distance(gt_linestring) * (R / 360)\n",
    "ios_gt_distances = ios_control_gpdf.distance(gt_linestring) * (R / 360)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_android_control_gpdf = android_control_gpdf[android_gt_distances <= 5]\n",
    "filtered_ios_control_gpdf = ios_control_gpdf[ios_gt_distances <= 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(filtered_android_control_gpdf)/len(android_control_gpdf), len(filtered_ios_control_gpdf)/len(ios_control_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax_array = plt.subplots(nrows=1, ncols=2, figsize=(20,20))\n",
    "android_control_gpdf.plot(ax=ax_array[0])\n",
    "filtered_android_control_gpdf.plot(ax=ax_array[0])\n",
    "ios_control_gpdf.plot(ax=ax_array[1])\n",
    "filtered_ios_control_gpdf.plot(ax=ax_array[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "filtered_android_control_gpdf.ts.iloc[0], filtered_android_control_gpdf.ts.iloc[-1], filtered_ios_control_gpdf.ts.iloc[0], filtered_ios_control_gpdf.ts.iloc[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "len(android_control_gpdf), len(ios_control_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.interpolate as sci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_lat_fn = sci.interp1d(x=filtered_android_control_gpdf.ts, y=filtered_android_control_gpdf.latitude)\n",
    "android_lon_fn = sci.interp1d(x=filtered_android_control_gpdf.ts, y=filtered_android_control_gpdf.longitude)\n",
    "ios_lat_fn = sci.interp1d(x=filtered_ios_control_gpdf.ts, y=filtered_ios_control_gpdf.latitude)\n",
    "ios_lon_fn = sci.interp1d(x=filtered_ios_control_gpdf.ts, y=filtered_ios_control_gpdf.longitude)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_ts_range = np.arange(math.ceil(filtered_android_control_gpdf.ts.iloc[0]), math.floor(filtered_android_control_gpdf.ts.iloc[-1]), 1).tolist()\n",
    "new_android_fmt_time_range = [arrow.get(ts).to(sd_la.eval_tz) for ts in new_android_ts_range]\n",
    "new_ios_ts_range = np.arange(math.ceil(filtered_ios_control_gpdf.ts.iloc[0]), math.floor(filtered_ios_control_gpdf.ts.iloc[-1]), 1).tolist()\n",
    "new_ios_fmt_time_range = [arrow.get(ts).to(sd_la.eval_tz) for ts in new_ios_ts_range]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_lat = android_lat_fn(new_android_ts_range)\n",
    "new_android_lng = android_lon_fn(new_android_ts_range)\n",
    "new_ios_lat = ios_lat_fn(new_ios_ts_range)\n",
    "new_ios_lng = ios_lon_fn(new_ios_ts_range)\n",
    "new_android_gpdf = gpd.GeoDataFrame({\n",
    "    \"latitude\": new_android_lat,\n",
    "    \"longitude\": new_android_lng,\n",
    "    \"ts\": new_android_ts_range,\n",
    "    \"fmt_time\": new_android_fmt_time_range,\n",
    "    \"geometry\": [shp.geometry.Point(x, y) for x, y in zip(new_android_lng, new_android_lat)]\n",
    "})\n",
    "new_ios_gpdf = gpd.GeoDataFrame({\n",
    "    \"latitude\": new_ios_lat,\n",
    "    \"longitude\": new_ios_lng,\n",
    "    \"ts\": new_ios_ts_range,\n",
    "    \"fmt_time\": new_ios_fmt_time_range,\n",
    "    \"geometry\": [shp.geometry.Point(x, y) for x, y in zip(new_ios_lng, new_ios_lat)]\n",
    "})\n",
    "new_android_gpdf[\"error\"] = new_android_gpdf.distance(gt_linestring) * (R/360)\n",
    "new_ios_gpdf[\"error\"] = new_ios_gpdf.distance(gt_linestring) * (R/360)\n",
    "new_android_gpdf[\"distance_along\"] = new_android_gpdf.geometry.apply(lambda p: gt_linestring.project(p) * (R/360))\n",
    "new_ios_gpdf[\"distance_along\"] = new_ios_gpdf.geometry.apply(lambda p: gt_linestring.project(p) * (R/360))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "new_android_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].head(), new_ios_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "new_android_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].tail(), new_ios_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_gpdf.error[new_android_gpdf.error == new_android_gpdf.error.iloc[-1]].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].loc[1210:1220], new_ios_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].loc[1210:1220]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "filtered_new_android_gpdf = new_android_gpdf[new_android_gpdf.error <= 5]\n",
    "filtered_new_ios_gpdf = new_ios_gpdf[new_ios_gpdf.error <= 5]\n",
    "filtered_new_android_gpdf.fmt_time.head(), filtered_new_android_gpdf.fmt_time.tail(), filtered_new_ios_gpdf.fmt_time.head(), filtered_new_ios_gpdf.fmt_time.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax_array = plt.subplots(nrows=2, ncols=2, figsize=(20,20))\n",
    "new_android_gpdf.plot(ax=ax_array[0][0])\n",
    "filtered_new_android_gpdf.plot(ax=ax_array[0][1])\n",
    "new_ios_gpdf.plot(ax=ax_array[1][0])\n",
    "filtered_new_ios_gpdf.plot(ax=ax_array[1][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NAN = float(\"nan\")\n",
    "merged_gpdf = pd.merge(filtered_new_android_gpdf, filtered_new_ios_gpdf, on=\"ts\", how=\"outer\", suffixes=(\"_a\", \"_i\")).sort_values(by=\"ts\", axis=\"index\"); merged_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.count_nonzero(merged_gpdf.distance_along_i.diff() < 0 ), len(merged_gpdf.distance_along_i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_row(loc_row):\n",
    "    # print(\"merging %s\" % loc_row)\n",
    "    if pd.isnull(loc_row.geometry_i):\n",
    "        assert not np.isnull(loc_row.geometry_a)\n",
    "        final_geom = loc_row.geometry_a\n",
    "    elif pd.isnull(loc_row.geometry_a):\n",
    "        assert not pd.isnull(loc_row.geometry_i)\n",
    "        final_geom = loc_row.geometry_i\n",
    "    else:\n",
    "        assert not pd.isnull(loc_row.geometry_i) and not pd.isnull(loc_row.geometry_a)\n",
    "        choice_series = gpd.GeoSeries([loc_row.geometry_a, loc_row.geometry_i])\n",
    "        closer_idx = choice_series.distance(gt_linestring).idxmin()\n",
    "        final_geom = choice_series.loc[closer_idx]\n",
    "    return {\n",
    "        \"ts\": loc_row.ts,\n",
    "        \"fmt_time\": arrow.get(loc_row.ts).to(\"America/Los_Angeles\"),\n",
    "        \"longitude\": final_geom.x,\n",
    "        \"latitude\": final_geom.y,\n",
    "        \"geometry\": final_geom\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use a variable outside the function to store distance so far\n",
    "# TODO: figure out whether it is better to do this or to write a loop manually\n",
    "distance_so_far = 0\n",
    "EMPTY_POINT = shp.geometry.Point()\n",
    "\n",
    "def merge_row_with_distance(loc_row):\n",
    "    global distance_so_far\n",
    "    source = None\n",
    "    more_details = False\n",
    "    # print(\"merging %s at distance %s\" % (loc_row, distance_so_far))\n",
    "    if 75 <= loc_row.name <= 80 or 816 <= loc_row.name <= 820:\n",
    "        more_details = True\n",
    "        print(\"merging %s at distance %s\" % (loc_row, distance_so_far))\n",
    "    if pd.isnull(loc_row.geometry_i):\n",
    "        assert not pd.isnull(loc_row.geometry_a)\n",
    "        if loc_row.distance_along_a > distance_so_far:\n",
    "            final_geom = loc_row.geometry_a\n",
    "            source = \"android\"\n",
    "        else:\n",
    "            final_geom = EMPTY_POINT\n",
    "    elif pd.isnull(loc_row.geometry_a):\n",
    "        assert not pd.isnull(loc_row.geometry_i)\n",
    "        if loc_row.distance_along_i > distance_so_far:\n",
    "            final_geom = loc_row.geometry_i\n",
    "            source = \"ios\"\n",
    "        else:\n",
    "            final_geom = EMPTY_POINT\n",
    "    else:\n",
    "        assert not pd.isnull(loc_row.geometry_i) and not pd.isnull(loc_row.geometry_a)\n",
    "        choice_series = gpd.GeoSeries([loc_row.geometry_a, loc_row.geometry_i])\n",
    "        distance_along_line_series = gpd.GeoSeries([loc_row.distance_along_a, loc_row.distance_along_i])\n",
    "        if more_details:\n",
    "            print(\"distance_along_line = %s\" % distance_along_line_series)\n",
    "        distance_from_last_series = distance_along_line_series.apply(lambda d: d - distance_so_far)\n",
    "        if more_details:\n",
    "            print(\"distance_from_last_series = %s\" % distance_from_last_series)\n",
    "\n",
    "        # assert not (distance_from_last_series < 0).all(), \"distance_so_far = %s, distance_from_last = %s\" % (distance_so_far, distance_from_last_series)\n",
    "        if (distance_from_last_series < 0).all():\n",
    "            if more_details:\n",
    "                print(\"all distances are negative, skipping...\")\n",
    "            final_geom = EMPTY_POINT\n",
    "        else:\n",
    "            if (distance_from_last_series < 0).any():\n",
    "                # avoid going backwards along the linestring (wonder how this works with San Jose u-turn)\n",
    "                closer_idx = distance_from_last_series.idxmax()\n",
    "                if more_details:\n",
    "                    print(\"one distance is going backwards, found closer_idx = %d\" % closer_idx)\n",
    "\n",
    "            else:\n",
    "                closer_idx = distance_from_last_series.idxmin()\n",
    "                if more_details:\n",
    "                    print(\"both distances are positive, found closer_idx = %d\" % closer_idx)\n",
    "\n",
    "            if closer_idx == 0:\n",
    "                source = \"android\"\n",
    "            else:\n",
    "                source = \"ios\"\n",
    "            final_geom = choice_series.loc[closer_idx]\n",
    "\n",
    "    if final_geom != EMPTY_POINT:\n",
    "        distance_so_far = gt_linestring.project(final_geom) * (R/360)\n",
    "        \n",
    "    if more_details:\n",
    "        print(\"final_geom = %s, new_distance_so_far = %s\" % (final_geom, distance_so_far))\n",
    "    if final_geom == EMPTY_POINT:\n",
    "        return {\n",
    "            \"ts\": loc_row.ts,\n",
    "            \"fmt_time\": arrow.get(loc_row.ts).to(\"America/Los_Angeles\"),\n",
    "            \"longitude\": np.nan,\n",
    "            \"latitude\": np.nan,\n",
    "            \"geometry\": EMPTY_POINT    \n",
    "        }\n",
    "    else:\n",
    "        return {\n",
    "            \"ts\": loc_row.ts,\n",
    "            \"fmt_time\": arrow.get(loc_row.ts).to(\"America/Los_Angeles\"),\n",
    "            \"longitude\": final_geom.x,\n",
    "            \"latitude\": final_geom.y,\n",
    "            \"geometry\": final_geom,\n",
    "            \"distance_along\": gt_linestring.project(final_geom),\n",
    "            \"error\": final_geom.distance(gt_linestring),\n",
    "            \"source\": source\n",
    "        }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "distance_so_far = 0\n",
    "initial_reference_gpdf = gpd.GeoDataFrame(data=list(merged_gpdf.apply(merge_row_with_distance, axis=1))); reference_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "reference_gpdf = initial_reference_gpdf[initial_reference_gpdf.latitude.notnull()]; print(len(reference_gpdf)/len(initial_reference_gpdf), len(reference_gpdf)/len(new_ts_range))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "len(filtered_new_android_gpdf)/len(new_android_gpdf), len(filtered_new_ios_gpdf)/len(new_ios_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import folium"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_new_android_gpdf.ts.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_new_android_gpdf.latitude.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "curr_map = folium.Map()\n",
    "gt_leg_gj = sd_ucb.get_geojson_for_leg(gt_leg)\n",
    "sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(filtered_new_android_gpdf.longitude, filtered_new_android_gpdf.latitude))),properties={\"style\": {\"color\": \"red\"}})\n",
    "# i_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(filtered_new_ios_gpdf.longitude, filtered_new_ios_gpdf.latitude))),properties={\"style\": {\"color\": \"purple\"}, \"ts\": list(filtered_new_ios_gpdf.ts)})\n",
    "old_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(android_control_gpdf.longitude, android_control_gpdf.latitude))),properties={\"style\": {\"color\": \"yellow\"}, \"ts\": list(android_control_gpdf.ts)})\n",
    "filtered_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(reference_gpdf.longitude, reference_gpdf.latitude))),properties={\"style\": {\"color\": \"blue\"}})\n",
    "gt_leg_gj_feature = folium.GeoJson(gt_leg_gj, name=\"ground_truth\")\n",
    "gt_leg_gj_points = ezpv.get_point_markers(gt_leg_gj[2], name=\"ground_truth_points\", color=\"green\")\n",
    "sensed_leg_gj_feature = folium.GeoJson(sensed_section_gj, name=\"sensed_values (android)\")\n",
    "# i_sensed_leg_gj_feature = folium.GeoJson(i_sensed_section_gj, name=\"sensed_values (ios)\")\n",
    "old_sensed_leg_gj_feature = folium.GeoJson(old_sensed_section_gj, name=\"old sensed_values\")\n",
    "filtered_sensed_leg_gj_feature = folium.GeoJson(filtered_sensed_section_gj, name=\"filtered sensed_values\")\n",
    "# sensed_leg_gj_points = ezpv.get_point_markers(sensed_section_gj, name=\"sensed_points(android) \", color=\"red\", tz=\"America/Los_Angeles\")\n",
    "# i_sensed_leg_gj_points = ezpv.get_point_markers(i_sensed_section_gj, name=\"sensed_points (ios)\", color=\"purple\", tz=\"America/Los_Angeles\")\n",
    "old_sensed_leg_gj_points = ezpv.get_point_markers(old_sensed_section_gj, name=\"old_sensed_points\", color=\"yellow\", tz=\"America/Los_Angeles\")\n",
    "filtered_sensed_leg_gj_points = ezpv.get_point_markers(filtered_sensed_section_gj, name=\"filtered_sensed_points\", color=\"blue\", tz=\"America/Los_Angeles\")\n",
    "curr_map.add_child(gt_leg_gj_feature)\n",
    "curr_map.add_child(gt_leg_gj_points)\n",
    "curr_map.add_child(sensed_leg_gj_feature)\n",
    "# curr_map.add_child(sensed_leg_gj_points)\n",
    "# curr_map.add_child(i_sensed_leg_gj_feature)\n",
    "# curr_map.add_child(i_sensed_leg_gj_points)\n",
    "curr_map.add_child(old_sensed_leg_gj_feature)\n",
    "curr_map.add_child(old_sensed_leg_gj_points)\n",
    "curr_map.add_child(filtered_sensed_leg_gj_feature)\n",
    "curr_map.add_child(filtered_sensed_leg_gj_points)\n",
    "curr_map.fit_bounds(sensed_leg_gj_feature.get_bounds())\n",
    "folium.LayerControl().add_to(curr_map)\n",
    "curr_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.concat([reference_gpdf.loc[75:85]], axis='index')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged_gpdf[merged_gpdf.longitude_a == -122.40730863534677]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "reference_gpdf[reference_gpdf.longitude == -122.46802100069702]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  `shapely.interp1d`: Temporal accuracy check with U-turn\n",
    "\n",
    "Let's try to stop the interpolation at the point where we have data instead of extrapolating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_trip = pv_sj.map()[\"android\"][\"ucb-sdb-android-1\"][\"evaluation_ranges\"][0][\"evaluation_trip_ranges\"][1][\"evaluation_section_ranges\"][1]\n",
    "ios_trip = pv_sj.map()[\"ios\"][\"ucb-sdb-ios-1\"][\"evaluation_ranges\"][0][\"evaluation_trip_ranges\"][1][\"evaluation_section_ranges\"][1]\n",
    "android_accuracy_df = android_trip[\"location_df\"]\n",
    "ios_accuracy_df = ios_trip[\"location_df\"]\n",
    "gt_leg = sd_sj.get_ground_truth_for_leg(\"bus trip with e-scooter access\", \"city_escooter\")\n",
    "gt_linestring = shp.geometry.LineString(coordinates=gt_leg[\"route_coords\"][\"geometry\"][\"coordinates\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_control_gpdf = gpd.GeoDataFrame(\n",
    "        android_accuracy_df, geometry=android_accuracy_df.apply(lambda lr: shp.geometry.Point(lr.longitude, lr.latitude), axis=1))\n",
    "ios_control_gpdf = gpd.GeoDataFrame(\n",
    "        ios_accuracy_df, geometry=ios_accuracy_df.apply(lambda lr: shp.geometry.Point(lr.longitude, lr.latitude), axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_gt_distances = android_control_gpdf.distance(gt_linestring) * (R / 360)\n",
    "ios_gt_distances = ios_control_gpdf.distance(gt_linestring) * (R / 360)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_android_control_gpdf = android_control_gpdf[android_gt_distances <= 5]\n",
    "filtered_ios_control_gpdf = ios_control_gpdf[ios_gt_distances <= 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(filtered_android_control_gpdf)/len(android_control_gpdf), len(filtered_ios_control_gpdf)/len(ios_control_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax_array = plt.subplots(nrows=1, ncols=2, figsize=(20,20))\n",
    "android_control_gpdf.plot(ax=ax_array[0])\n",
    "filtered_android_control_gpdf.plot(ax=ax_array[0])\n",
    "ios_control_gpdf.plot(ax=ax_array[1])\n",
    "filtered_ios_control_gpdf.plot(ax=ax_array[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "filtered_android_control_gpdf.ts.iloc[0], filtered_android_control_gpdf.ts.iloc[-1], filtered_ios_control_gpdf.ts.iloc[0], filtered_ios_control_gpdf.ts.iloc[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "len(android_control_gpdf), len(ios_control_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.interpolate as sci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "android_lat_fn = sci.interp1d(x=filtered_android_control_gpdf.ts, y=filtered_android_control_gpdf.latitude)\n",
    "android_lon_fn = sci.interp1d(x=filtered_android_control_gpdf.ts, y=filtered_android_control_gpdf.longitude)\n",
    "ios_lat_fn = sci.interp1d(x=filtered_ios_control_gpdf.ts, y=filtered_ios_control_gpdf.latitude)\n",
    "ios_lon_fn = sci.interp1d(x=filtered_ios_control_gpdf.ts, y=filtered_ios_control_gpdf.longitude)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_ts_range = np.arange(math.ceil(filtered_android_control_gpdf.ts.iloc[0]), math.floor(filtered_android_control_gpdf.ts.iloc[-1]), 1).tolist()\n",
    "new_android_fmt_time_range = [arrow.get(ts).to(sd_la.eval_tz) for ts in new_android_ts_range]\n",
    "new_ios_ts_range = np.arange(math.ceil(filtered_ios_control_gpdf.ts.iloc[0]), math.floor(filtered_ios_control_gpdf.ts.iloc[-1]), 1).tolist()\n",
    "new_ios_fmt_time_range = [arrow.get(ts).to(sd_la.eval_tz) for ts in new_ios_ts_range]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_lat = android_lat_fn(new_android_ts_range)\n",
    "new_android_lng = android_lon_fn(new_android_ts_range)\n",
    "new_ios_lat = ios_lat_fn(new_ios_ts_range)\n",
    "new_ios_lng = ios_lon_fn(new_ios_ts_range)\n",
    "new_android_gpdf = gpd.GeoDataFrame({\n",
    "    \"latitude\": new_android_lat,\n",
    "    \"longitude\": new_android_lng,\n",
    "    \"ts\": new_android_ts_range,\n",
    "    \"fmt_time\": new_android_fmt_time_range,\n",
    "    \"geometry\": [shp.geometry.Point(x, y) for x, y in zip(new_android_lng, new_android_lat)]\n",
    "})\n",
    "new_ios_gpdf = gpd.GeoDataFrame({\n",
    "    \"latitude\": new_ios_lat,\n",
    "    \"longitude\": new_ios_lng,\n",
    "    \"ts\": new_ios_ts_range,\n",
    "    \"fmt_time\": new_ios_fmt_time_range,\n",
    "    \"geometry\": [shp.geometry.Point(x, y) for x, y in zip(new_ios_lng, new_ios_lat)]\n",
    "})\n",
    "new_android_gpdf[\"error\"] = new_android_gpdf.distance(gt_linestring) * (R/360)\n",
    "new_ios_gpdf[\"error\"] = new_ios_gpdf.distance(gt_linestring) * (R/360)\n",
    "new_android_gpdf[\"distance_along\"] = new_android_gpdf.geometry.apply(lambda p: gt_linestring.project(p) * (R/360))\n",
    "new_ios_gpdf[\"distance_along\"] = new_ios_gpdf.geometry.apply(lambda p: gt_linestring.project(p) * (R/360))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "new_android_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].head(), new_ios_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "new_android_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].tail(), new_ios_gpdf[[\"fmt_time\", \"geometry\", \"error\"]].tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "filtered_new_android_gpdf = new_android_gpdf[new_android_gpdf.error <= 5]\n",
    "filtered_new_ios_gpdf = new_ios_gpdf[new_ios_gpdf.error <= 5]\n",
    "filtered_new_android_gpdf.fmt_time.head(), filtered_new_android_gpdf.fmt_time.tail(), filtered_new_ios_gpdf.fmt_time.head(), filtered_new_ios_gpdf.fmt_time.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax_array = plt.subplots(nrows=2, ncols=2, figsize=(20,20))\n",
    "new_android_gpdf.plot(ax=ax_array[0][0])\n",
    "filtered_new_android_gpdf.plot(ax=ax_array[0][1])\n",
    "new_ios_gpdf.plot(ax=ax_array[1][0])\n",
    "filtered_new_ios_gpdf.plot(ax=ax_array[1][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NAN = float(\"nan\")\n",
    "merged_gpdf = pd.merge(filtered_new_android_gpdf, filtered_new_ios_gpdf, on=\"ts\", how=\"outer\", suffixes=(\"_a\", \"_i\")).sort_values(by=\"ts\", axis=\"index\"); merged_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_row(loc_row):\n",
    "    # print(\"merging %s\" % loc_row)\n",
    "    if pd.isnull(loc_row.geometry_i):\n",
    "        assert not np.isnull(loc_row.geometry_a)\n",
    "        final_geom = loc_row.geometry_a\n",
    "    elif pd.isnull(loc_row.geometry_a):\n",
    "        assert not pd.isnull(loc_row.geometry_i)\n",
    "        final_geom = loc_row.geometry_i\n",
    "    else:\n",
    "        assert not pd.isnull(loc_row.geometry_i) and not pd.isnull(loc_row.geometry_a)\n",
    "        choice_series = gpd.GeoSeries([loc_row.geometry_a, loc_row.geometry_i])\n",
    "        closer_idx = choice_series.distance(gt_linestring).idxmin()\n",
    "        final_geom = choice_series.loc[closer_idx]\n",
    "    return {\n",
    "        \"ts\": loc_row.ts,\n",
    "        \"fmt_time\": arrow.get(loc_row.ts).to(\"America/Los_Angeles\"),\n",
    "        \"longitude\": final_geom.x,\n",
    "        \"latitude\": final_geom.y,\n",
    "        \"geometry\": final_geom\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use a variable outside the function to store distance so far\n",
    "# TODO: figure out whether it is better to do this or to write a loop manually\n",
    "distance_so_far = 0\n",
    "EMPTY_POINT = shp.geometry.Point()\n",
    "\n",
    "def merge_row_with_distance(loc_row):\n",
    "    global distance_so_far\n",
    "    source = None\n",
    "    more_details = False\n",
    "    # print(\"merging %s at distance %s\" % (loc_row, distance_so_far))\n",
    "    if 430 <= loc_row.name <= 440:\n",
    "        more_details = True\n",
    "        print(\"merging %s at distance %s\" % (loc_row, distance_so_far))\n",
    "    if pd.isnull(loc_row.geometry_i):\n",
    "        assert not pd.isnull(loc_row.geometry_a)\n",
    "        if loc_row.distance_along_a > distance_so_far:\n",
    "            final_geom = loc_row.geometry_a\n",
    "            source = \"android\"\n",
    "        else:\n",
    "            final_geom = EMPTY_POINT\n",
    "    elif pd.isnull(loc_row.geometry_a):\n",
    "        assert not pd.isnull(loc_row.geometry_i)\n",
    "        if loc_row.distance_along_i > distance_so_far:\n",
    "            final_geom = loc_row.geometry_i\n",
    "            source = \"ios\"\n",
    "        else:\n",
    "            final_geom = EMPTY_POINT\n",
    "    else:\n",
    "        assert not pd.isnull(loc_row.geometry_i) and not pd.isnull(loc_row.geometry_a)\n",
    "        choice_series = gpd.GeoSeries([loc_row.geometry_a, loc_row.geometry_i])\n",
    "        distance_along_line_series = gpd.GeoSeries([loc_row.distance_along_a, loc_row.distance_along_i])\n",
    "        if more_details:\n",
    "            print(\"distance_along_line = %s\" % distance_along_line_series)\n",
    "        distance_from_last_series = distance_along_line_series.apply(lambda d: d - distance_so_far)\n",
    "        if more_details:\n",
    "            print(\"distance_from_last_series = %s\" % distance_from_last_series)\n",
    "\n",
    "        # assert not (distance_from_last_series < 0).all(), \"distance_so_far = %s, distance_from_last = %s\" % (distance_so_far, distance_from_last_series)\n",
    "        if (distance_from_last_series < 0).all():\n",
    "            if more_details:\n",
    "                print(\"all distances are negative, skipping...\")\n",
    "            final_geom = EMPTY_POINT\n",
    "        else:\n",
    "            if (distance_from_last_series < 0).any():\n",
    "                # avoid going backwards along the linestring (wonder how this works with San Jose u-turn)\n",
    "                closer_idx = distance_from_last_series.idxmax()\n",
    "                if more_details:\n",
    "                    print(\"one distance is going backwards, found closer_idx = %d\" % closer_idx)\n",
    "\n",
    "            else:\n",
    "                closer_idx = distance_from_last_series.idxmin()\n",
    "                if more_details:\n",
    "                    print(\"both distances are positive, found closer_idx = %d\" % closer_idx)\n",
    "\n",
    "            if closer_idx == 0:\n",
    "                source = \"android\"\n",
    "            else:\n",
    "                source = \"ios\"\n",
    "            final_geom = choice_series.loc[closer_idx]\n",
    "\n",
    "    if final_geom != EMPTY_POINT:\n",
    "        distance_so_far = gt_linestring.project(final_geom) * (R/360)\n",
    "        \n",
    "    if more_details:\n",
    "        print(\"final_geom = %s, new_distance_so_far = %s\" % (final_geom, distance_so_far))\n",
    "    if final_geom == EMPTY_POINT:\n",
    "        return {\n",
    "            \"ts\": loc_row.ts,\n",
    "            \"fmt_time\": arrow.get(loc_row.ts).to(\"America/Los_Angeles\"),\n",
    "            \"longitude\": np.nan,\n",
    "            \"latitude\": np.nan,\n",
    "            \"geometry\": EMPTY_POINT    \n",
    "        }\n",
    "    else:\n",
    "        return {\n",
    "            \"ts\": loc_row.ts,\n",
    "            \"fmt_time\": arrow.get(loc_row.ts).to(\"America/Los_Angeles\"),\n",
    "            \"longitude\": final_geom.x,\n",
    "            \"latitude\": final_geom.y,\n",
    "            \"geometry\": final_geom,\n",
    "            \"distance_along\": gt_linestring.project(final_geom),\n",
    "            \"error\": final_geom.distance(gt_linestring),\n",
    "            \"source\": source\n",
    "        }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "distance_so_far = 0\n",
    "initial_reference_gpdf = gpd.GeoDataFrame(data=list(merged_gpdf.apply(merge_row_with_distance, axis=1))); reference_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "reference_gpdf = initial_reference_gpdf[initial_reference_gpdf.latitude.notnull()]; print(len(reference_gpdf)/len(initial_reference_gpdf), len(reference_gpdf)/len(new_ts_range))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import folium"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_new_android_gpdf.latitude.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "curr_map = folium.Map()\n",
    "gt_leg_gj = sd_ucb.get_geojson_for_leg(gt_leg)\n",
    "sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(filtered_new_android_gpdf.longitude, filtered_new_android_gpdf.latitude))),properties={\"style\": {\"color\": \"red\"}, \"ts\": [int(t) for t in filtered_new_android_gpdf.ts]})\n",
    "i_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(filtered_new_ios_gpdf.longitude, filtered_new_ios_gpdf.latitude))),properties={\"style\": {\"color\": \"purple\"}, \"ts\": [int(t) for t in filtered_new_ios_gpdf.ts]})\n",
    "old_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(android_control_gpdf.longitude, android_control_gpdf.latitude))),properties={\"style\": {\"color\": \"yellow\"}, \"ts\": [int(t) for t in android_control_gpdf.ts]})\n",
    "filtered_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(reference_gpdf.longitude, reference_gpdf.latitude))),properties={\"style\": {\"color\": \"blue\"}, \"ts\": [int(t) for t in reference_gpdf.ts]})\n",
    "gt_leg_gj_feature = folium.GeoJson(gt_leg_gj, name=\"ground_truth\")\n",
    "gt_leg_gj_points = ezpv.get_point_markers(gt_leg_gj[2], name=\"ground_truth_points\", color=\"green\")\n",
    "sensed_leg_gj_feature = folium.GeoJson(sensed_section_gj, name=\"sensed_values (android)\")\n",
    "i_sensed_leg_gj_feature = folium.GeoJson(i_sensed_section_gj, name=\"sensed_values (ios)\")\n",
    "old_sensed_leg_gj_feature = folium.GeoJson(old_sensed_section_gj, name=\"old sensed_values\")\n",
    "filtered_sensed_leg_gj_feature = folium.GeoJson(filtered_sensed_section_gj, name=\"filtered sensed_values\")\n",
    "sensed_leg_gj_points = ezpv.get_point_markers(sensed_section_gj, name=\"sensed_points(android) \", color=\"red\", tz=\"America/Los_Angeles\")\n",
    "i_sensed_leg_gj_points = ezpv.get_point_markers(i_sensed_section_gj, name=\"sensed_points (ios)\", color=\"purple\", tz=\"America/Los_Angeles\")\n",
    "old_sensed_leg_gj_points = ezpv.get_point_markers(old_sensed_section_gj, name=\"old_sensed_points\", color=\"yellow\", tz=\"America/Los_Angeles\")\n",
    "filtered_sensed_leg_gj_points = ezpv.get_point_markers(filtered_sensed_section_gj, name=\"filtered_sensed_points\", color=\"blue\", tz=\"America/Los_Angeles\")\n",
    "curr_map.add_child(gt_leg_gj_feature)\n",
    "curr_map.add_child(gt_leg_gj_points)\n",
    "curr_map.add_child(sensed_leg_gj_feature)\n",
    "curr_map.add_child(sensed_leg_gj_points)\n",
    "curr_map.add_child(i_sensed_leg_gj_feature)\n",
    "curr_map.add_child(i_sensed_leg_gj_points)\n",
    "curr_map.add_child(old_sensed_leg_gj_feature)\n",
    "curr_map.add_child(old_sensed_leg_gj_points)\n",
    "curr_map.add_child(filtered_sensed_leg_gj_feature)\n",
    "curr_map.add_child(filtered_sensed_leg_gj_points)\n",
    "curr_map.fit_bounds(sensed_leg_gj_feature.get_bounds())\n",
    "folium.LayerControl().add_to(curr_map)\n",
    "curr_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reference_gpdf.iloc[430:435]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged_gpdf[merged_gpdf.longitude_i == -121.89511652921553]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.concat([merged_gpdf.loc[430:440]], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.concat([reference_gpdf.iloc[430:440]], axis='index')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reference_gpdf[reference_gpdf.longitude == -122.46802100069702]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}