with open('map.geojson') as f:
laArea = json.load(f)
laMap = folium.Map(location=[18.516726, 73.856255],
tiles="Stamen Toner",
zoom_start=12)
laMap = HeatMap(df).add_to(laMap)
folium.GeoJson(laArea).add_to(laMap)
#for i,row in df.iterrows():
# folium.CircleMarker((row.latitude,row.longitude), radius=3, weight=2, color='red', fill_color='red', fill_opacity=.5).add_to(laMap)
laMap.save('laPointMap.html')
x = pd.read_csv("a.csv")
y = x.Location[0]
locator = Nominatim(user_agent="myGeocoder")
location = locator.geocode(y)
p, q = location.latitude, location.longitude
array = [[p, q]]
x = df.append({'latitude': p, 'longitude': q}, ignore_index=True)
for i, row in x.iterrows():
folium.CircleMarker((row.latitude, row.longitude),
radius=3,
weight=2,
color='red',
def main():
# read the data
in_directory = 'amenities-vancouver.json.gz'
data = pd.read_json(in_directory, lines=True)
restaurants = data[(data['amenity'] == 'restaurant') |
(data['amenity'] == 'fast_food') |
(data['amenity'] == 'cafe')]
res = pd.read_json('restaurant.json')
fas = pd.read_json('fast_food.json')
piz = pd.read_json('pizzeria.json')
caf = pd.read_json('cafe.json')
# process and split the data
Unknown = restaurants[restaurants['name'].isnull()]
restaurants = restaurants[~restaurants['name'].isnull()]
restaurants['chain'] = restaurants['name'].apply(check_chain,
list_r=res,
list_f=fas,
list_p=piz,
list_c=caf)
chains1 = restaurants[restaurants['chain'] != 'NotChain'] # 960
Notchains1 = restaurants[restaurants['chain'] == 'NotChain']
Notchains1 = Notchains1.assign(num=1)
nc_group = Notchains1.groupby('name').count()
Notchains1['num'] = Notchains1['name'].apply(get_num, df=nc_group)
chains2 = Notchains1[Notchains1['num'] > 1] # 711
nchains = Notchains1[Notchains1['num'] == 1]
chains = pd.concat([
chains1[['amenity', 'lat', 'lon', 'name']],
chains2[['amenity', 'lat', 'lon', 'name']]
],
axis=0)
# analyze the data
# draw distribution
v_latitude = 49.14
v_longitude = -123.05
van_map_chains1 = folium.Map(location=[v_latitude, v_longitude],
zoom_start=10,
tiles='OpenStreetMap')
van_map_chains2 = folium.Map(location=[v_latitude, v_longitude],
zoom_start=10,
tiles='OpenStreetMap')
van_map_nchains = folium.Map(location=[v_latitude, v_longitude],
zoom_start=10,
tiles='OpenStreetMap')
chain1_group = folium.map.FeatureGroup()
chains1.apply(draw_marker, axis=1, foods=chain1_group, col='red')
fig = van_map_chains1.add_child(chain1_group)
fig.save("output_restaurant/chains_in_wikidata.html")
chain2_group = folium.map.FeatureGroup()
chains2.apply(draw_marker, axis=1, foods=chain2_group, col='green')
fig = van_map_chains2.add_child(chain2_group)
fig.save("output_restaurant/chains_notin_wikidata.html")
nchain_group = folium.map.FeatureGroup()
nchains.apply(draw_marker, axis=1, foods=nchain_group, col='blue')
fig = van_map_nchains.add_child(nchain_group)
fig.save("output_restaurant/nonchains.html")
# draw cluster
van_map_chains_cluster = folium.Map(location=[v_latitude, v_longitude],
zoom_start=10,
tiles='OpenStreetMap')
van_map_nchains_cluster = folium.Map(location=[v_latitude, v_longitude],
zoom_start=10,
tiles='OpenStreetMap')
chain_cluster = plugins.MarkerCluster().add_to(van_map_chains_cluster)
nchain_cluster = plugins.MarkerCluster().add_to(van_map_nchains_cluster)
chains.apply(draw_cluster, axis=1, foods=chain_cluster)
fig = van_map_chains_cluster.add_child(chain_cluster)
fig.save("output_restaurant/chains_cluster.html")
nchains.apply(draw_cluster, axis=1, foods=nchain_cluster)
fig = van_map_nchains_cluster.add_child(nchain_cluster)
fig.save("output_restaurant/nonchains_cluster.html")
# draw heat map
van_map_chains_heat = folium.Map(location=[v_latitude, v_longitude],
zoom_start=10,
tiles='OpenStreetMap')
van_map_nchains_heat = folium.Map(location=[v_latitude, v_longitude],
zoom_start=10,
tiles='OpenStreetMap')
heatchain = chains[['lat', 'lon']].values.tolist()
fig = HeatMap(heatchain).add_to(van_map_chains_heat)
fig.save("output_restaurant/chains_heat.html")
heatnchain = nchains[['lat', 'lon']].values.tolist()
fig = HeatMap(heatnchain).add_to(van_map_nchains_heat)
fig.save("output_restaurant/nonchains_heat.html")
# stats analysis
plt.figure(figsize=(12, 7))
plt.subplot(2, 2, 1)
plt.hist(chains['lon'])
plt.title('distribution of chains along lonitude')
plt.subplot(2, 2, 2)
plt.hist(nchains['lon'])
plt.title('distribution of non-chains along lonitude')
plt.subplot(2, 2, 3)
plt.hist(chains['lat'])
plt.title('distribution of chains along latitude')
plt.subplot(2, 2, 4)
plt.hist(nchains['lat'])
plt.title('distribution of chains along latitude')
plt.plot()
plt.savefig("output_restaurant/distribution_along_latitude_longitude.jpg")
c_sample = chains.sample(n=500)
n_sample = nchains.sample(n=500)
lon_levene_p = stats.levene(c_sample['lon'], n_sample['lon']).pvalue
lat_levene_p = stats.levene(c_sample['lat'], n_sample['lat']).pvalue
print("--------------------statistic data------------------------")
print("equal varible test:")
print("longitude p value: ", lon_levene_p)
print("latitude p value: ", lat_levene_p)
print("stds: ")
print("chains longitude std: ", chains['lon'].std(),
", non-chains longitude std: ", nchains['lon'].std())
print("chains latitude std: ", chains['lat'].std(),
", non-chains latitude std: ", nchains['lat'].std())
print("Mann-Whitney Utest:")
print(
"longitude p value: ",
stats.mannwhitneyu(c_sample['lon'],
n_sample['lon'],
alternative='two-sided').pvalue)
print(
"latitude p value: ",
stats.mannwhitneyu(c_sample['lat'],
n_sample['lat'],
alternative='two-sided').pvalue)
print("means:")
print("chains longitude mean: ", chains['lon'].mean(),
", non-chains longitude mean: ", nchains['lon'].mean())
print("chains latitude mean: ", chains['lat'].mean(),
", non-chains latitude mean: ", nchains['lat'].mean())
# density visualization
sns.set(style='darkgrid', color_codes=True)
fig = sns.jointplot(x="lon",
y="lat",
kind='kde',
data=chains,
color='red',
ratio=6)
fig.savefig('output_restaurant/chains_kde.png')
sns.set(style='darkgrid', color_codes=True)
fig = sns.jointplot(x="lon",
y="lat",
kind='kde',
data=nchains,
color='red',
ratio=6)
fig.savefig('output_restaurant/nonchains_kde.png')
print('Successfully Create HTML Files in folder output_restaurant!')
# 데이터 불러오기
import pandas as pd
station_data = pd.read_csv('Station_data.csv', encoding='euc-kr')
station_data = station_data[['주차장명', '위도', '경도']]
station_data = station_data.dropna(axis=0).reset_index()
# 주소, 위도, 경도 크롤링
station_name = station_data['주차장명']
station_lat = station_data['위도']
station_lng = station_data['경도']
# 맵
import folium
map = folium.Map(location=[station_lat.mean(), station_lng.mean()], tiles='stamentoner', zoom_start=8)
# 히트맵1 표시
from folium import plugins
map = map.add_children(plugins.HeatMap(zip(station_lat, station_lng), radius = 8))
map.save('Station_HeatMap1.html')
# 히트맵2 표시
from folium.plugins import HeatMap
map = HeatMap(zip(station_lat, station_lng)).add_to(map)
map.save('Station_HeatMap2.html')
import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)
# 데이터 불러오기
import pandas as pd
cctv_data = pd.read_csv('CCTV_data.csv', encoding='euc-kr')
cctv_data = cctv_data[['소재지지번주소', '촬영방면정보', '위도', '경도']]
cctv_data = cctv_data.dropna(axis=0).reset_index()
# CCTV 명칭 수정
cctv_data['CCTV'] = cctv_data['소재지지번주소'] + ' ' + cctv_data['촬영방면정보']
# 주소, 위도, 경도 크롤링
cctv_name = cctv_data['CCTV']
cctv_lat = cctv_data['위도']
cctv_lng = cctv_data['경도']
# 맵
import folium
map = folium.Map(location=[cctv_lat.mean(), cctv_lng.mean()], zoom_start=8)
# 히트맵1 표시
from folium import plugins
map = map.add_children(plugins.HeatMap(zip(cctv_lat, cctv_lng), radius = 8))
map.save('CCTV_HeatMap1.html')
# 히트맵2 표시
from folium.plugins import HeatMap
map = HeatMap(zip(cctv_lat, cctv_lng)).add_to(map)
map.save('CCTV_HeatMap2.html')
class MapTabWidget(QWidget):
def __init__(self, main_win):
super(QWidget, self).__init__(main_win)
self.main_win = main_win
self.base_path = os.getcwd()
self.main_layout = QGridLayout(self)
self.dock_area = DockArea()
self.main_layout.addWidget(self.dock_area, 1, 0, 4, 6)
self.lat_str = 'LATITUDE_ORIGINE'
self.long_str = 'LONGITUDE_ORIGINE'
self.csv_path = 'csv_data/remorquages.csv'
self.lats = None
self.longs = None
self.t_span_left = 0
self.t_span_right = 100
self.plot_range_left = 0
self.plot_range_right = 400
self.map_path = os.path.join(self.base_path, 'montreal_map.html')
# Select file
self.create_select_file_form()
# Settings dock
self.create_settings_dock()
# Map
self.m = self.create_map()
# View
self.view_dock = InnerDock(self.main_layout,
'Saving',
b_pos=(2, 0),
toggle_button=False,
size=(40, 40))
self.create_view()
# Time span dock
self.time_span_dock, self.t_plot = self.create_time_span_dock()
self.setLayout(self.main_layout)
def create_heat_map(self):
self.hm_wide = HeatMap(list(zip(self.lats, self.longs)),
min_opacity=0.01,
radius=37,
blur=95,
max_zoom=1)
self.m.add_children(self.hm_wide)
self.hm_wide.save('heatmap.html')
def create_settings_dock(self):
settings_dock = InnerDock(self.main_layout,
'Settings',
b_pos=(0, 1),
toggle_button=True,
size=(1, 1))
self.dock_area.addDock(settings_dock.dock)
# Line edit
form = QGroupBox('')
f_l = QFormLayout()
form.setLayout(f_l)
df_possible_val = ['Latitude field', 'Longitude field', 'Time field']
self.df_combobox = [QComboBox() for _ in range(len(df_possible_val))]
for val, cb in zip(df_possible_val, self.df_combobox):
f_l.addRow(QLabel(f'{val}: '), cb)
cb.name = val
cb.activated[str].connect(partial(self.set_cb_val, cb))
settings_dock.layout.addWidget(form)
return settings_dock
def change_t_boundaries(self, r):
self.t_span_left = int(r.boundingRect().left())
self.t_span_right = int(r.boundingRect().right())
print('left: ', self.t_span_left, 'right: ', self.t_span_right)
def set_cb_val(self, cb, cb_val):
if cb.name == 'Latitude field':
self.lat_str = cb_val
elif cb.name == 'Longitude field':
self.long_str = cb_val
def create_time_span_dock(self):
time_span_dock = InnerDock(self.main_layout,
'Time span',
b_pos=(0, 2),
toggle_button=True,
size=(1, 1))
self.dock_area.addDock(time_span_dock.dock)
# Date
d_axis = DateAxis(orientation='bottom')
# time plot region
t_plot = pg.PlotWidget(background=dark_grey,
axisItems={'bottom': d_axis})
t_plot.setXRange(self.plot_range_left, self.plot_range_right)
t_plot.hideAxis('left')
# Region
t_region = pg.LinearRegionItem([self.t_span_right, self.t_span_left])
t_region.sigRegionChanged.connect(
partial(self.change_t_boundaries, t_region))
t_plot.addItem(t_region, ignoreBounds=True)
# Add date to
# dates = np.arange(2) * (3600*24*356)
# t_plot.plot(x=dates, y=[0, 0], symbol='o')
time_span_dock.layout.addWidget(t_plot)
return time_span_dock, t_plot
def create_select_file_form(self):
# Dock
opening_dock = InnerDock(self.main_layout,
'Select file',
b_pos=(0, 0),
toggle_button=True,
size=(1, 1))
self.dock_area.addDock(opening_dock.dock)
csv_path_edit = QLineEdit('')
# Buttons
# Choose map b
choose_map_file_b = QPushButton('Choose csv data file')
choose_map_file_b.clicked.connect(partial(self.select_f,
csv_path_edit))
# Read csv_data b
read_header_b = btn('Read csv data',
opening_dock.layout,
pos=(0, 2),
func_conn=self.read_header,
color=map_blue_b,
txt_color=white)
# Open csv_data b
add_data_to_map_b = btn('Add csv data to map',
opening_dock.layout,
pos=(0, 3),
func_conn=self.refresh_map,
color=map_blue_b,
txt_color=white)
# add_data_to_map_b.clicked.connect( self.refresh_map)
# Add to layout
opening_dock.layout.addWidget(choose_map_file_b, 0, 0)
opening_dock.layout.addWidget(csv_path_edit, 0, 1)
# .addWidget(add_data_to_map_b, 0, 2)
def select_f(self, csv_path_edit):
f_name = select_file(self.main_win, open=True, f_extension='.csv')
csv_path_edit.setText(f_name)
self.csv_path = f_name
def refresh_map(self):
self.create_map()
self.add_data_to_map()
# Heat map
self.create_heat_map()
self.create_view(refresh=True)
try:
self.time_span_dock.dock.close()
except AttributeError as e:
print('Error', e)
self.time_span_dock, self.t_plot = self.create_time_span_dock()
def create_map(self):
m = folium.Map(location=[45.5088, -73.554],
tiles='Stamen Toner',
zoom_start=12,
control_scale=True)
m.save('mtl_map.html')
return m
def create_combobox(self, df_vals):
for cb in self.df_combobox:
for val in df_vals:
cb.addItem(val)
def read_header(self):
remorquage_csv = pd.read_csv(self.csv_path)
remorquage_df = pd.DataFrame(remorquage_csv)
df_vals = remorquage_df.columns.values
self.create_combobox(df_vals)
def read_data(self):
remorquage_csv = pd.read_csv(self.csv_path)
remorquage_df = pd.DataFrame(remorquage_csv)
self.lats = np.array(
remorquage_df[self.lat_str])[self.t_span_left:self.t_span_right]
self.longs = np.array(
remorquage_df[self.long_str])[self.t_span_left:self.t_span_right]
def add_data_to_map(self):
self.read_data()
for lat, long in zip(self.lats, self.longs):
try:
folium.Marker([lat, long]).add_to(self.m)
except ValueError as e:
pass
self.m.save('mtl_map.html')
def create_view(self, refresh=False):
view = QtWebEngineWidgets.QWebEngineView()
view.load(QtCore.QUrl().fromLocalFile(
os.path.join(self.base_path, 'mtl_map.html')))
if refresh == True:
view.load(QtCore.QUrl().fromLocalFile(
os.path.join(self.base_path, 'heatmap.html')))
self.view_dock.layout.addWidget(view, 0, 0)
self.dock_area.addDock(self.view_dock.dock)
