My LA Footprint

##### Setup
%matplotlib inline
import json
import pandas as pd
import geopandas as gpd
from shapely.geometry import Point
import pysal as ps
import matplotlib.pyplot as plt
import datetime
import folium

# Load the file, print first five timestamps
with open('Takeout/Location_History/Location_History.json', 'r') as fh:
    data = json.loads(fh.read())

for i in range(0,5):
    print data['locations'][i]

with open('Takeout/Location_History/Location_History.json', 'r') as fh:
    data = json.loads(fh.read())

locations = data['locations']
print "The Google Location History JSON file contains {} points" .format(len(locations))

def generate_locations(locations):
    
    # Create a new dictionary ('loc') that will contain the transformed data
    # that we will use to create the new GeoDataFrame
    for loc in locations:
        
        # Create a shapely point object from the lat / lon coords
        loc['lon'] = loc['longitudeE7'] * 0.0000001
        loc['lat'] = loc['latitudeE7'] * 0.0000001
        loc['geometry'] = Point(loc['lon'], loc['lat'])
        
        # Convert timestamp from ms to s, create datetime object
        loc['timestampSec'] = int(loc['timestampMs']) * 0.001
        loc['datetime'] = datetime.datetime.fromtimestamp(loc['timestampSec']).strftime('%Y-%m-%d %H:%M:%S')
        
        # If activity is present, assign most likely activity to timestamp
        try:
            activities = loc['activity'][0]['activity']
            
            # Pick the activity with the highest probability
            maxConfidenceActivity = max(activities, key=lambda x:x['confidence'])
            loc['conf'] = maxConfidenceActivity['confidence']
            loc['activity'] = maxConfidenceActivity['type']
        
        except:
            loc['conf'] = None
            loc['activity'] = None

        yield loc

formatted_loc = generate_locations(locations)

google_loc = gpd.GeoDataFrame(generate_locations(locations))
google_loc = google_loc.drop(['velocity','latitudeE7','longitudeE7','timestampMs','heading'],axis=1)
google_loc.crs = {'init':'epsg:4326'}

# Let's take a peek at the resulting GeoDataFrame (focusing on those GPS timestamps where Google determined I was cycling)
google_loc[google_loc['activity'] == 'ON_BICYCLE'].head()

# Calculate the percentage of time spent doing each activity
activity_percent = (google_loc['activity'].value_counts() / google_loc['activity'].value_counts().sum())

# Create a bar chart showing the percentage of time spent doing each activity
activity_chart = activity_percent.sort_values(ascending=False).plot(kind='bar', title='Count of Timestamps for each Activity', figsize=(15,10), fontsize=12)
activity_chart.set_xlabel("Activity", fontsize=12)
activity_chart.set_ylabel("Percentage of Time", fontsize=12)
plt.show()

# Read the shapefile 
la_neighborhoods = gpd.read_file('la_neighborhoods/la_city.shp')

# Execute spatial join: all points within LA Neighborhoods
la_loc = gpd.sjoin(google_loc, la_neighborhoods, how='inner', op='intersects')

# Calculate the percentage of time spent in each LA neighborhood & Join to spatial dataframe
neighborhood_percent = (la_loc['Name'].value_counts(dropna=False) / la_loc['Name'].value_counts().sum()).reset_index()
neighborhood_percent.columns = ['Name','Percent']

# Clean up the resulting dataframe
la_neighborhoods = la_neighborhoods.merge(neighborhood_percent, how='left', on='Name')
la_neighborhoods = la_neighborhoods.drop('Descriptio', axis=1)

# Plot the bar chart
la_neighborhoods_pct = la_neighborhoods[la_neighborhoods['Percent'] > .008]
la_neighborhoods_pct = la_neighborhoods_pct.set_index('Name')
barchart = la_neighborhoods_pct['Percent'].sort_values(ascending=False).plot(kind='bar', title='Percent of Time Spent in Each LA Neighborhood', figsize=(15,10), fontsize=12)
barchart.set_xlabel("LA Neighborhood", fontsize=12)
barchart.set_ylabel("Percent of Last Year Spent in the Neighborhood", fontsize=12)
plt.show()

# Create LA Basemap specifying map center, zoom level, and using default openstreetmap tiles
la_basemap = folium.Map([34.047677, -118.3073917], tiles='Stamen Toner', zoom_start=11)

# Choropleth function adapted from code via Andrew Gaidus
# at http://andrewgaidus.com/leaflet_webmaps_python/
def add_choropleth(mapobj, gdf, id_field, value_field, fill_color = 'YlOrRd', fill_opacity = 0.6, 
                    line_opacity = 0.2, num_classes = 6, classifier = 'Quantiles'):
    
    #Allow for 3 Pysal map classifiers to display data
    #Generate list of breakpoints using specified classification scheme. List of breakpoint will be input to choropleth function
    if classifier == 'Fisher_Jenks':
        threshold_scale=ps.esda.mapclassify.Fisher_Jenks(gdf[value_field], k = num_classes).bins.tolist()
    if classifier == 'Equal_Interval':
        threshold_scale=ps.esda.mapclassify.Equal_Interval(gdf[value_field], k = num_classes).bins.tolist()
    if classifier == 'Quantiles':
        threshold_scale=ps.esda.mapclassify.Quantiles(gdf[value_field], k = num_classes).bins.tolist()
    
    #Call Folium choropleth function, specifying the geometry as a the WGS84 dataframe converted to GeoJSON, the data as 
    #the GeoDataFrame, the columns as the user-specified id field and and value field.
    #key_on field refers to the id field within the GeoJSON string
    mapobj.choropleth(
                geo_str = gdf.to_json(),
                data = gdf,
                columns = [id_field, value_field],
                key_on = 'feature.properties.{}'.format(id_field),
                fill_color = fill_color,
                fill_opacity = fill_opacity,
                line_opacity = line_opacity,
                threshold_scale = threshold_scale
                )
    return mapobj

la_google_history = add_choropleth(la_basemap, la_neighborhoods, "Name", "Percent")

la_google_history

# Create new LA Basemap specifying map center, zoom level, and using Stamen Terrain tiles
griffith_map = folium.Map([34.109279, -118.266087], tiles='Stamen Terrain', zoom_start=13)

# Resurrect the Google Location History GeoDataFrame
bicycle_points = google_loc[google_loc['activity'] == 'ON_BICYCLE']

# Loop through the pandas df, add each bicycling point to the map
for index, row in bicycle_points.iterrows():
    folium.Marker([str(row['lat']), str(row['lon'])]).add_to(griffith_map)

# Show the map
griffith_map