exploration_trajectory_timestamp_many_alternatives.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": [
    "importlib.reload(ezpv)"
   ]
  },
  {
   "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"
   ]
  },
  {
   "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.snap`: Easy case (max spatial error for accuracy control < 20 m)\n",
    "\n",
    "works pretty well"
   ]
  },
  {
   "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]\n",
    "ios_trip = pv_la.map()[\"ios\"][\"ucb-sdb-ios-1\"][\"evaluation_ranges\"][1][\"evaluation_trip_ranges\"][0]\n",
    "android_accuracy_df = android_trip[\"location_df\"]\n",
    "ios_accuracy_df = ios_trip[\"location_df\"]"
   ]
  },
  {
   "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": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "len(android_control_gpdf), len(ios_control_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "snapped_result = shp.ops.snap(shp.geometry.LineString(coordinates=list(zip(android_control_gpdf.longitude, android_control_gpdf.latitude))),\n",
    "             shp.geometry.LineString(coordinates=list(zip(ios_control_gpdf.longitude, ios_control_gpdf.latitude))),\n",
    "            tolerance=TEN_METERS_IN_DEGREES); snapped_result"
   ]
  },
  {
   "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 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(snapped_result.coords)), properties={\"style\": {\"color\": \"red\"}})\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 = sensed_section_gj\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.snap`: Hard case (android accuracy is just completely messed up)\n",
    "\n",
    "does not work well. And we don't have the distances to do any kind of filtering"
   ]
  },
  {
   "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\"]"
   ]
  },
  {
   "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": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "len(android_control_gpdf), len(ios_control_gpdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "snapped_result = shp.ops.snap(shp.geometry.LineString(coordinates=list(zip(android_control_gpdf.longitude, android_control_gpdf.latitude))),\n",
    "             shp.geometry.LineString(coordinates=list(zip(ios_control_gpdf.longitude, ios_control_gpdf.latitude))),\n",
    "            tolerance=TEN_METERS_IN_DEGREES); snapped_result"
   ]
  },
  {
   "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 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(snapped_result.coords)), properties={\"style\": {\"color\": \"red\"}})\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 = sensed_section_gj\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`: Easy case\n",
    "\n",
    "Works pretty well (97.25% retained)"
   ]
  },
  {
   "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]\n",
    "ios_trip = pv_la.map()[\"ios\"][\"ucb-sdb-ios-1\"][\"evaluation_ranges\"][1][\"evaluation_trip_ranges\"][0]\n",
    "android_accuracy_df = android_trip[\"location_df\"]\n",
    "ios_accuracy_df = ios_trip[\"location_df\"]"
   ]
  },
  {
   "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": {
    "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=android_control_gpdf.ts, y=android_control_gpdf.latitude, fill_value=\"extrapolate\")\n",
    "android_lon_fn = sci.interp1d(x=android_control_gpdf.ts, y=android_control_gpdf.longitude, fill_value=\"extrapolate\")\n",
    "ios_lat_fn = sci.interp1d(x=ios_control_gpdf.ts, y=ios_control_gpdf.latitude, fill_value=\"extrapolate\")\n",
    "ios_lon_fn = sci.interp1d(x=ios_control_gpdf.ts, y=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(new_ios_gpdf) * (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_android_gpdf = new_android_gpdf[valid_mask]; filtered_android_gpdf.head()\n",
    "filtered_ios_gpdf = new_ios_gpdf[valid_mask]; filtered_ios_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_ratio = len(filtered_android_gpdf)/len(new_android_gpdf)\n",
    "assert valid_ratio == len(filtered_ios_gpdf)/len(new_ios_gpdf)\n",
    "valid_ratio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax = plt.subplots(nrows=1, ncols=1, figsize=(15,15))\n",
    "# android_control_gpdf.plot(ax=ax)\n",
    "# ios_control_gpdf.plot(ax=ax)\n",
    "new_android_gpdf.plot(ax=ax)\n",
    "new_ios_gpdf.plot(ax=ax)\n",
    "filtered_android_gpdf.plot(ax=ax)\n",
    "filtered_ios_gpdf.plot(ax=ax)"
   ]
  },
  {
   "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": [
    "new_android_gpdf[\"fmt_time\"] = new_android_gpdf.ts.apply(lambda ts: arrow.get(ts).to(\"America/Los_Angeles\"))"
   ]
  },
  {
   "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(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(filtered_android_gpdf.longitude, filtered_android_gpdf.latitude))),properties={\"style\": {\"color\": \"blue\"}, \"ts\": list(filtered_android_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\"]"
   ]
  },
  {
   "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": {
    "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=android_control_gpdf.ts, y=android_control_gpdf.latitude, fill_value=\"extrapolate\")\n",
    "android_lon_fn = sci.interp1d(x=android_control_gpdf.ts, y=android_control_gpdf.longitude, fill_value=\"extrapolate\")\n",
    "ios_lat_fn = sci.interp1d(x=ios_control_gpdf.ts, y=ios_control_gpdf.latitude, fill_value=\"extrapolate\")\n",
    "ios_lon_fn = sci.interp1d(x=ios_control_gpdf.ts, y=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(new_ios_gpdf) * (R/360); distances.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_mask = distances <= 10; np.nonzero(np.logical_not(valid_mask))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_android_gpdf = new_android_gpdf[valid_mask]; filtered_android_gpdf.head()\n",
    "filtered_ios_gpdf = new_ios_gpdf[valid_mask]; filtered_ios_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_ratio = len(filtered_android_gpdf)/len(new_android_gpdf)\n",
    "assert valid_ratio == len(filtered_ios_gpdf)/len(new_ios_gpdf)\n",
    "valid_ratio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax = plt.subplots(nrows=1, ncols=1, figsize=(15,15))\n",
    "# android_control_gpdf.plot(ax=ax)\n",
    "# ios_control_gpdf.plot(ax=ax)\n",
    "# new_android_gpdf.plot(ax=ax)\n",
    "# new_ios_gpdf.plot(ax=ax)\n",
    "filtered_android_gpdf.plot(ax=ax)\n",
    "filtered_ios_gpdf.plot(ax=ax)"
   ]
  },
  {
   "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": [
    "new_android_gpdf[\"fmt_time\"] = new_android_gpdf.ts.apply(lambda ts: arrow.get(ts).to(\"America/Los_Angeles\"))"
   ]
  },
  {
   "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(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(filtered_android_gpdf.longitude, filtered_android_gpdf.latitude))),properties={\"style\": {\"color\": \"blue\"}, \"ts\": list(filtered_android_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`: Temporal accuracy check\n",
    "\n",
    "Now let's check this for the temporal accuracy motivating use case"
   ]
  },
  {
   "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\"]"
   ]
  },
  {
   "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": {
    "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=android_control_gpdf.ts, y=android_control_gpdf.latitude, fill_value=\"extrapolate\")\n",
    "android_lon_fn = sci.interp1d(x=android_control_gpdf.ts, y=android_control_gpdf.longitude, fill_value=\"extrapolate\")\n",
    "ios_lat_fn = sci.interp1d(x=ios_control_gpdf.ts, y=ios_control_gpdf.latitude, fill_value=\"extrapolate\")\n",
    "ios_lon_fn = sci.interp1d(x=ios_control_gpdf.ts, y=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(new_ios_gpdf) * (R/360); distances.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_mask = distances <= 10; np.nonzero(np.logical_not(valid_mask))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_android_gpdf = new_android_gpdf[valid_mask]; filtered_android_gpdf.head()\n",
    "filtered_ios_gpdf = new_ios_gpdf[valid_mask]; filtered_ios_gpdf.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_ratio = len(filtered_android_gpdf)/len(new_android_gpdf)\n",
    "assert valid_ratio == len(filtered_ios_gpdf)/len(new_ios_gpdf)\n",
    "valid_ratio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax_array = plt.subplots(nrows=1, ncols=2, figsize=(15,15))\n",
    "android_control_gpdf.plot(ax=ax_array[0])\n",
    "ios_control_gpdf.plot(ax=ax_array[0])\n",
    "# new_android_gpdf.plot(ax=ax)\n",
    "# new_ios_gpdf.plot(ax=ax)\n",
    "filtered_android_gpdf.plot(ax=ax_array[1])\n",
    "filtered_ios_gpdf.plot(ax=ax_array[1])"
   ]
  },
  {
   "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": [
    "new_android_gpdf[\"fmt_time\"] = new_android_gpdf.ts.apply(lambda ts: arrow.get(ts).to(\"America/Los_Angeles\"))"
   ]
  },
  {
   "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(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",
    "oldi_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(ios_control_gpdf.longitude, ios_control_gpdf.latitude))),properties={\"style\": {\"color\": \"red\"}, \"ts\": list(ios_control_gpdf.ts)})\n",
    "filtered_sensed_section_gj = gj.Feature(geometry=gj.LineString(coordinates=list(zip(filtered_android_gpdf.longitude, filtered_android_gpdf.latitude))),properties={\"style\": {\"color\": \"blue\"}, \"ts\": list(filtered_android_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=\"sensed_values (android)\")\n",
    "oldi_sensed_leg_gj_feature = folium.GeoJson(oldi_sensed_section_gj, name=\"sensed_values (ios)\")\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=\"sensed_points (android)\", color=\"yellow\", tz=\"America/Los_Angeles\")\n",
    "oldi_sensed_leg_gj_points = ezpv.get_point_markers(oldi_sensed_section_gj, name=\"sensed_points (ios)\", color=\"red\", 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(oldi_sensed_leg_gj_feature)\n",
    "curr_map.add_child(oldi_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": [
    "android_control_gpdf.iloc[-1].ts, android_control_gpdf.iloc[-1].ts + 60 * 60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pv_ucb.map()[\"android\"][\"ucb-sdb-android-1\"][\"evaluation_ranges\"][0][\"location_df\"].query(\"ts > 1563986933 & ts < 1563990533\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_android_gpdf.loc[71:83]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_polygons(pvunp):\n",
    "    \"\"\"\n",
    "    Return GeoSeries of polygons\n",
    "    \"\"\"\n",
    "    polygons = []\n",
    "    trips = pvunp.spec_details.curr_spec['evaluation_trips']\n",
    "\n",
    "    for trip in trips:\n",
    "        for leg in trip['legs']:\n",
    "            if 'loc' in leg and leg['loc']['geometry']['type'] == 'Polygon':\n",
    "                polygons.append(shp.geometry.Polygon(leg['loc']['geometry']['coordinates'][0]))\n",
    "            if 'end_loc' in leg and leg['end_loc']['geometry']['type'] == 'Polygon':\n",
    "                polygons.append(shp.geometry.Polygon(leg['end_loc']['geometry']['coordinates'][0]))\n",
    "            if 'start_loc' in leg and leg['start_loc']['geometry']['type'] == 'Polygon':\n",
    "                polygons.append(shp.geometry.Polygon(leg['start_loc']['geometry']['coordinates'][0]))\n",
    "    return gpd.GeoSeries(polygons)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_point_outside_polygons(loc_row, polygons):\n",
    "    \"\"\"\n",
    "    Utility function to check if a point represented by a row in a location dataframe\n",
    "    is contained within a series of Shapely polygons\n",
    "    \"\"\"\n",
    "    # print(loc_row)\n",
    "    point = loc_row.geometry\n",
    "    inside_polygons = polygons.contains(point)\n",
    "    return not inside_polygons.any()\n",
    "\n",
    "def get_travel_trajectory(df, polygons):\n",
    "    \"\"\" \n",
    "    Filters the dataframe of location points to only include values outside the defined polygons\n",
    "    \"\"\"\n",
    "    geo_df = gpd.GeoDataFrame(\n",
    "        df, geometry=df.apply(lambda lr: shp.geometry.Point(lr.longitude, lr.latitude), axis=1))\n",
    "    geo_df[\"outside_polygons\"] = geo_df.apply(lambda r: is_point_outside_polygons(r, polygons), axis=1)\n",
    "    # return a slice instead of setting a column value\n",
    "    return geo_df.query(\"outside_polygons==True\")\n",
    "\n",
    "def get_gt_linestring(gt_leg):\n",
    "    \"\"\"\n",
    "    Get lat-long corrdinates in ground truth\n",
    "    \"\"\"\n",
    "    if 'route_coords' in gt_leg:\n",
    "        coords = gt_leg['route_coords']['geometry']['coordinates']\n",
    "    else:\n",
    "        coords = []\n",
    "    return shp.geometry.LineString(coords)\n",
    "\n",
    "def get_measured_points(df, polygons):\n",
    "    \"\"\"\n",
    "    Get lat-long coordinates recorded from phone\n",
    "    \"\"\"\n",
    "    return get_travel_trajectory(df, polygons)\n",
    "\n",
    "def get_projection(loc_row, line):\n",
    "    point = geometry.Point(loc_row.longitude, loc_row.latitude)\n",
    "    return point.distance(line)\n",
    "\n",
    "def get_shortest_distances(df, line):\n",
    "    \"\"\"\n",
    "    Returns a series representing the distances from each point in a location dataframe to a line\n",
    "    \"\"\"\n",
    "    return df.distance(line)\n",
    "\n",
    "def convert_to_xy(points):\n",
    "    xy_points = []\n",
    "    R = 6371000 # Radius of the earth in m\n",
    "    \n",
    "    for point in points:\n",
    "        lon = point[0]\n",
    "        lat = point[1]\n",
    "        \n",
    "        theta = math.pi/2 - math.radians(lat) \n",
    "        phi = math.radians(lon)\n",
    "        \n",
    "        x = R * math.sin(theta) * math.cos(phi)\n",
    "        y = R * math.sin(theta) * math.sin(phi)\n",
    "        xy_points.append([x, y])\n",
    "        \n",
    "    return xy_points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_spatial_errors(pvunp):\n",
    "    spatial_error_list = []\n",
    "    # This is a GeoSeries\n",
    "    polygons = get_polygons(pvunp)\n",
    "    \n",
    "    for phone_os, phone_map in pvunp.map().items():\n",
    "        for phone_label, phone_detail_map in phone_map.items():\n",
    "            for (r_idx, r) in enumerate(phone_detail_map[\"evaluation_ranges\"]):\n",
    "                run_errors = []\n",
    "                for (tr_idx, tr) in enumerate(r[\"evaluation_trip_ranges\"]):\n",
    "                    trip_errors = []\n",
    "                    for (sr_idx, sr) in enumerate(tr[\"evaluation_section_ranges\"]):\n",
    "                        # This is a Shapely LineString\n",
    "                        section_gt_leg = pvunp.spec_details.get_ground_truth_for_leg(tr[\"trip_id_base\"], sr[\"trip_id_base\"])\n",
    "                        section_gt_points = get_gt_linestring(section_gt_leg)\n",
    "                        if section_gt_points.is_empty:\n",
    "                            print(\"No ground truth route for %s %s, must be polygon, skipping...\" % (tr[\"trip_id_base\"], sr[\"trip_id_base\"]))\n",
    "                            assert section_gt_leg[\"type\"] != \"TRAVEL\", \"For %s, %s, %s, %s, %s found type %s\" % (phone_os, phone_label, r_idx, tr_idx, sr_idx, section_gt_leg[\"type\"])\n",
    "                            continue\n",
    "                        if len(sr['location_df']) == 0:\n",
    "                            print(\"No sensed locations found, role = %s skipping...\" % (r[\"eval_role_base\"]))\n",
    "                            # assert r[\"eval_role_base\"] == \"power_control\", \"Found no locations for %s, %s, %s, %s, %s\" % (phone_os, phone_label, r_idx, tr_idx, sr_idx)\n",
    "                            continue\n",
    "\n",
    "                        # This is a GeoDataFrame\n",
    "                        section_measured_points = get_measured_points(sr['location_df'], polygons)\n",
    "                        line = section_gt_points\n",
    "                        degree_dist = get_shortest_distances(section_measured_points.geometry, line)\n",
    "                        meter_dist = degree_dist * (6371000/360) # Radius of the earth in m\n",
    "                        spatial_error_entries = [{\"phone_os\": phone_os, \"phone_label\": phone_label,\n",
    "                                               \"timeline\": pvunp.spec_details.curr_spec[\"id\"],\n",
    "                                               \"run\": r_idx, \"role\": r[\"eval_role_base\"],\n",
    "                                               \"trip_id\": tr[\"trip_id_base\"], \"section_id\": sr[\"trip_id_base\"],\n",
    "                                               \"error\": e} for e in meter_dist]\n",
    "                        spatial_error_list.extend(spatial_error_entries)\n",
    "    return spatial_error_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spatial_errors_list = []\n",
    "spatial_errors_list.extend(get_spatial_errors(pv_la))\n",
    "spatial_errors_list.extend(get_spatial_errors(pv_sj))\n",
    "spatial_errors_list.extend(get_spatial_errors(pv_ucb))\n",
    "\n",
    "spatial_errors_df = pd.DataFrame(spatial_errors_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r2q_map = {\"power_control\": 0, \"HAMFDC\": 1, \"MAHFDC\": 2, \"HAHFDC\": 3, \"accuracy_control\": 4}\n",
    "q2r_map = {0: \"power\", 1: \"HAMFDC\", 2: \"MAHFDC\", 3: \"HAHFDC\", 4: \"accuracy\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spatial_errors_df[\"quality\"] = spatial_errors_df.role.apply(lambda r: r2q_map[r])\n",
    "spatial_errors_df[\"label\"] = spatial_errors_df.role.apply(lambda r: r.replace('_control', ''))\n",
    "timeline_list = [\"train_bus_ebike_mtv_ucb\", \"car_scooter_brex_san_jose\", \"unimodal_trip_car_bike_mtv_la\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spatial_errors_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spatial_errors_df.query('timeline == \"train_bus_ebike_mtv_ucb\" & run == 0 & phone_os == \"android\" & quality == 0').error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ifig, ax_array = plt.subplots(nrows=2,ncols=3,figsize=(12,6), sharex=False, sharey=False)\n",
    "timeline_list = [\"train_bus_ebike_mtv_ucb\", \"car_scooter_brex_san_jose\", \"unimodal_trip_car_bike_mtv_la\"]\n",
    "for i, tl in enumerate(timeline_list):\n",
    "    spatial_errors_df.query(\"timeline == @tl & phone_os == 'android' & quality > 0\").boxplot(ax = ax_array[0][i], column=[\"error\"], by=[\"quality\"])\n",
    "    ax_array[0][i].set_title(tl)\n",
    "    spatial_errors_df.query(\"timeline == @tl & phone_os == 'ios' & quality > 0\").boxplot(ax = ax_array[1][i], column=[\"error\"], by=[\"quality\"])\n",
    "    ax_array[1][i].set_title(\"\")\n",
    "\n",
    "for i, ax in enumerate(ax_array[0]):\n",
    "    ax.set_xticklabels([q2r_map[int(t.get_text())] for t in ax.get_xticklabels()])\n",
    "    ax.set_xlabel(\"\")\n",
    "\n",
    "for i, ax in enumerate(ax_array[1]):\n",
    "    ax.set_xticklabels([q2r_map[int(t.get_text())] for t in ax.get_xticklabels()])\n",
    "    ax.set_xlabel(\"\")\n",
    "\n",
    "ax_array[0][0].set_ylabel(\"Battery drain (android)\")\n",
    "ax_array[1][0].set_ylabel(\"Battery drain (iOS)\")\n",
    "ifig.suptitle(\"Power v/s quality over multiple timelines\")\n",
    "# ifig.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "ifig, ax_array = plt.subplots(nrows=2,ncols=4,figsize=(25,10), sharex=True, sharey=True)\n",
    "timeline_list = [\"train_bus_ebike_mtv_ucb\"]\n",
    "for i, tl in enumerate(timeline_list):\n",
    "    for q in range(1,5):\n",
    "        sel_df = spatial_errors_df.query(\"timeline == @tl & phone_os == 'android' & quality == @q\")\n",
    "        if len(sel_df) > 0:\n",
    "            sel_df.boxplot(ax = ax_array[2*i][q-1], column=[\"error\"], by=[\"section_id\"])\n",
    "        ax_array[2*i][q-1].tick_params(axis=\"x\", labelrotation=45)\n",
    "        sel_df = spatial_errors_df.query(\"timeline == @tl & phone_os == 'ios' & quality == @q\")\n",
    "        if len(sel_df) > 0:\n",
    "            sel_df.boxplot(ax = ax_array[2*i+1][q-1], column=[\"error\"], by=[\"section_id\"])\n",
    "#        ax_array[i][].set_title(\"\")\n",
    "\n",
    "def make_acronym(s):\n",
    "    ssl = s.split(\"_\")\n",
    "    # print(\"After splitting %s, we get %s\" % (s, ssl))\n",
    "    if len(ssl) == 0 or len(ssl[0]) == 0:\n",
    "        return \"\"\n",
    "    else:\n",
    "        return \"\".join([ss[0] for ss in ssl])\n",
    "\n",
    "for q in range(1,5):\n",
    "    ax_array[0][q-1].set_title(q2r_map[q])\n",
    "    curr_ticks = [t.get_text() for t in ax_array[1][q-1].get_xticklabels()]\n",
    "    new_ticks = [make_acronym(t) for t in curr_ticks]\n",
    "    ax_array[1][q-1].set_xticklabels(new_ticks)\n",
    "    \n",
    "print(list(zip(curr_ticks, new_ticks)))\n",
    "# fig.text(0,0,\"%s\"% list(zip(curr_ticks, new_ticks)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "timeline_list = [\"train_bus_ebike_mtv_ucb\"]\n",
    "for i, tl in enumerate(timeline_list):\n",
    "    unique_sections = spatial_errors_df.query(\"timeline == @tl\").section_id.unique()\n",
    "    ifig, ax_array = plt.subplots(nrows=2,ncols=len(unique_sections),figsize=(40,10), sharex=True, sharey=False)\n",
    "    for sid, s_name in enumerate(unique_sections):\n",
    "        sel_df = spatial_errors_df.query(\"timeline == @tl & phone_os == 'android' & section_id == @s_name & quality > 0\")\n",
    "        if len(sel_df) > 0:\n",
    "            sel_df.boxplot(ax = ax_array[2*i][sid], column=[\"error\"], by=[\"quality\"])\n",
    "        ax_array[2*i][sid].set_title(s_name)\n",
    "        sel_df = spatial_errors_df.query(\"timeline == @tl & phone_os == 'ios' & section_id == @s_name & quality > 0\")\n",
    "        if len(sel_df) > 0:\n",
    "            sel_df.boxplot(ax = ax_array[2*i+1][sid], column=[\"error\"], by=[\"quality\"])\n",
    "        ax_array[2*i+1][sid].set_title(\"\")\n",
    "#        ax_array[i][].set_title(\"\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Focus only on sections where the max error is > 100 meters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timeline_list = [\"train_bus_ebike_mtv_ucb\"]\n",
    "for i, tl in enumerate(timeline_list):\n",
    "    unique_sections = pd.Series(spatial_errors_df.query(\"timeline == @tl\").section_id.unique())\n",
    "    sections_with_outliers_mask = unique_sections.apply(lambda s_name: spatial_errors_df.query(\"timeline == 'train_bus_ebike_mtv_ucb' & section_id == @s_name\").error.max() > 100)\n",
    "    sections_with_outliers = unique_sections[sections_with_outliers_mask]   \n",
    "    ifig, ax_array = plt.subplots(nrows=2,ncols=len(sections_with_outliers),figsize=(16,4), sharex=True, sharey=False)\n",
    "    for sid, s_name in enumerate(sections_with_outliers):\n",
    "        sel_df = spatial_errors_df.query(\"timeline == @tl & phone_os == 'android' & section_id == @s_name & quality > 0\")\n",
    "        if len(sel_df) > 0:\n",
    "            sel_df.boxplot(ax = ax_array[2*i][sid], column=[\"error\"], by=[\"quality\"])\n",
    "        ax_array[2*i][sid].set_title(s_name)\n",
    "        sel_df = spatial_errors_df.query(\"timeline == @tl & phone_os == 'ios' & section_id == @s_name & quality > 0\")\n",
    "        if len(sel_df) > 0:\n",
    "            sel_df.boxplot(ax = ax_array[2*i+1][sid], column=[\"error\"], by=[\"quality\"])\n",
    "        ax_array[2*i+1][sid].set_title(\"\")\n",
    "#        ax_array[i][].set_title(\"\")\n",
    "    ifig.suptitle(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validation of outliers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (express bus iOS, MAHFDC)\n",
    "\n",
    "ok, so it looks like the error is non-trivial across all runs, but run #1 is the worst and is responsible for the majority of the outliers. And this is borne out by the map, where on run #1, we end up with points in San Leandro!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spatial_errors_df.query(\"phone_os == 'ios' & quality == 2 & section_id == 'express_bus' & error > 500\").run.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "spatial_errors_df.query(\"phone_os == 'ios' & quality == 2 & section_id == 'express_bus'\").boxplot(column=\"error\", by=\"run\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ucb_and_back = pv_ucb.map()[\"ios\"][\"ucb-sdb-ios-3\"][\"evaluation_ranges\"][1]; ucb_and_back[\"trip_id\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "back_trip = ucb_and_back[\"evaluation_trip_ranges\"][2]; print(back_trip[\"trip_id\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eb_leg = back_trip[\"evaluation_section_ranges\"][4]; print(eb_leg[\"trip_id\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "gt_leg = sd_ucb.get_ground_truth_for_leg(back_trip[\"trip_id_base\"], eb_leg[\"trip_id_base\"]); gt_leg[\"id\"]"
   ]
  },
  {
   "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 = ezpv.get_geojson_for_leg(eb_leg)\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",
    "sensed_leg_gj_points = ezpv.get_point_markers(sensed_section_gj, name=\"sensed_points\", color=\"red\", 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.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": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "curr_map = folium.Map()\n",
    "gt_leg_gj = sd_ucb.get_geojson_for_leg(gt_leg)\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",
    "\n",
    "colors = [\"red\", \"yellow\", \"blue\"]\n",
    "for run in range(3):\n",
    "    ucb_and_back = pv_ucb.map()[\"ios\"][\"ucb-sdb-ios-3\"][\"evaluation_ranges\"][run]; ucb_and_back[\"trip_id\"]\n",
    "    back_trip = ucb_and_back[\"evaluation_trip_ranges\"][2]; print(back_trip[\"trip_id\"])\n",
    "    eb_leg = back_trip[\"evaluation_section_ranges\"][4]; print(eb_leg[\"trip_id\"])\n",
    "    sensed_section_gj = ezpv.get_geojson_for_leg(eb_leg)\n",
    "    sensed_section_gj[\"properties\"][\"style\"][\"color\"] = colors[run]\n",
    "    sensed_leg_gj_feature = folium.GeoJson(sensed_section_gj, name=\"run %s\" % run)\n",
    "    sensed_leg_gj_points = ezpv.get_point_markers(sensed_section_gj, name=\"points for %d\" % run, color=colors[run], tz=\"America/Los_Angeles\")\n",
    "    curr_map.add_child(sensed_leg_gj_feature)\n",
    "    curr_map.add_child(sensed_leg_gj_points)\n",
    "    \n",
    "curr_map.add_child(gt_leg_gj_feature)\n",
    "curr_map.add_child(gt_leg_gj_points)\n",
    "curr_map.fit_bounds(gt_leg_gj_feature.get_bounds())\n",
    "folium.LayerControl().add_to(curr_map)\n",
    "curr_map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (commuter rail aboveground android, HAMFDC)\n",
    "\n",
    "ok, so it looks like the error is non-trivial across all runs, but run #1 is the worst and is responsible for the majority of the outliers. And this is borne out by the map, where on run #1, we end up with points in San Leandro!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spatial_errors_df.query(\"phone_os == 'android' & quality == 1 & section_id == 'commuter_rail_aboveground' & error > 500\").run.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ucb_and_back = pv_ucb.map()[\"android\"][\"ucb-sdb-android-3\"][\"evaluation_ranges\"][0]; ucb_and_back[\"trip_id\"]\n",
    "to_trip = ucb_and_back[\"evaluation_trip_ranges\"][0]; print(to_trip[\"trip_id\"])\n",
    "train_leg = to_trip[\"evaluation_section_ranges\"][2]; print(train_leg[\"trip_id\"])\n",
    "gt_leg = sd_ucb.get_ground_truth_for_leg(to_trip[\"trip_id_base\"], train_leg[\"trip_id_base\"]); gt_leg[\"id\"]"
   ]
  },
  {
   "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 = ezpv.get_geojson_for_leg(train_leg)\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",
    "sensed_leg_gj_points = ezpv.get_point_markers(sensed_section_gj, name=\"sensed_points\", color=\"red\", 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.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": [
    "unique_sections = pd.Series(spatial_errors_df.query(\"timeline == 'train_bus_ebike_mtv_ucb'\").section_id.unique())\n",
    "sections_with_outliers_mask = unique_sections.apply(lambda s_name: spatial_errors_df.query(\"timeline == 'train_bus_ebike_mtv_ucb' & section_id == @s_name\").error.max() > 100)\n",
    "unique_sections[sections_with_outliers_mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (walk_to_bus android, HAMFDC, HAHFDC)\n",
    "\n",
    "ok, so it looks like the error is non-trivial across all runs, but run #1 is the worst and is responsible for the majority of the outliers. And this is borne out by the map, where on run #1, we end up with points in San Leandro!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "spatial_errors_df.query(\"phone_os == 'android' & (quality == 1 | quality == 3) & section_id == 'walk_to_bus' & error > 500\").run.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spatial_errors_df.query(\"phone_os == 'android' & (quality == 1 | quality == 3) & section_id == 'walk_to_bus' & error > 500\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "spatial_errors_df.query(\"phone_os == 'android' & (quality == 1 | quality == 3) & section_id == 'walk_to_bus'\").boxplot(column=\"error\", by=\"run\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ucb_and_back = pv_ucb.map()[\"android\"][\"ucb-sdb-android-2\"][\"evaluation_ranges\"][0]; ucb_and_back[\"trip_id\"]\n",
    "to_trip = ucb_and_back[\"evaluation_trip_ranges\"][0]; print(to_trip[\"trip_id\"])\n",
    "wb_leg = to_trip[\"evaluation_section_ranges\"][6]; print(wb_leg[\"trip_id\"])\n",
    "gt_leg = sd_ucb.get_ground_truth_for_leg(to_trip[\"trip_id_base\"], wb_leg[\"trip_id_base\"]); gt_leg[\"id\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import folium"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "curr_map = folium.Map()\n",
    "gt_leg_gj = sd_ucb.get_geojson_for_leg(gt_leg)\n",
    "sensed_section_gj = ezpv.get_geojson_for_leg(wb_leg)\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",
    "sensed_leg_gj_points = ezpv.get_point_markers(sensed_section_gj, name=\"sensed_points\", color=\"red\", 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.fit_bounds(sensed_leg_gj_feature.get_bounds())\n",
    "folium.LayerControl().add_to(curr_map)\n",
    "curr_map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (light_rail_below_above_ground, android, accuracy_control)\n",
    "\n",
    "ok, so it looks like the error is non-trivial across all runs, but run #1 is the worst and is responsible for the majority of the outliers. And this is borne out by the map, where on run #1, we end up with points in San Leandro!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "spatial_errors_df.query(\"phone_os == 'android' & quality == 4 & section_id == 'light_rail_below_above_ground' & error > 100\").run.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "spatial_errors_df.query(\"phone_os == 'android' & (quality == 4) & section_id == 'light_rail_below_above_ground'\").boxplot(column=\"error\", by=\"run\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ucb_and_back = pv_ucb.map()[\"android\"][\"ucb-sdb-android-2\"][\"evaluation_ranges\"][0]; ucb_and_back[\"trip_id\"]\n",
    "back_trip = ucb_and_back[\"evaluation_trip_ranges\"][2]; print(back_trip[\"trip_id\"])\n",
    "lt_leg = back_trip[\"evaluation_section_ranges\"][7]; print(lt_leg[\"trip_id\"])\n",
    "gt_leg = sd_ucb.get_ground_truth_for_leg(back_trip[\"trip_id_base\"], lt_leg[\"trip_id_base\"]); gt_leg[\"id\"]"
   ]
  },
  {
   "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",
    "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",
    "\n",
    "colors = [\"red\", \"yellow\", \"blue\"]\n",
    "for run in range(3):\n",
    "    ucb_and_back = pv_ucb.map()[\"android\"][\"ucb-sdb-android-2\"][\"evaluation_ranges\"][run]; ucb_and_back[\"trip_id\"]\n",
    "    back_trip = ucb_and_back[\"evaluation_trip_ranges\"][2]; print(back_trip[\"trip_id\"])\n",
    "    lt_leg = back_trip[\"evaluation_section_ranges\"][7]; print(lt_leg[\"trip_id\"])\n",
    "    sensed_section_gj = ezpv.get_geojson_for_leg(lt_leg)\n",
    "    sensed_section_gj[\"properties\"][\"style\"][\"color\"] = colors[run]\n",
    "    sensed_leg_gj_feature = folium.GeoJson(sensed_section_gj, name=\"run %s\" % run)\n",
    "    sensed_leg_gj_points = ezpv.get_point_markers(sensed_section_gj, name=\"points for %d\" % run, color=colors[run], tz=\"America/Los_Angeles\")\n",
    "    curr_map.add_child(sensed_leg_gj_feature)\n",
    "    curr_map.add_child(sensed_leg_gj_points)\n",
    "    \n",
    "curr_map.add_child(gt_leg_gj_feature)\n",
    "curr_map.add_child(gt_leg_gj_points)\n",
    "curr_map.fit_bounds(gt_leg_gj_feature.get_bounds())\n",
    "folium.LayerControl().add_to(curr_map)\n",
    "curr_map"
   ]
  }
 ],
 "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
}