def school_histogram(filename):
key = os.getenv('GOOGLE_MAPS_API_KEY')
df = pd.read_excel(filename)
df.columns = [
'school', 'grade', 'res_addr', 'pickup_time', 'pickup_bus',
'pickup_location', 'pickup_stop', 'pickup_stop_desc', 'dropoff_time',
'dropoff_bus', 'dropoff_location', 'dropoff_stop', 'dropoff_stop_desx',
'pickup_dist_from_stop', 'dropoff_dist_from_stop'
]
# School: [Drop Off, Start Time, End Time]
school_time = {
"ALT": ["09:20", "09:30", "14:15", "115 A St."],
"BAR": ["08:50", "09:05", "15:05", "100 Dudley Rd."],
"BRO": ["09:00", "09:15", "15:15", "575 Pleasant St."],
"CAM": ["07:55", "08:15", "14:25", "215 Elm St."],
"CHA": ["08:00", "08:30", "15:30", "139 Newbury St"],
"DUN": ["08:50", "09:05", "15:05", "48 Frost St."],
"FHS": ["07:00", "07:25", "13:55", "115 A St."],
"FUL": ["07:55", "08:15", "14:25", "31 Flagg Dr."],
"HEM": ["09:00", "09:15", "15:15", "729 Water St."],
"JUN": ["00:00", "00:00", "00:00",
"29 Upper Joclyn Ave."], # NEEDS VERIFICATION
"KNG": ["09:10", "09:25", "15:25", "454 Water St."],
"MAR": ["07:18", "07:20", "13:45", "273 Union Ave."],
"MCC": ["08:00", "08:15", "14:15", "8 Flagg Dr."],
"POT": ["09:00", "09:15", "15:15", "492 Potter Rd."],
"STA": ["08:50", "09:05", "15:05", "25 Elm St."],
"STB": ["07:45", "08:00", "14:15", "832 Worcester Rd"],
"WAL": ["07:55", "08:15", "14:25", "301 Brook St."],
"WIL": ["08:50", "09:05", "15:05", "169 Leland St."]
}
# School: [pickup_time1, pickup_time2, pickup_time3, etc.]
school_dict = dict()
df = df.dropna(subset=['pickup_time'])
break_counter = 0
for index, row in df.iterrows():
school = row["school"]
time = datetime.strptime(row["pickup_time"], '%I:%M %p')
am_dest = row["pickup_stop_desc"]
pm_dest = row["dropoff_stop_desx"]
if school not in school_dict:
school_dict[school] = [[time.timestamp(), am_dest, pm_dest]]
else:
school_dict[school] += [[time.timestamp(), am_dest, pm_dest]]
for y in school_dict:
gmap = gmplot.GoogleMapPlotter(42.2981, -71.4361, 15)
gmap.apikey = key
if break_counter < 100:
break_counter += 1
school_times = [item[0] for item in school_dict[y]]
time_stamps = school_times
earliest_pickup = datetime.fromtimestamp(min(
time_stamps)).strftime("%Y-%m-%d %H:%M:%S").split(" ")[1][:-3]
latest_pickup = datetime.fromtimestamp(max(time_stamps)).strftime(
"%Y-%m-%d %H:%M:%S").split(" ")[1][:-3]
average_pickup = datetime.fromtimestamp(
sum(time_stamps) / len(time_stamps)).strftime(
"%Y-%m-%d %H:%M:%S").split(" ")[1][:-3]
subtitle = "Earliest Pickup: " + earliest_pickup + " | Latest Pickup: " + latest_pickup +\
" | Average Pickup: " + average_pickup + " | Drop Off Time: " + school_time[y][0] + " | Start Time: " + school_time[y][1]
fig, ax = plt.subplots()
# create 10 bins evenly spaced out between first and last pickup time per school
counter = min(time_stamps)
step = (max(time_stamps) - min(time_stamps)) / 10.0
calculated_bins = [counter]
for x in range(10):
counter += step
calculated_bins += [counter]
# plot histogram
(n, bins, patches) = ax.hist(time_stamps,
color="skyblue",
bins=calculated_bins,
rwidth=0.8)
ax.set_xticks(calculated_bins)
back_to_date = []
for x in bins:
back_to_date += [
datetime.fromtimestamp(x).strftime(
"%Y-%m-%d %H:%M:%S").split(" ")[1][:-3]
]
ax.set_xticklabels(back_to_date)
ax.xaxis.set_minor_locator(tkr.AutoMinorLocator(n=2))
ax.xaxis.set_minor_formatter(tkr.FixedFormatter(back_to_date))
ax.xaxis.set_major_formatter(tkr.NullFormatter())
for tick in ax.xaxis.get_minor_ticks():
tick.tick1line.set_markersize(0)
title = "School Pickup Data for " + str(y)
plt.suptitle(title, fontsize=14)
plt.title(subtitle, fontsize=6.5)
plt.xlabel("Time")
plt.ylabel("Number of Students")
plt.show()
# below is for plotting points on map
# retrieving data points within each of the histogram bins
binlist = np.c_[bins[:-1], bins[1:]]
d = np.array(time_stamps)
list_time = []
for i in range(len(binlist)):
if i == len(binlist) - 1:
l = d[(d >= binlist[i, 0]) & (d <= binlist[i, 1])]
else:
l = d[(d >= binlist[i, 0]) & (d < binlist[i, 1])]
list_time += [l.tolist()]
school_info = school_dict[y]
bin_dict = {i: list_time[i] for i in range(0, len(list_time))}
pickup_dict = {i: [] for i in range(0, len(list_time))}
for x in school_info:
for n in range(10):
if x[0] in bin_dict[n]:
pickup_dict[n] += [(x[1]).replace('*', '')]
for key in pickup_dict:
pickup_dict[key] = list(set(pickup_dict[key]))
lat_dict = {i: [] for i in range(0, 10)}
lon_dict = {i: [] for i in range(0, 10)}
for key in pickup_dict:
for value in pickup_dict[key]:
pickup_coordinates = get_coordinates(value)
if pickup_coordinates[0] is not None and pickup_coordinates[
1] is not None:
lat_dict[key] += [pickup_coordinates[0]]
lon_dict[key] += [pickup_coordinates[1]]
# Place map
colors = [
"#ffffff", "#ecd8e9", "#d8b1d4", "#c38bbf", "#ad66a9",
"#973e95", "#800080", "#6a0c6a", "#551054", "#411140",
"#2d102c"
]
for x in range(10):
gmap.scatter(lat_dict[x],
lon_dict[x],
color=colors[x],
size=150,
marker=False)
school_location = get_coordinates(school_time[y][-1])
school_lat_coordinates = [school_location[0]]
school_lon_coordinates = [school_location[1]]
gmap.scatter(school_lat_coordinates,
school_lon_coordinates,
color=colors[10],
size=300,
marker=False)
gmap.draw("pickup_" + str(y) + ".html")
def ready_direction_array(self):
self.direction_array = self.client.dir_points
gmap = gmplot.GoogleMapPlotter(52.29661, 19.45500, 5)
lat, lng = zip(*self.direction_array)
gmap.plot(lat, lng)
gmap.draw("dirs.html")
import csv
from gmplot import gmplot
from generateCoordinates import generateCoordsWithinSquare
import json
from pprint import pprint
import os
meterWidth = 5000
count = meterWidth / 30
# Open up json from eventful result
data = json.load(open('EventfulQueries/nextWeek200Popular.json'))
events = data["events"]["event"]
for event in events:
venue_name = event["venue_name"]
directory = "Venues/" + venue_name
latitude = float(event["latitude"])
longitude = float(event["longitude"])
gmap = gmplot.GoogleMapPlotter(latitude, longitude, 13)
map_file = directory + "/map.html"
# Store gps data to collect in a file, and visual map in map.html
if not os.path.exists(directory):
os.makedirs(directory)
data = generateCoordsWithinSquare(latitude, longitude, meterWidth, count,
gmap, map_file)
data["center_point"] = [latitude, longitude]
filename = directory + "/data_to_collect.json"
with open(filename, 'w') as fp:
json.dump(data, fp, indent=4, sort_keys=True)
from ast import literal_eval
from gmplot import gmplot
import random
import os
trainSet = pd.read_csv(
'../train_set.csv', # replace with the correct path
converters={"Trajectory": literal_eval},
index_col='tripId')
directory = 'map'
if not os.path.exists(directory):
os.makedirs(directory)
items = random.sample(range(len(trainSet)), 5)
for item in items:
traj = traj = trainSet['Trajectory'].iloc[item]
lon = []
lan = []
for i in traj:
lon.append(i[1])
lan.append(i[2])
gmap = gmplot.GoogleMapPlotter(lan[0], lon[0], len(lon))
gmap.plot(lan, lon, 'green', edge_width=5)
gmap.draw(directory + '/map_' +
str(trainSet['journeyPatternId'].iloc[item]) + '_' + str(item) +
'.html')
def gmap_plot(gps_lat, gps_lon, filename):
gmap = gmplot.GoogleMapPlotter(gps_lat[0], gps_lon[0], 20)
gmap.plot(gps_lat, gps_lon, 'cornflowerblue', edge_width=10)
# Draw
gmap.draw(filename +".html")
# -*- coding: utf-8 -*-
"""
Created on Wed Sep 18 19:19:34 2019
@author: Rudrajit
"""
import csv
from gmplot import gmplot
gmap = gmplot.GoogleMapPlotter(28.689169, 77.324448, 17)
gmap.coloricon = "http://www.googlemapsmarkers.com/v1/%s/"
with open("route.csv", "r") as f:
reader = csv.reader(f)
k = 0
for row in reader:
lat = float(row[0])
long = float(row[1])
if (k == 0):
gmap.marker(lat, long, 'yellow')
k = 1
else:
gmap.marker(lat, long, 'blue')
gmap.marker(lat, long, 'red')
gmap.draw("mymap.html")
#print path #print "122222222222222222222222222211111111111111111111" #for d in dist: # print d[0] final_dist = sort(dist) #for d in dist1: # print (d[0],d[1],d[2]) count = 0 generic = 0 for d in final_dist: if count == 5 : break gmap = gmplot.GoogleMapPlotter(d[3][0][1],d[3][0][0],13) #print d[2][0][1] #print d[2][0][0] longitude , latitude = zip(*d[3]) #print "-------------------------lat1------------------------" #print longitude #print "-------------------------end of lat 1-----------------" longitude2, latitude2 = zip(*d[1]) #print "---------------------------lat2-------------------------" #print longitude2 #print "---------------------------end of lat 2-------------------" #print latitude2 #print latitude #print longitude
for i in range(sheet.nrows):
if str(type(sheet.cell_value(i, 9))) == "<class 'float'>" and str(
type(sheet.cell_value(i, 8))) == "<class 'float'>":
longitude.append(sheet.cell_value(i, 9))
latitude.append(sheet.cell_value(i, 8))
#Your Google_API_Key
y_12 = latitude
x_12 = longitude
#Import important libraries
from gmplot import gmplot
# Place map
gmap = gmplot.GoogleMapPlotter(y_12[0], x_12[0], 13)
# Polygon
# gmap.plot(latitude, longitude, 'cornflowerblue', edge_width=10)
# Scatter points
gmap.coloricon = "http://www.googlemapsmarkers.com/v1/%s/"
gmap.scatter(latitude, longitude, '#3B0B39', size=10, marker=False)
# Marker
hidden_gem_lat, hidden_gem_lon = 37.770776, -122.461689
for index, value in enumerate(latitude):
gmap.marker(latitude[index], longitude[index], 'cornflowerblue')
gmap.apikey = key
## Plotting in Google Maps
## https://github.com/vgm64/gmplot
#pip install gmplot
from gmplot import gmplot
# Google_API_Key is the custom file name I gave to my key
from Google_API_Key import api_key as google_key
STL = gmaps.geocode('St. Louis')
STL[0]['geometry']['location']
## latitutde and longitude and "zoom level"
## or location and zoom level (deprecated)
plot1 = gmplot.GoogleMapPlotter(38.6270025, -90.19940419999999, 13)
plot1.apikey = google_key
stl_places = [
"Forest Park, St. Louis", "Missouri Botanical Garden, St. Louis",
"Anheuser Busch, St. Louis", "Arch, St. Louis"
]
def grab_latlng(place):
x = gmaps.geocode(place)
return (x[0]["geometry"]["location"]["lat"],
x[0]["geometry"]["location"]["lng"])
l = [grab_latlng(i) for i in stl_places]
def getGPS(frameid=0):
if (video_type == 0):
out = ''
ynDATA = False
dataE1, dataE2 = 0.0, 0.0
dataN1, dataN2 = 0.0, 0.0
try:
while (serial.inWaiting()):
out = str(serial.readline().decode('utf-8'))
except:
pass
if out != '':
gpsdata = out.split(",")
print(out)
if (gpsdata[0] == "$GPRMC"):
dataE = gpsdata[5]
dataN = gpsdata[3]
if (len(dataE) >= 10):
dataE1, dataE2 = float(dataE[:3]), float(dataE[3:])
gpsE = dataE1 + dataE2 / 60
ynDATA = True
if (len(dataN) >= 9):
dataN1, dataN2 = float(dataN[:2]), float(dataN[2:])
gpsN = dataN1 + dataN2 / 60
str_gpsE = str(gpsE)
str_gpsN = str(gpsN)
else:
ynDATA = False
for i in range(0, len(gps_frames) - 1):
if (frameID >= int(gps_frames[i][0])
and frameID < int(gps_frames[i + 1][0])):
print(frameID, gps_frames[i][0], gps_frames[i][1])
gpsN, gpsE = gps_frames[i][1].split(",")
ynDATA = True
#now_loc = (float(gpsE), float(gpsN))
gmap = gmplot.GoogleMapPlotter(float(gpsN), float(gpsE), 18)
print("GPS:", float(gpsN), float(gpsE))
if (float(gpsN) > 0) and float(gpsE) > 0:
# Marker
print(gpsN, gpsE)
#gmap.plot(float(gpsN), float(gpsE), 'cornflowerblue', edge_width=10)
gmap.marker(float(gpsN),
float(gpsE),
color='#000000',
c=None,
title="Defect")
#gmap.scatter(float(gpsE), float(gpsN),'#FF6666', edge_width=10)
# Draw
#gmap.coloricon = "pointer.png"
gmap.apikey = 'AIzaSyCbQibjl5FKhsQCFz8lj1ad3qru1bUCdrU'
gmap.draw("my_map.html")
#print(gpsN, gpsE)
return ynDATA, float(gpsE), float(gpsN)
#find mean latitude and longitude to center the map
cam_longitudes = [camera['location'][0] for camera in camera_coordinates]
cam_latitudes = [camera['location'][1] for camera in camera_coordinates]
mean_cam_latitude = np.mean(cam_latitudes)
mean_cam_longitude = np.mean(cam_longitudes)
print(f'mean_cam_latitude : {mean_cam_latitude} \nmean_cam_longitude : {mean_cam_longitude}')
#place map
gmap = gmplot.GoogleMapPlotter(mean_cam_latitude, mean_cam_longitude, 13)
for taxi in taxi_path:
gmap.scatter([taxi['latitude']], [taxi['longitude']], color='black', marker = False, size = 1,title=str(taxi['longitude']) + '-' +str(taxi['latitude']))
#plotting sample of cameras and detected points on map
for camera in camera_coordinates:
cam_latitude, cam_longitude = camera['location'][1], camera['location'][0]
gmap.marker(cam_latitude, cam_longitude, color='green', title=camera['id'])
gmap.scatter([cam_latitude], [cam_longitude], color='yellow', marker = False, size=50)
#only including cameras that detect atleast one vehicle
if str(camera['id']) in camera_stream:
detected_vehicles = camera_stream[str(camera['id'])]
for vehicle in detected_vehicles:
vehicle_latitude, vehicle_longitude = vehicle['location'][1], vehicle['location'][0]
# from keys import MAPS_API_KEY
# Change current working directory, only needed for Atom
os.chdir(os.path.dirname(os.path.abspath(__file__)))
today_date: str = date.today().strftime("%m-%d-%y")
report_path = f'../reports/all_time.xlsx'
report: openpyxl.workbook.Workbook = load_workbook(filename=report_path)
worksheet: openpyxl.worksheet.worksheet.Worksheet = report.active
MAPS_API_KEY = ''
googlemaps_client = googlemaps.Client(key=MAPS_API_KEY)
'''# 40.3, -75, 6 creates a default zoom over the entire state of Virginia '''
gmap_plotter_client = gmplot.GoogleMapPlotter(40.3, -75, 6)
gmap_plotter_client.apikey = MAPS_API_KEY
for cell in worksheet['H']:
str_value = str(cell.value)
str_value = str_value.replace(' ', '')
if '|' in str_value:
str_value = str_value[0: str_value.find('|')]
geocode_result = googlemaps_client.geocode(str_value)[0]
lat, lng = geocode_result['geometry']['location']['lat'], geocode_result['geometry']['location']['lng']
print(str(lat) + str(lng))
gmap_plotter_client.marker(lat, lng)
gmap_plotter_client.draw(f'../maps/{today_date}.html')
elif cols[-1] == "bits/sec":
speed /= 1000
np_idx = time - min(times)
speeds[np_idx] = speed
shape_2d = (int(num / 15), 15)
num_2d = int(num / 15) * 15
lats = lats[:num_2d].reshape(shape_2d)
longs = longs[:num_2d].reshape(shape_2d)
speeds = speeds[:num_2d].reshape(shape_2d)
speeds = np.nanmean(speeds, axis=1)
lats = np.nanmean(lats, axis=1)
longs = np.nanmean(longs, axis=1)
gmap = gmplot.GoogleMapPlotter(np.nanmean(lats),
np.nanmean(longs),
12,
apikey=GMAP_API_KEY)
for i in range(len(lats) - 1):
avg_speed = (speeds[i] + speeds[i + 1]) / 2
color = ""
if avg_speed >= 1000:
color = "green"
elif avg_speed < 1000 and avg_speed > 1:
color = "orange"
elif avg_speed <= 1:
color = "red"
else:
color = "black"
gmap.plot(lats[i:i + 2],
longs[i:i + 2],
color=color,
from gmplot import gmplot
import os
# Place map
gmap = gmplot.GoogleMapPlotter(49.839683, 24.029717, 13)
def readFile(path):
"""
(str) -> list
The function opens the file
and get all data from it, storing
it in the list
"""
lst = []
f = open(path, encoding="utf-8", errors="ignore")
for i in f:
lst.append(i)
return lst
def putMarker(coord, color):
"""
(tuple, str) -> Nonetype
Using the abstract data type and
google api, the function puts the marker
on the map
"""
gmap.marker(coord[0], coord[1], color=color)
import folium
from gmplot import gmplot
df = pd.read_csv("data/yellow_tripdata_2017-01.csv")
location_df = pd.read_csv("v2_zone_geocode.csv")
location_df = location_df.drop(["Unnamed: 0"], axis=1)
#drop other column
# df['DOLocationID'].value_counts().reset_index().to_csv('destination_count.csv')
# merging two df
lat_lng_count_df = pd.merge(df,
location_df,
left_on='DOLocationID',
right_on="LocationID",
how='left')
print(lat_lng_count_df.shape[0])
# NYC
# random 300000 data - gmplot cannot handle
data = lat_lng_count_df.head(n=300000)
gmap = gmplot.GoogleMapPlotter(40.758896, -73.985130, 9)
# Overlay our datapoints onto the map
gmap.heatmap(data['lat'], data['lng'])
gmap.draw("heatmap.html")
#map = folium.Map(location=[40.758896, -73.985130], tiles="Stamen Terrain", zoom_start=13)
#map.add_children(plugins.HeatMap(stationArr, radius=15))
import pandas as pd
from gmplot import gmplot
import numpy as np
if __name__ == '__main__':
places = pd.read_csv('data/places.csv')
lat = places['Latitude']
lon = places['Longitude']
dates = places['Date']
gmap = gmplot.GoogleMapPlotter(lat[0], lon[0], 5)
gmap.heatmap(lat, lon, radius=10, maxIntensity=10)
gmap.draw("my_map_heatmap.html")
from gmplot import gmplot as gp
import csv
import random
map = gp.GoogleMapPlotter(40.1105875,
-88.2072697,
13,
apikey="AIzaSyCLV6iOyD6d60RXPgpzMf4baAy8ZqjCdYE")
path = "trips_data.csv"
path_corider = "trips_data_Xiaolu.csv"
data = []
with open(path) as file:
reader = csv.reader(file)
headers = next(reader)
for row in reader:
if len(row[5]) != 0:
lat = (float(row[5]), float(row[9]))
lng = (float(row[6]), float(row[10]))
data.append((lat, lng))
for pair in data:
r = lambda: random.randint(0, 255)
color = '#%02X%02X%02X' % (r(), r(), r())
map.plot(pair[0], pair[1], color, edge_width=3)
# draw
start_points = []
locationInfo("Beijing", "textfile/Beijing.txt"),
locationInfo("Seoul", "textfile/Seoul.txt")
]
# search for coordinate using geopy
print("Location - (Latitude, Longitude)")
geolocator = Nominatim(user_agent="Ben")
for x in range(len(locationList)):
location = geolocator.geocode(locationList[x].name)
locationList[x].setAddress(location.address)
locationList[x].setCoor(location.latitude, location.longitude)
locationList[x].print_location_information()
# marking location using gmplot
gmap = gmplot.GoogleMapPlotter(locationList[4].latitude,
locationList[4].longitude, 3)
# 2. Placing/Mark all points(drop markers)
for x in range(len(locationList)):
gmap.marker(locationList[x].latitude, locationList[x].longitude)
print("")
# 3. Get Distance
print("The distance of the city(3 decimal place):")
print("%15s|" % (''), end='')
for i in range(len(locationList)):
print("%15s|" % (locationList[i].name), end='')
print('')
distanceCountry = [[0] * len(locationList) for i in range(len(locationList))]
for i in range(len(locationList)):
print("%-15s|" % locationList[i].name, end='')
# lat = min(lat1, lat2)
# long = min(long1, long2)
num_patients = 294
num_clinics = 30
# todo: search if there's 2d random generating coordinates
patients_latitude = np.random.uniform(br[0], tl[0], num_patients)
# print(patients_latitude)
patients_longtitude = np.random.uniform(bl[1], tr[1], num_patients)
# print(patients_longtitude)
patients_coord = zip(patients_latitude, patients_longtitude)
# for tup in patients_coord:
# print(tup)
clinics_latitude = np.random.uniform(br[0], tl[0], num_clinics)
# print(patients_latitude)
clinics_longtitude = np.random.uniform(bl[1], tr[1], num_clinics)
# berkshire_coord = (42.3118, 73.1822)
gmap = gmplot.GoogleMapPlotter(42.446, -73.192, 10.5)
gmap.heatmap(patients_latitude, patients_longtitude)
for x, y in zip(clinics_latitude, clinics_longtitude):
gmap.marker(x, y, "darkred")
# todo: add outline on map
gmap.apikey = "AIzaSyDE_MLUeIdpPgnCWEV-ZgscLCO1734Ax3w"
gmap.draw("my_map.html")
def visualize(filename, dataset_name, lat_name, lon_name, spatial_resolution,
standard_deviations, map_name):
dataset = netCDF4.Dataset(filename, "r")
gmap = gmplot.GoogleMapPlotter(
(dataset.variables[lat_name][0] + dataset.variables[lat_name][-1]) / 2,
(dataset.variables[lon_name][0] + dataset.variables[lon_name][-1]) / 2,
3)
standard_deviation = np.std(np.array(dataset.variables[dataset_name]))
average = np.average(np.array(dataset.variables[dataset_name]))
increment = 0
maximum = 0
datapoints = []
percentage = -1
print("[-] Extracting data...")
for lat in range(len(dataset.variables[dataset_name][0])):
for lon in range(len(dataset.variables[dataset_name][0][lat])):
if dataset.variables[dataset_name][0][lat][
lon] > standard_deviation * standard_deviations + average or dataset.variables[
dataset_name][0][lat][lon] < 1:
continue
else:
datapoints.append([])
datapoints[increment].append(lat)
datapoints[increment].append(lon)
if dataset.variables[dataset_name][0][lat][lon] > maximum:
maximum = dataset.variables[dataset_name][0][lat][lon]
increment += 1
if exact_round(lat / (len(dataset.variables[lat_name]) - 1) *
100) != percentage:
percentage = exact_round(
lat / (len(dataset.variables[lat_name]) - 1) * 100)
os.system("cls" if os.name == "nt" else "clear")
if percentage != 100:
print("\t" + str(percentage) + "%\t [" + "=" * percentage +
">" + " " * (100 - percentage) + "]")
else:
print("\t100% [" + "=" * 100 + ">]")
print("[+] Data extraction finished.")
print("[-] Plotting data...")
percentage = -1
for i in range(len(datapoints)):
if rgb(
scale_max(
dataset.variables[dataset_name][0][datapoints[i][0]][
datapoints[i][1]], maximum)) != [0, 0, 0]:
gmap.scatter(
[dataset.variables[lat_name][datapoints[i][0]]],
[dataset.variables[lon_name][datapoints[i][1]]],
"#" + hex_color(
rgb(
scale_max(
dataset.variables[dataset_name][0]
[datapoints[i][0]][datapoints[i][1]], maximum))),
size=sum(spatial_resolution) * 15000,
marker=False)
if exact_round(i / (len(datapoints) - 1) * 100) != percentage:
percentage = exact_round(i / (len(datapoints) - 1) * 100)
os.system("cls" if os.name == "nt" else "clear")
if percentage != 100:
print("\t" + str(percentage) + "%\t [" + "=" * percentage +
">" + " " * (100 - percentage) + "]")
else:
print("\t100% [" + "=" * 100 + ">]")
print("[+] Data plotting finished.")
print("[-] Rendering map...")
gmap.draw(map_name)
print("[+] Map rendering finished.")
os.system(map_name)
return map_name
path_run = os.path.join(path, run_name)
if not os.path.exists('/home/jacob/DNDO/IMU_GPS/' + name):
string = 'mkdir /home/jacob/DNDO/IMU_GPS/' + name
os.system(string)
pd_gps = pandas.read_csv(os.path.join(path_run, 'vectornav_gps.csv'))
pd_ins = pandas.read_csv(os.path.join(path_run, 'vectornav_ins.csv'))
pd_imu = pandas.read_csv(os.path.join(path_run, 'vectornav_imu.csv'))
ins_time = [
i - pd_ins['timestamp_unix'][0] for i in pd_ins['timestamp_unix']
]
gps_time = [
i - pd_ins['timestamp_unix'][0] for i in pd_gps['timestamp_unix']
]
if plot:
gmap = gmplot.GoogleMapPlotter(pd_ins['Latitude'][0],
pd_ins['Longitude'][0], 18)
gmap.plot(pd_ins['Latitude'],
pd_ins['Longitude'],
colors['ins'],
edge_width=7)
gmap.plot(pd_gps['Latitude'],
pd_gps['Longitude'],
colors['gps'],
edge_width=7)
gmap.scatter([pd_ins['Latitude'][0]], [pd_ins['Longitude'][0]],
'green')
gmap.scatter([pd_ins['Latitude'].iloc[-1]],
[pd_ins['Longitude'].iloc[-1]], 'red')
gmap.scatter([pd_gps['Latitude'][0]], [pd_gps['Longitude'][0]],
'green')
gmap.scatter([pd_gps['Latitude'].iloc[-1]],
import plotly
from gmplot import gmplot
import os
import pandas as pd
cwd = os.getcwd()
dataSet = pd.read_csv(cwd + "/Data/sfpd_dispatch_data_subset.csv")
gmapFrequency = gmplot.GoogleMapPlotter(37.762289, -122.445359, 13)
gmapFrequency.heatmap(dataSet['latitude'], dataSet['longitude'])
gmapFrequency.draw("frequency.html")
gmapNotUrgent = gmplot.GoogleMapPlotter(37.762289, -122.445359, 13)
gmapUrgent = gmplot.GoogleMapPlotter(37.762289, -122.445359, 13)
notUrgentCoords = list()
urgentCoords = list()
for i in range(len(dataSet['received_timestamp'])):
if dataSet['final_priority'][i] == 2:
notUrgentCoords.append(
(dataSet['latitude'][i], dataSet['longitude'][i]))
elif dataSet['final_priority'][i] == 3:
urgentCoords.append((dataSet['latitude'][i], dataSet['longitude'][i]))
#Gets the latitudes and longitudes into separate lists instead of in tuples
notUrgentlats, notUrgentlongs = zip(*notUrgentCoords)
urgentLats, urgentLongs = zip(*urgentCoords)
gmapNotUrgent.heatmap(notUrgentlats, notUrgentlongs)
gmapNotUrgent.draw("notUrgent.html")
gmapUrgent.heatmap(urgentLats, urgentLongs)
gmapUrgent.draw("urgent.html")
from gmplot import gmplot
import json
# Place map
gmap = gmplot.GoogleMapPlotter(37.766956, -122.438481, 6)
with open('Location History.json') as json_data:
d = json.load(json_data)
lat_long = []
for location in d["locations"]:
lat_calc = (int(location["latitudeE7"] / 10000) * 10000) / 1e7
long_calc = (int(location["longitudeE7"] / 10000) * 10000) / 1e7
lat_long.append((lat_calc, long_calc))
print(len(lat_long))
set_lat_long = set(lat_long)
print(len(set_lat_long))
#
# # Polygon
# golden_gate_park_lats, golden_gate_park_lons = zip(*lat_long)
# gmap.plot(golden_gate_park_lats, golden_gate_park_lons, 'cornflowerblue', edge_width=3)
# Scatter points
top_attraction_lats, top_attraction_lons = zip(*set_lat_long)
gmap.scatter(top_attraction_lats, top_attraction_lons, 'cornflowerblue', edge_width=4, marker=False)
#gmap.heatmap(top_attraction_lats, top_attraction_lons)
# Draw
gmap.draw("my_map.html")
,'darkmagenta'
, 'yellow'
, 'navy'
,'darkorange'
,'purple'
, 'orchid'
,'darkgray'
,'gold'
,'pink'
]
gmap = gmplot.GoogleMapPlotter(-68.779056, 33.529694,3 )
clustermat=[]
for i in range(1,max(list_labels)+1):
clustermat.insert(i,[i])
for i in range(0,len(list_labels)):
clustermat[list_labels[i]-1].append([datamovlatactual[i][0],datamovlatactual[i][1],datamovspd[i][0],datamovspd[i][1]])
for i in range(len(list_labels)):
lats, lons = zip(datamovlatactual[i])
gmap.scatter(lats, lons, color_codes[list_labels[i]], size=15600, marker=False)
gmap.draw("hack_dbscan_plot.html")
gv=[]
for i in range(max(list_labels)):
clustermat[i].pop(0)
locationInfo("Bangkok"),
locationInfo("Taipei"),
locationInfo("Hong Kong"),
locationInfo("Tokyo"),
locationInfo("Beijing"),
locationInfo("Seoul")
]
# search for coordinate using geopy
geolocator = Nominatim(user_agent="MyGeopy")
for x in range(len(locationList)):
location = geolocator.geocode(locationList[x].name)
locationList[x].setAddress(location.address)
locationList[x].setLongitude(location.longitude)
locationList[x].setLatitude(location.latitude)
locationList[x].print_location_information()
# marking location using gmplot
# 1. Placing map(centered at KL)
gmap = gmplot.GoogleMapPlotter(locationList[0].latitude,
locationList[0].longitude, 13)
# 2. Placing all points(drop markers)
for x in range(len(locationList)):
gmap.marker(locationList[x].latitude, locationList[x].longitude)
# 3.draw the map
gmap.draw("mapOflocation.html")
#Getting distance between cities
from gmplot import gmplot
# Place map
gmap = gmplot.GoogleMapPlotter(77.8946302, 29.8622079, 8)
# # Polygon
# golden_gate_park_lats, golden_gate_park_lons = zip(*[
# (37.771269, -122.511015),
# (37.773495, -122.464830),
# (37.774797, -122.454538)
# ])
# gmap.plot(golden_gate_park_lats, golden_gate_park_lons, 'cornflowerblue', edge_width=10)
# # Scatter points
# top_attraction_lats, top_attraction_lons = zip(*[
# (37.769901, -122.498331),
# (37.768645, -122.475328),
# (37.771478, -122.468677),
# (37.769867, -122.466102),
# (37.767187, -122.467496),
# (37.770104, -122.470436)
# ])
# gmap.scatter(top_attraction_lats, top_attraction_lons, '#3B0B39', size=40, marker=False)
# # Marker
# hidden_gem_lat, hidden_gem_lon = 37.770776, -122.461689
# gmap.marker(hidden_gem_lat, hidden_gem_lon, '#3B0B39')
# Draw
gmap.draw("my_map.html")
#%% Determining how much a ships lat and long will move relative to speed
foo = features[np.where(100012.0 == labels)[0], :]
deltaTime = np.zeros(foo.shape[0] - 1)
deltaPos = np.zeros((foo.shape[0] - 1, 2))
for i in range(foo.shape[0] - 1):
deltaTime[i] = foo[i + 1, 0] - foo[i, 0]
deltaPos[i, 0] = foo[i + 1, 1] - foo[i, 1] # latitude
deltaPos[i, 1] = foo[i + 1, 2] - foo[i, 2] #longitude
print(np.sum(deltaTime) / np.shape(deltaTime))
print("longitude = x, latitude = y")
#%%
from gmplot import gmplot
uniq = np.array(np.unique(labels), dtype=int)
z = np.array([['#000000'], ['#0000CD'], ['#0000FF'], ['#00BFFF'],
['#00CED1'], ['#00FA9A'], ['#00FF00'], ['#00FF7F']])
gmap = gmplot.GoogleMapPlotter(36.931199, -76.113555, 13,
'get your own google API key')
lat3, long3 = zip(*[(features3[:, 1], features3[:, 2])])
gmap.scatter(lat3[0], long3[0], size=30, marker=False)
gmap.draw("F:\Python File Saves\html's\lastSet.html")
x, y = zip(*[(np.append(features[:, 1], features2[:, 1]),
np.append(features[:, 2], features2[:, 2]))])
gmap.scatter(x[0], y[0], z[0], size=30, marker=False)
gmap.draw("F:\Python File Saves\html's\scatter.html")
gmap.heatmap(x[0], y[0])
gmap.draw("F:\Python File Saves\html's\heatmap.html")
gmap.plot(x[0], y[0])
gmap.draw("F:\Python File Saves\html's\plot.html")
#%%
from sklearn.cluster import DBSCAN
import pandas as pd
# -*- coding: utf-8 -*-
"""
Created on Fri Jun 29 14:19:19 2018
@author: surbhi
"""
from gmplot import gmplot
# Place map
gmap = gmplot.GoogleMapPlotter(26.8851417, 75.6504706, 10)
# Scatter points
top_attraction_lats, top_attraction_lons = zip(*[
(26.9198857,75.8194477),#chaura rasta rd
(26.9200347,75.8249383),#johri bazar
(26.8504847,75.8001958),#malviya nagar
(26.9079421,75.7980539),#ashok nagar
(26.8466574,75.8073311),#girdhar marg
(26.9370594,75.8370154),#govind nagar
(26.8916497,75.7907282),#lalkothi
(26.9241727,75.7926167),#sindhi camp
(26.783114,75.8222804),#sitapura
(26.9167676,75.8109164),#MI road
(26.8997037,75.8005478),#rambagh
(26.9555944,75.7685048),#vidyadhar nagar
])
gmap.scatter(top_attraction_lats, top_attraction_lons, '#f21804', size=100, marker=False)
# Draw and save file as top10
gmap.draw("top10_hot_ar.html")
print('Path not reachable')
break
path.insert(0,start)
if shortest_distance[goal] != infinity:
print('Shortest distance is ' + str(shortest_distance[goal]))
print('And the path is ' + str(path))
print(dijkstra(graph, "KL Sentral", "Legoland"))
#TASK 4 : PLOTTING ROUTE
import gmaps
#import googlemaps
from gmplot import gmplot
#gmaps = googlemaps.Client(api_key)
gmap = gmplot.GoogleMapPlotter(2.64, 102.803, 7)
gmap.scatter(df1['Latitude'],df1['Longitude'], '#FFFFFF', size=100, marker=False)
gmap.draw('maptest.html')
lat = df1["Latitude"].tolist()
lng = df1["Longitude"].tolist()
route0_lat = [lat[0],lat[1],lat[2],lat[3]]
route0_lng = [lng[0],lng[1],lng[2],lng[3]]
gmap.plot(route0_lat, route0_lng, "white", edge_width = 3.0)
route1_lat = [lat[0],lat[9],lat[10],lat[7],lat[8],lat[3]]
route1_lng = [lng[0],lng[9],lng[10],lng[7],lng[8],lng[3]]
gmap.plot(route1_lat, route1_lng, "blue", edge_width = 3.0)
START_LNG = '78.5718'
DEST_LAT = '17.2403'
DEST_LNG = '78.4294'
VIA_LAT = '17.4033'
VIA_LNG = '78.4707'
MODES = ['car', 'pedestrian', 'truck']
URL = 'https://router.hereapi.com/v8/routes?transportMode=car&origin={},{}&destination={},{}&return=polyline&apikey={}'
URL = URL.format(START_LAT, START_LNG, DEST_LAT, DEST_LNG, API_KEY)
URL_VIA = 'https://router.hereapi.com/v8/routes?transportMode=car&origin={},{}&destination={},{}&via={},{}&return=polyline&apikey={}'
URL_VIA = URL_VIA.format(START_LAT, START_LNG, DEST_LAT, DEST_LNG, VIA_LAT,
VIA_LNG, API_KEY)
r = requests.get(URL)
print(r.json())
polyline = r.json()["routes"][0]["sections"][0]["polyline"]
coordinates_list = fp.decode(polyline)
lat_list, lng_list = zip(*coordinates_list)
HYD_LAT = "17.3850"
HYD_LNG = "78.4867"
gmap = gmplot.GoogleMapPlotter(HYD_LAT, HYD_LNG, 11)
gmap.marker(float(START_LAT), float(START_LNG))
gmap.marker(float(DEST_LAT), float(DEST_LNG))
gmap.plot(lat_list, lng_list, edge_width=10)
gmap.draw("my_map.html")
