def show_map():
latitude = 48.445
longitude = 21.687
np.random.seed(3141592)
initial_data = (
np.random.normal(size=(300, 2)) * np.array([[0.003, 0.003]]) +
np.array([[latitude, longitude]]))
move_data = np.random.normal(size=(300, 2)) * 0.00001
data = [(initial_data + move_data * i).tolist() for i in range(100)]
weight = 1 # default value
for time_entry in data:
for row in time_entry:
row.append(weight)
mapa = folium.Map([48.726, 21.249], tiles='OpenStreetMap', zoom_start=14)
hm = HeatMapWithTime(data, auto_play=True, max_opacity=0.8, radius=5)
hm.add_to(mapa)
ref = db.reference('vines')
result = ref.get()
for res in result:
folium.Marker(location=[
float(result[res]['latitude']),
float(result[res]['longitude'])
],
popup=result[res]['class'],
icon=folium.Icon(color='green')).add_to(mapa)
mapa.save('mapa.html')
return send_file('mapa.html')
def get_heatmapWithTime(self):
data = self.og_data
data['hour']=data['datetime'].apply(lambda x: x.hour)
locations = {
"Torino": [45.0781, 7.6761],
"Amsterdam": [52.3676, 4.9041],
"Austin": [30.2672, -97.7431],
"Berlin": [52.5200, 13.4050],
"Calgary": [51.0447, -114.0719],
"Columbus": [39.9612, -82.9988],
"Denver": [39.7392, -104.9903],
"Firenze": [43.7696, 11.2558],
"Frankfurt": [50.1109, 8.6821],
"Hamburg": [53.5511, 9.9937]
}
_map = folium.Map(location=locations[self.parametro],
tiles='Stamen Toner',
zoom_start = 12)
heat_df = data[['hour','lat','lng']]
heat_df = heat_df.dropna(axis=0, subset=['hour','lat','lng'])
lat_long_list = []
for i in range(0,24):
temp=[]
for index, instance in heat_df[heat_df['hour'] == i].iterrows():
temp.append([instance['lat'],instance['lng']])
lat_long_list.append(temp)
HeatMapWithTime(lat_long_list,radius=7,auto_play=True, position='bottomright').add_to(_map)
return _map
def heapMapTime():
#Create the map
start_coords = (-34.60, -58.42)
folium_map = folium.Map(location=start_coords, zoom_start=13)
# Seleccionamos solo las columnas de coordenadas validas para la fecha seleccionada
df = initDataFrame()
# Seleccionamos solo las columnas de coordenadas validas para la fecha seleccionada
df = df[(df['latitud'] != 0) & (df['longitud'] != 0) & (df['anho'] == 2018)
& (df['mes'] <= 3) & (df['solo_hora'] != 99)]
#Creamos la lista de 24 horas
df_hour_list = []
for hour in df.solo_hora.sort_values().unique():
df_hour_list.append(df.loc[df.solo_hora == hour,
['latitud', 'longitud', 'count']].groupby([
'latitud', 'longitud'
]).sum().reset_index().values.tolist())
#Creamos y agregamos el heatmap por horas
HeatMapWithTime(df_hour_list,
radius=9,
gradient={
0.2: 'blue',
0.4: 'lime',
0.6: 'orange',
1: 'red'
},
min_opacity=0.1,
max_opacity=0.8,
use_local_extrema=True).add_to(folium_map)
#Save in html
folium_map.save('static/mapWithTime.html')
return render_template('mapa2.html', current_time=int(time.time()))
def heatmap_with_time(df: pd.DataFrame,
geo_wkt_col: str,
time_col: str,
agg_unit: str = MINUTE_AGG) -> HeatMapWithTime:
"""
A visualization utility function for visualizing a timed-geographic layer with a folium's HeatMapWithTime.
The function aggregates the times correctly and inserts the parameters correctly into the object.
Args:
df: The dataframe we want to visualize
geo_wkt_col: The geographic column's name, holding wkt objects
time_col: The time column's name
agg_unit: The time unit for the aggregation
Returns:
A HeatMapWithTime object to use with a folium map
"""
df = df[[geo_wkt_col, time_col]].copy()
df[VIS_GEO_SHP] = df[geo_wkt_col].apply(lambda x: loads(x))
df = _aggregate_datetime(df, time_col, VIS_AGG_TIME, agg_unit)
time_groupby_dict = df.groupby(VIS_AGG_TIME).groups
time_index = sorted(list(time_groupby_dict.keys()))
data = []
for t in time_index:
data.append(
list(
map(lambda shp: [shp.centroid.y, shp.centroid.x],
df.iloc[time_groupby_dict[t]][VIS_AGG_TIME])))
time_index_str = [dt.strftime('%Y-%m-%d %H:%M') for dt in time_index]
return HeatMapWithTime(data,
index=time_index_str,
auto_play=True,
max_opacity=0.5)
def main():
# Create Heatmap
curr_dir = os.getcwd()
confirmed_path = curr_dir + '/data/time_series_covid_19_confirmed.csv'
death_path = curr_dir + '/data/time_series_covid_19_deaths.csv'
recovered_path = curr_dir + '/data/time_series_covid_19_recovered.csv'
map = Map(confirmed_path, death_path, recovered_path)
days = map.parse_data_by_day()
HeatMapWithTime(days,
radius=10,
gradient={
0.1: '#99FFFF',
0.2: '#66FF66',
0.4: '#FFFF66',
0.6: '#FF9933',
0.8: '#FF0000',
1.0: '#990000'
},
min_opacity=0.5,
max_opacity=1,
use_local_extrema=True,
min_speed=5,
auto_play=True).add_to(map.map)
map.save_map()
# Host html on localhost
run_server()
def folium_moving():
df = df_ny_box()
timezone_name = 'America/New_York'
time_column = "pickup_datetime"
df.index = pd.to_datetime(df[time_column])
df.index = df.index.tz_convert(timezone_name)
df["dow"] = df.index.weekday
df["hour"] = df.index.hour
df["month"] = df.index.month
df["year"] = df.index.year
df.reset_index(drop=True)
gradient = {0.2: 'blue', 0.4: 'lime', 0.6: 'orange', 1: 'red'}
heatmap_data_by_hour = []
__df__ = df.copy()
for hour in df.hour.sort_values().unique():
_df = __df__[__df__.hour == hour][[
'pickup_latitude', 'pickup_longitude', 'passenger_count'
]].groupby(['pickup_latitude',
'pickup_longitude']).sum().reset_index().values.tolist()
heatmap_data_by_hour.append(_df)
center_location = [40.758896, -73.985130]
m2 = folium.Map(location=center_location,
control_scale=True,
zoom_start=11)
HeatMapWithTime(heatmap_data_by_hour,
radius=5,
gradient=gradient,
min_opacity=0.5,
max_opacity=0.8,
use_local_extrema=False).add_to(m2)
return m2
def gen_heat_map(df_strava_travs_sliced):
#First handle empty sliced df case. Create a generic zoomed out map with additional features
if len(df_strava_travs_sliced) == 0:
m = folium.Map(location=[36, -108], zoom_start=4, control_scale=True)
folium.TileLayer('stamenterrain').add_to(m)
m.save('map.html'
) #Save map without routes or markers and create dash layout
return html.Iframe(id='mainview',
srcDoc=open('map.html', 'r').read(),
width='100%',
height='100%')
#Slice not empty:
#Create map based on staring location of last run
init_coord = df_strava_travs_sliced.iloc[-1]['start_latlng']
init_coord = ast.literal_eval(init_coord)
m = folium.Map(location=init_coord, zoom_start=12, control_scale=True)
folium.TileLayer('stamenterrain').add_to(m)
#Initilaize arrays to store heatmap parameters
heat_coords = []
heat_date_ind = []
for i in df_strava_travs_sliced.index:
route_coord = polyline.decode(
df_strava_travs_sliced.loc[i]['map.summary_polyline'])
route_coord = [[i[0], i[1]] for i in route_coord]
#Estimate number of splits
cnt_splits = max(
round(m_to_mi(df_strava_travs_sliced.loc[i]['distance'])), 1)
coords_in_split = len(
route_coord
) // cnt_splits #Count number of coorindates to include in split
route_coord = [
route_coord[x:x + coords_in_split]
for x in range(0, len(route_coord), coords_in_split)
]
heat_coords.extend(route_coord) #Add coordinates into list
heat_date_ind.extend(
[s_to_easyDate(df_strava_travs_sliced.loc[i]['event_date'][0:10])
] * len(route_coord)) #Get date as heatmap time index
heat_coords_flat = [item for sublist in heat_coords for item in sublist]
#Construct HeatMap
HeatMap(heat_coords_flat, radius=6).add_to(m)
#Construct HeatMap with time
HeatMapWithTime(heat_coords,
heat_date_ind,
radius=12,
min_opacity=2,
max_opacity=4,
min_speed=5,
max_speed=12,
speed_step=1).add_to(m)
#Save the map and create the mainview
m.save('map.html')
return html.Iframe(id='mainview',
srcDoc=open('map.html', 'r').read(),
width='100%',
height='100%')
def generate_hotmap(data, name):
'''
Generate dynamic hotmap with input data and save as a html file.
:param data: a 3-d list of [[[latitude, longitude, average_speed]]] for each hour for each location
:param name: a str
:return: no return
'''
map_osm = folium.Map(location=[31.2234, 121.4814], zoom_start=10)
HeatMapWithTime(data, radius=10).add_to(map_osm)
map_osm.save(name)
def heatmap(gdf,
geometry_column='geometry',
with_time=False,
time_column='Year',
name=None,
show=False,
basemap=None,
**kwargs):
"""
Create a heatmap or a heatmap with time from a geodataframe of points.
:param gdf: Geodataframe with points as the geometry type.
:param geometry_column: The geometry column of the gdf. Defaults to 'geometry'
:param start_color: The start color, defaults to 'white'
:param end_color: The end color, defaults to the MI blue
:param with_time: If true, plot a heat map with time, not just a heat map.
:param time_column: The column used to specify the years of the data, defaults to 'Year'
:param str name: Defaults to None. If not None, will generate a FeatureGroup with this name and return that instead of
the GeoJson object.
:param bool show: Defaults to False. The show parameter for the FeatureGroup that the GeoJson will be added to.
:param folium.Map basemap: Defaults to None. If not none, will add the GeoJson or FeatureGroup to the supplied basemap.
:param **kwargs: kwargs to be passed onto the 'heatmap' or 'heatmapwithtime' folium constructors.
:return: HeatMap object or FeatureGroup
"""
if with_time:
all_points = []
time_periods = sorted(gdf[time_column].unique().tolist())
for time_period in time_periods:
points = gdf.loc[gdf[time_column] == time_period, geometry_column]
points = [
utilities.simple.retrieve_coords(point) for point in points
]
all_points.append(points)
result = HeatMapWithTime(all_points, index=time_periods, **kwargs)
else:
points = [
utilities.simple.retrieve_coords(point)
for point in gdf[geometry_column]
]
result = HeatMap(points, **kwargs)
if name is not None:
feature_group = folium.FeatureGroup(name, show=show)
result.add_to(feature_group)
if basemap is not None:
feature_group.add_to(basemap)
return feature_group
else:
if basemap is not None:
result.add_to(basemap)
return result
def generate_map(server=False):
tmp = path + "/corona.html"
df = pd.read_csv(path + '/gps_dated/gps_dated.csv')
df = df.loc[df.index.repeat(df.total)]
dates = df.date.unique()
heat = []
for i in dates:
tmp_df = df.loc[df['date'] == i]
tmp_heat = [[row["lat"], row["lon"]] for idx, row in tmp_df.iterrows()]
heat.append(tmp_heat)
folium_map = folium.Map(location=[df.lat.mean(),
df.lon.mean()],
zoom_start=4.4,
attr="CoViD19 no Brasil Agora")
folium_map.add_child(
HeatMapWithTime(heat,
index=list(dates),
auto_play=True,
name='Coronavirus'))
for i in dates:
tmp_df = df.loc[df['date'] == i]
mk = MarkerCluster(name='Cluster ' + i, show=False)
for lat, lon in zip(tmp_df.lat, tmp_df.lon):
folium.CircleMarker(
location=[lat, lon],
radius=(10) / 2,
fill_opacity=0.9,
fill_color='#3186cc',
).add_to(mk)
folium_map.add_child(mk)
folium_map.add_child(folium.LayerControl())
f.write("Saving html...\n")
try:
folium_map.save(tmp)
f.write("Saved!\n")
except:
f.write("Error in saving process!!!\n")
if (server):
with open(tmp) as fi:
folium_map_html = fi.read()
run_html_server(folium_map_html)
def plotHeatMap(values, date_range):
base_map = folium.Map(location=[-31.420082, -64.188774])
HeatMapWithTime(values,
index=date_range,
radius=25,
gradient={
0.0: 'blue',
0.2: 'lime',
0.4: 'orange',
1: 'red'
},
auto_play=True,
max_opacity=1).add_to(base_map)
filename = tempfile.NamedTemporaryFile(prefix='heatmap_').name + '.html'
base_map.save(filename)
webbrowser.open(filename)
def generate_heat_map_with_time(
self,
style: int = 6,
zoom_start: int = 12,
time_var: str = "hours",
time_max_val: int = 24,
):
"""
Generates a interactive HeatMap which enables a geographic visualization by time.
:param style: indicates which style of the map to be used
:type style: int
:param zoom_start: set the initial zoom of the map
:type zoom_start: int
:param time_var: the label of the time column by which the data is analyzed by
:type time_var: str
:param time_max_val: the maximal time value to be shown
:type time_max_val: int
:return:
"""
junk_coord = (
-360
) # Junk values are inserted here such that the time variable matches the time filter
self._generate_base_map(style, zoom_start)
df_tmp = self.data[[self.lat, self.lon, time_var]]
time_list = [[[
junk_coord, junk_coord
]]] * time_max_val # Initial list with junk values to be replaced
for t in df_tmp[time_var].sort_values().unique():
if t > 0:
time_list[t - 1] = (df_tmp.loc[
df_tmp[time_var] == t, self.coordinates].groupby(
self.coordinates).sum().reset_index().values.tolist())
else:
time_list[time_max_val] = (df_tmp.loc[
df_tmp[time_var] == t, self.coordinates].groupby(
self.coordinates).sum().reset_index().values.tolist())
HeatMapWithTime(
time_list,
radius=5,
gradient=self._grad_list,
min_opacity=0.5,
max_opacity=0.8,
use_local_extrema=True,
).add_to(self.map)
def setup_bike_count_heat_map(bike_data):
bike_count_heat_map = folium.Map(location=seattle_coords,
min_zoom=13,
max_bounds=True)
bike_count_heat_map.add_child(
HeatMapWithTime(data=bike_data,
index=date_indices,
radius=50,
gradient={
0.2: 'blue',
0.4: 'lime',
0.6: 'orange',
1: 'red'
},
use_local_extrema=True,
min_opacity=0.5,
max_opacity=0.8))
bike_count_heat_map.save("bike_count_heat_map.html")
def heatmap_with_time(df_,
n_rows,
lat_origin=None,
lon_origin=None,
zoom_start=12,
radius=5,
min_opacity=0.5,
max_opacity=0.8,
base_map=None,
save_as_html=False,
filename='heatmap_with_time.html'):
if base_map is None:
if lat_origin is None and lon_origin is None:
lat_origin = df_.loc[0]['lat']
lon_origin = df_.loc[0]['lon']
base_map = generateBaseMap(default_location=[lat_origin, lon_origin],
default_zoom_start=zoom_start)
COUNT = 'count'
df_['hour'] = df_.datetime.apply(lambda x: x.hour)
df_[COUNT] = 1
df_hour_list = []
for hour in df_.hour.sort_values().unique():
df_hour_list.append(df_.loc[df_.hour == hour,
['lat', 'lon', COUNT]].groupby([
'lat', 'lon'
]).sum().reset_index().values.tolist())
HeatMapWithTime(df_hour_list[:n_rows],
radius=radius,
gradient={
0.2: 'blue',
0.4: 'lime',
0.6: 'orange',
1: 'red'
},
min_opacity=min_opacity,
max_opacity=max_opacity,
use_local_extrema=True).add_to(base_map)
df_.drop(columns=[COUNT, 'hour'], inplace=True)
if save_as_html:
base_map.save(outfile=filename)
else:
return base_map
def bushfire_spread_map():
#Heat map object for bush fire
bush_fire_map = folium.Map(location=[-25.2744, 133.7751], zoom_start=4)
if request.method == 'POST':
f = request.files['bushfire_csvfile']
df = pd.read_csv(f)
#group by all the rows according to date so that the map visualizes bush fires according to date
date_groupby_list = df.groupby('date').apply(
lambda x: x[['latitude', 'longitude']].values.tolist())
dt_obj = [
datetime.strptime(i, '%d-%m-%Y') for i in date_groupby_list.index
]
date_index = [x.strftime('%d-%m-%Y') for x in dt_obj]
date_hour_date = date_groupby_list.tolist()
HeatMapWithTime(date_hour_date, index=date_index).add_to(bush_fire_map)
return bush_fire_map.get_root().render()
def upload():
if request.method == 'POST':
df_incidents = pd.read_csv(request.files.get('file'))
#df_incidents = pd.read_csv('data.csv')
#print('Dataset downloaded and read into a pandas dataframe!')
df_incidents.head()
Italy_map = folium.Map(location=[41.9028, 12.4964], zoom_start=13)
incidents = folium.map.FeatureGroup()
#converting latitude and longitude to float values
df_incidents.Longitude = df_incidents.Longitude.astype(float)
df_incidents.Latitude = df_incidents.Latitude.astype(float)
# loop through the 100 crimes and add each to the incidents feature group
# add incidents to map of Italy
Italy_map.add_child(incidents)
from folium.plugins import HeatMapWithTime
#base_map = generateBaseMap(default_zoom_start=11)
df_century_list = []
for century in df_incidents.Century_of_Origin.sort_values().unique():
df_century_list.append(
df_incidents.loc[df_incidents.Century_of_Origin == century,
['Latitude', 'Longitude']].groupby([
'Latitude', 'Longitude'
]).sum().reset_index().values.tolist())
df_century_list
centuries = []
centuries = df_incidents.Century_of_Origin.sort_values().unique()
centuries = list(centuries)
centuries
HeatMapWithTime(df_century_list,
radius=15,
index=centuries,
position='topright',
name='CO2 (micro-atm)',
control=True).add_to(Italy_map)
Italy_map.save("Italy.html")
return render_template('frameset.html', src1=page1, src2=page2)
return render_template('upload.html')
def heatmap(pollutant):
"""
Returns a heatmap with time of the pollutant levels at each station
Returns:
Map: folium heatmap with time
"""
folium_map = folium.Map(location=[46, 2.291705], zoom_start=7)
client = DBClient("database")
ordered_mesures = client.get_mesures_by_time(pollutant)
global_max = get_global_max(ordered_mesures)
heatmap_data = []
heatmap_index = []
for time in ordered_mesures:
heatmap_data.append([[
mesure["position"]["x"], mesure["position"]["y"],
mesure["value"] / global_max
] for mesure in ordered_mesures[time]])
heatmap_index.append(dt.datetime.strftime(time, "%d/%m %H:%M:%S"))
HeatMapWithTime(heatmap_data, position="topright",
index=heatmap_index).add_to(folium_map)
return folium_map
def languages():
'''Return data in json format'''
df_incidents = pd.read_csv('data.csv')
print('Dataset downloaded and read into a pandas dataframe!')
df_incidents.head()
Italy_map = folium.Map(location=[41.9028, 12.4964], zoom_start=13)
incidents = folium.map.FeatureGroup()
#converting latitude and longitude to float values
df_incidents.Longitude = df_incidents.Longitude.astype(float)
df_incidents.Latitude = df_incidents.Latitude.astype(float)
# loop through the 100 crimes and add each to the incidents feature group
# add incidents to map of Italy
Italy_map.add_child(incidents)
from folium.plugins import HeatMapWithTime
#base_map = generateBaseMap(default_zoom_start=11)
df_century_list = []
for century in df_incidents.Century_of_Origin.sort_values().unique():
df_century_list.append(
df_incidents.loc[df_incidents.Century_of_Origin == century,
['Latitude', 'Longitude']].groupby([
'Latitude', 'Longitude'
]).sum().reset_index().values.tolist())
#df_century_list
centuries = []
centuries = df_incidents.Century_of_Origin.sort_values().unique()
centuries = list(centuries)
centuries
HeatMapWithTime(df_century_list,
radius=15,
index=centuries,
position='topright',
name='CO2 (micro-atm)',
control=True).add_to(Italy_map)
Italy_map.save("Italy.html")
#lst = ["Python", 'HTML', 'JavaScript', 'CSS']
#words = {}
#words['choice'] = random.choice(lst)
return jsonify(Italy_map)
def get_heatmap_video(self,
radius=10,
auto_play=True,
resolution='h',
window_size=1):
# resample
xy = self.data[self.GPS_INDEX]
xy = xy.resample(resolution).mean().interpolate(limit_direction='both').values
windows = self.rolling_window(np.arange(len(xy)), window_size)
xy = xy[windows].tolist()
# build heatmap
heatmap = HeatMapWithTime(xy,
auto_play=auto_play,
display_index=False,
radius=radius,
index_steps=1,
min_speed=1,
max_speed=24,
speed_step=1)
return heatmap
def generate_HeatMapTime(data, location=None, zoom_start=None):
'''
This function generates animated Heat Map by Time based on current observations
Parameters
----------
data: array of arrays or so called 2-D array.
First dimension is related to the largest Time span (e.g. months of year if the user want to create a monthly animated HeatMap).
Second dimension is related to the second-largest Time (e.g. days of month if the user want to create a montly animated HeatMap)
The data grouped by Time is a 3 element array-like value (e.g., an array, list, or tuple) in the order of [latitude, longitude, value]
location: array [latitude, longitude], optional
Location of center of the basemap that will be zoomed in when generating the basemap
By default, the location of New York City [40.693943, -73.985880] will be used
zoom_start: integer, optional
Level of zoom to the basemap. By default, value of 12 will be used
Returns
-------
basemap
The animated basemap in generated based on current observation.
The basemap will be exported as an .html
file and can be visualized simply by open this .html file
Examples
-------
>>>
generate_HeatMapTime(location=[40.693943, -73.985880], zoom_start=12, data=df)
'''
import folium
from folium.plugins import HeatMapWithTime
# Default values for location and zoom levels
if location is None:
location = [40.693943, -73.985880]
if zoom_start is None:
zoom_start = 12
# Generate the basemap by location and zoom level
basemap = folium.Map(location=location,
control_scale=True,
zoom_start=zoom_start)
try:
# Generate an animated HeatMap by Time
HeatMapWithTime(data,
radius=17,
min_opacity=0.5,
max_opacity=0.8,
use_local_extrema=True,
gradient={
0.2: 'blue',
0.4: 'lime',
0.6: 'orange',
1: 'red'
}).add_to(basemap)
except Exception as e:
print(e)
basemap.save("C:/Users/tvo/Desktop/test_heatmaptime.html")
return basemap
def sim_folium_heat(geogridfile, griddatafile):
#if os.path.exists(geogridfile):
# print( "ok esiste" )
geogrid = gpd.read_file(geogridfile).sort_index()
geogrid.id = geogrid.id.astype(int)
geogrid['centroid'] = geogrid.to_crs(epsg=3857).geometry.centroid.to_crs(
epsg=4326)
geogrid['cen_lat'] = [p.y for p in geogrid['centroid']]
geogrid['cen_lon'] = [p.x for p in geogrid['centroid']]
with open(griddatafile) as gin:
griddata = json.load(gin)
sim_id = griddata['sim_id']
griddata = griddata['grid_cnt']
griddata = [{
'timestamp': ts,
'cell_id': int(gid),
'cnt': val,
} for ts, cnt in griddata.items() for gid, val in cnt.items()]
gridcnt = pd.DataFrame.from_dict(griddata)
#gridcnt['norm_cnt'] = (gridcnt.cnt - gridcnt.cnt.min()) / (gridcnt.cnt.max() - gridcnt.cnt.min())
gridcnt['norm_cnt'] = gridcnt.cnt / gridcnt.cnt.max()
#print(gridcnt)
gridcnt = gridcnt.merge(geogrid[['id', 'cen_lat', 'cen_lon']],
left_on='cell_id',
right_on='id')
time_label = []
data = []
for ts, dfg in gridcnt.groupby('timestamp'):
#dt = f"{pd.to_datetime(ts, unit='s').tz_localize('utc').tz_convert('Europe/Rome')}"
dt = str(
pd.to_datetime(
ts, unit='s').tz_localize('utc').tz_convert('Europe/Rome'))
time_label.append(dt)
data.append(dfg[['cen_lat', 'cen_lon', 'norm_cnt']].values.tolist())
# print(dt, dfg.cnt.sum())
#print(time_label)
m = folium.Map(control_scale=True)
_radius = 60
if "ubrovnik" in str(geogridfile):
_radius = 100
HeatMapWithTime(
data=data,
index=time_label,
radius=_radius,
# gradient={'0':'Navy', '0.25':'Blue','0.5':'Green', '0.75':'Yellow', '0.85':'orange','1': 'Red'},
gradient={
'0': 'gray',
'0.2': 'Blue',
'0.4': 'Green',
'0.6': 'Yellow',
'0.8': 'orange',
'1': 'Red'
},
# gradient={0.0: 'blue', 0.1: 'orange', 0.5: 'red'},
min_opacity=0.2,
max_opacity=0.6,
use_local_extrema=False,
display_index=True,
auto_play=True,
).add_to(m)
MeasureControl().add_to(m)
colormap = cm.LinearColormap(
colors=['gray', 'Blue', 'Green', 'Yellow', 'orange', 'red'],
index=[0, 0.2, 0.4, 0.6, 0.8, 1],
# tick_labels=[0, 25, 50, 75, 85, 100],
caption='Density of population')
m.add_child(colormap)
s, w = geogrid[['cen_lat', 'cen_lon']].min()
n, e = geogrid[['cen_lat', 'cen_lon']].max()
m.fit_bounds([[s, w], [n, e]])
text_save = f'{html_folder}/heatmap_{sim_id}.html'
m.save(text_save)
print(f'* File saved in: {text_save}')
lon_point_list = [-0.286666667, -0.182222222, -0.3625, -0.475555556]
addpolygontomap(lat_point_list, lon_point_list, 'Luton CTA 7')
lat_point_list = [51.86388889, 51.87888889, 51.9175]
lon_point_list = [-0.726666667, -0.641111111, -0.731388889]
addpolygontomap(lat_point_list, lon_point_list, 'Luton CTA 8')
lat_point_list = [51.86388889, 51.9175, 51.96361111, 51.89888889, 51.84666667]
lon_point_list = [
-0.726666667, -0.731388889, -0.679888889, -0.834863889, -0.823888889
]
addpolygontomap(lat_point_list, lon_point_list, 'Luton CTA 9')
lat_point_list = [
51.87888889, 51.91972222, 51.96194444, 51.9825, 51.845, 51.80833333,
51.75083333
]
lon_point_list = [
-0.641111111, -0.407222222, -0.3625, -0.242777778, -0.158611111,
-0.251666667, -0.5825
]
addpolygontomap(lat_point_list, lon_point_list, 'Luton CTR')
### Luton ###
#Now add the heatmap data
HeatMapWithTime(date_hour_data, index=date_hour_index,
radius=8).add_to(flight_map_time)
#save it as a html
flight_map_time.save('/Users/Gareth.Ahern/Desktop/mapwithtimemapall999.html')
#%% To change a bit I'm trying to develop in the following line a heatmap timed
from folium.plugins import HeatMap, HeatMapWithTime
import branca.colormap as cm
center = (45.74808, 4.82355)
m = folium.Map(center, zoom_start=12, tiles='OpenStreetMap')
h = folium.FeatureGroup(name='Temps de parcours')
locations = []
mamax = 100 #scaling my speed here
dimi = []
for pp in np.arange(1, 480, 1):
locations = []
for idx, row in Speed_and_Geom.iterrows():
temp = row['geom'].split('|')
for bla in temp:
locations.append([
float(bla.split(',')[0]),
float(bla.split(',')[1]), row[pp] / mamax
])
dimi.append(locations)
HeatMapWithTime(dimi, radius=20, gradient={0: 'green', 1: 'red'}).add_to(m)
m.add_child(h)
m.save('Timedheat.html')
#this map does not bring much with its current version, but I guess there might have potential on the next upgrade
import math
# Importing the dataset
dataset = pd.read_csv('Vietnam_Bombing_Operations_STRIKE_HIT_YN.csv')
import folium
from folium import Choropleth, Circle, Marker
from folium.plugins import HeatMap, MarkerCluster, HeatMapWithTime
# Create a map
m_1 = folium.Map(location=[17.34, 106.71],
tiles='Stamen Terrain',
zoom_start=8)
# Add points to the map
tgtloc = []
msn_date = []
for idx, row in dataset.iterrows():
if not math.isnan(row['TGTLONDDD_DDD_WGS84']) and not math.isnan(
row['TGTLATDD_DDD_WGS84']):
tgtloc.append([row['TGTLATDD_DDD_WGS84'], row['TGTLONDDD_DDD_WGS84']])
msn_date.append(row['MSNDATE'])
# m_1.add_child(mc)
#HeatMap(data=tgtloc, radius=10).add_to(m_1)
HeatMapWithTime(data=tgtloc, index=msn_date, radius=10).add_to(m_1)
# Display the map
m_1.save('index.html')
def get_timelapse():
file = "static/Data/all_data.csv"
param = "Ozone"
# get the data
histData = pd.read_csv(file, parse_dates=['Date'])
histData['year'] = (histData['Date'].dt.year)
histData['month'] = (histData['Date'].dt.month)
histData['day'] = 1
histData['newDate'] = pd.to_datetime(histData[['year', 'month', 'day']])
#Reorder columns
columns = ['newDate', 'Latitude', 'Longitude', 'AQI', 'Defining_Parameter','county_name']
reorderData = histData[columns]
# Get only the data for the parameter
paramData = reorderData.loc[reorderData['Defining_Parameter'] == param]
sortedhistData = paramData.sort_values(by=['newDate'])
newhistData = sortedhistData.reset_index()
newhistData.drop(columns=['index'], inplace=True)
mapData=newhistData[["newDate", "Latitude", "Longitude", "AQI", 'Defining_Parameter']]
# Create list of lists, with the "key" of the list being the date, and the "value" being all measurements for that date.
# 1. Need list of date
mapTime = []
mapTime = mapData["newDate"].sort_values().unique()
# 2. create the lists
mapData_list = []
# Weight must be between 0 and 1. Divide AQI by max value to get correct data
minAQI = mapData["AQI"].min()
maxAQI = mapData['AQI'].max()
mapData["AQI_adj"] = mapData["AQI"]/maxAQI
for date in mapTime:
mapData_list.append(mapData.loc[mapData['newDate'] == date, ["Latitude", "Longitude", "AQI_adj"]].groupby(["Latitude", "Longitude"]).mean().reset_index().values.tolist())
# create the base map
start_coords = (36.7378, -119.7871)
folium_map = folium.Map(location=start_coords, zoom_start=6, tiles='stamentoner', width='80%', height='80%')
#add the Heat Map from the data
HeatMapWithTime(data=mapData_list, radius=20, auto_play=True, overlay=False, max_opacity=0.5,
gradient = {0.2: '#FBD973',
0.4: '#fa782f',
0.75: '#F16578',
.9: '#782890'}).add_to(folium_map)
title_html = "<h2>Monthly Average Ozone 2010 - 2020</h2>"
folium_map.get_root().html.add_child(folium.Element(title_html))
# display base map with HeatMap
_ = folium_map._repr_html_()
map_id = folium_map._repr_html_()
#map_id = folium_map.get_root().render()
# map_id = Markup(folium_map.get_root().html.render())
hdr_txt = Markup(folium_map.get_root().header.render())
script_txt = Markup(folium_map.get_root().script.render())
folium_map.save("templates/timelapse_static.html")
return(map_id, hdr_txt, script_txt)
def sim_folium_heat(geogridfile, griddatafile):
geogrid = gpd.read_file(geogridfile).sort_index()
geogrid.id = geogrid.id.astype(int)
geogrid['centroid'] = geogrid.to_crs(epsg=3857).geometry.centroid.to_crs(
epsg=4326)
geogrid['cen_lat'] = geogrid['centroid'].y
geogrid['cen_lon'] = geogrid['centroid'].x
#print(geogrid)
with open(griddatafile) as gin:
griddata = json.load(gin)['grid_cnt']
griddata = [{
'timestamp': ts,
'cell_id': int(gid),
'cnt': val,
} for ts, cnt in griddata.items() for gid, val in cnt.items()]
gridcnt = pd.DataFrame.from_dict(griddata)
#gridcnt['norm_cnt'] = (gridcnt.cnt - gridcnt.cnt.min()) / (gridcnt.cnt.max() - gridcnt.cnt.min())
gridcnt['norm_cnt'] = gridcnt.cnt / gridcnt.cnt.max()
#print(gridcnt)
gridcnt = gridcnt.merge(geogrid[['id', 'cen_lat', 'cen_lon']],
left_on='cell_id',
right_on='id')
#print(gridcnt)
time_label = []
data = []
for ts, dfg in gridcnt.groupby('timestamp'):
dt = str(
pd.to_datetime(
ts, unit='s').tz_localize('utc').tz_convert('Europe/Rome'))
time_label.append(dt)
data.append(dfg[['cen_lat', 'cen_lon', 'norm_cnt']].values.tolist())
#print(dt, dfg.cnt.sum())
#print(time_label)
#print(data)
#exit()
m = folium.Map(control_scale=True)
HeatMapWithTime(
data=data,
index=time_label,
radius=60,
#gradient={0.0: 'blue', 0.1: 'lime', 0.3: 'orange', 0.4: 'red'},
gradient={
0.0: 'blue',
0.1: 'orange',
0.5: 'red'
},
min_opacity=0.2,
max_opacity=0.6,
use_local_extrema=False,
display_index=True,
auto_play=True,
).add_to(m)
MeasureControl().add_to(m)
s, w = geogrid[['cen_lat', 'cen_lon']].min()
n, e = geogrid[['cen_lat', 'cen_lon']].max()
m.fit_bounds([[s, w], [n, e]])
m.save(griddatafile + '.html')
#
#Exposure_DATA_move['adt'] = Exposure_DATA_move['adt'] + np.random.rand(len(Exposure_DATA_move)) * 1000
data_move = []
for jj in Exposure_DATA_move['hour'].sort_values().unique():
data_move.append(Exposure_DATA_move[Exposure_DATA_move['hour'] == jj][[
'mid_y', 'mid_x', 'adt'
]].groupby(['mid_y', 'mid_x', 'adt']).sum().reset_index().values.tolist())
print(data_move[0])
def generateBaseMap(default_location=[40.693943, -73.985880],
default_zoom_start=12):
base_map = folium.Map(location=default_location,
control_scale=True,
zoom_start=default_zoom_start)
return base_map
from folium.plugins import HeatMapWithTime
m = generateBaseMap(default_zoom_start=11)
HeatMapWithTime(data_move,
radius=20,
gradient={
0.45: 'blue',
0.4: 'lime',
0.4: 'orange',
1: 'red'
},
use_local_extrema=True).add_to(m)
m.save(file_path)
def initValues():
initLabel = tk.Label(window,
text="Initialized Values : " "\n Location: " + str(weather['name']) + "\n Latitude: " + str(
latController.get()) + "\n Longitude: " +
str(longController.get()) +
"\n Wind Speed: " + str(weather['wind']['speed'] + " mi/hr" + "\n Wind Degrees: " + str(weather['wind']['deg']) + "\n", width=18)
initLabel.grid(row=6, column=0)
def generateBaseMap(default_location=[latController.get(), longController.get()], default_zoom_start=30):
base_map = folium.Map(location=default_location, zoom_start=default_zoom_start)
return base_map
from folium.plugins import HeatMap
def simulateValues():
with open('fireVal.csv', 'w', newline='') as fp:
fieldnames = ['latitude', 'longitude', 'count', 'minute']
a = csv.DictWriter(fp, fieldnames=fieldnames)
a.writeheader()
latt = latController.get()
longg = longController.get()
backLat = latController.get()
backLong = longController.get()
duration = timeController.get() * 60
for i in range(0, duration): # make 4320 minutes
fluct = randint(0, 10)
windSpeed = randint(int(weather['wind']['speed']) - fluct, int(weather['wind']['speed']) + fluct) #needs to be fixed!
slope = rd.uniform(0.0, 1.0)
# variables
Mf = randint(100, 200)
Qig = 250 + (116 * Mf)
E = 0.924 # fluctuating
Pb = 0.55
squig = 0.4824
Ir = 62889.331
s = 1764
Ro = (Ir * squig) / (Pb * E * Qig)
Ow = (0.005235)*(windSpeed*5280/60)**1.43
Os = (17.851) * (slope ** 2)
R = Ro * (1 + Ow + Os)
#backing fire
Rh = Ro*(1 + 1/Ow + Os)
C = 7.47 * (math.exp(-0.133*(s**0.55)))
B = 0.02526*s**0.54
E = 0.715*(math.exp(-3.59*(10**-4)*s))
esum = Ow + Os
Ue = ((esum*(2.35)**E)/C)**(-B)
z = 1 + 0.25*(Ue)
v = ((z**2 - 1)**0.5) / z
Rb = Rh*(1-v / 1+v)
#wind degrees
windDeg = weather['wind']['deg']
fluxValue = randint(28, 95)
#determining wind direction
windFlux = randint(windDeg - fluxValue, windDeg + fluxValue)
if(windFlux>= 0 and windFlux<= 29):
windDir = "N"
elif(windFlux> 29 and windFlux<= 65):
windDir = "NE"
elif(windFlux> 65 and windFlux<= 111):
windDir = "E"
elif (windFlux> 111 and windFlux<= 165):
windDir = "SE"
elif (windFlux> 165 and windFlux<= 204):
windDir = "S"
elif (windFlux> 204 and windFlux<= 245):
windDir = "SW"
elif (windFlux> 245 and windFlux<= 291):
windDir = "W"
elif (windFlux> 291 and windFlux<= 359):
windDir = "NW"
#convert to latitude/longitude using nautical miles calculation
convert = (R / 364567.2)
if(windDir == "N"):
lat = latt + convert
long = longg - convert
lat2 = backLat - (Rb / 364567.2)
long2 = backLong + (Rb / 364567.2)
elif(windDir == "NE"):
lat = latt + convert
long = longg + convert
lat2 = backLat - (Rb / 364567.2)
long2 = backLong - (Rb / 364567.2)
elif(windDir == "E"):
lat = latt
long = longg + convert
lat2 = backLat
long2 = backLong - (Rb / 364567.2)
elif(windDir == "SE"):
lat = latt - convert
long = longg + convert
lat2 = backLat + (Rb / 364567.2)
long2 = backLong - (Rb / 364567.2)
elif(windDir == "S"):
lat = latt - convert
long = longg
lat2 = backLat + (Rb / 364567.2)
long2 = backLong
elif(windDir == "SW"):
lat = latt - convert
long = longg - convert
lat2 = backLat + (Rb / 364567.2)
long2 = backLong + (Rb / 364567.2)
elif(windDir == "W"):
lat = latt
long = longg - convert
lat2 = backLat
long2 = backLong + (Rb / 364567.2)
elif(windDir == "NW"):
lat = latt + convert
long = longg - convert
lat2 = backLat - (Rb / 364567.2)
long2 = backLong + (Rb / 364567.2)
#convert to degrees
a.writerow({'latitude': lat, 'longitude': long, 'count': 1, 'minute': i})
a.writerow({'latitude': lat2, 'longitude': long2, 'count': 1, 'minute': i})
latt = lat
longg = long
backLat = lat2
backLong = long2
df_train = pd.read_csv('fireVal.csv')
df_test = pd.read_csv('fireVal.csv')
df = pd.concat([df_train, df_test], sort=False, ignore_index=True)
map = generateBaseMap(default_location=[latController.get(), longController.get()], default_zoom_start=15)
tooltip = 'click for more info'
folium.Marker([latController.get(), longController.get()], popup='<strong>Fire Initialization Site</strong>',
tooltip=tooltip,
icon=folium.Icon(icon='fire', color='red')).add_to(map)
for index, row in df.iterrows():
firetip = "Time: " + str(row['minute']) + " minutes"
folium.CircleMarker([row['latitude'], row['longitude']],
radius=3,
fill_color="#ff0000", tooltip= firetip, color = "#32d302").add_to(map)
from folium.plugins import HeatMap
df_copy = df.copy()
df_copy['count'] = 1
HeatMap(data=df_copy[['latitude', 'longitude', 'count']].groupby(
['latitude', 'longitude']).sum().reset_index().values.tolist(), radius=30, gradient={0.29: 'blue', 0.63: 'lime', 0.94: 'orange', 1: 'red'}, max_zoom=13).add_to(
map)
df_min_list = []
for minute in df_copy.minute.sort_values().unique():
df_min_list.append(df_copy.loc[df_copy.minute == minute, ['latitude', 'longitude', 'count']].groupby(
['latitude', 'longitude']).sum().reset_index().values.tolist())
from folium.plugins import HeatMapWithTime
HeatMapWithTime(df_min_list, radius=45, gradient={0.2: 'red', 0.4: 'orange', 0.6: 'lime', 1: 'blue'},
min_opacity=0.5, max_opacity=0.8, use_local_extrema=True).add_to(map)
map.save("fireSimu.html")
url = "/Users/shrinandan-n/PycharmProjects/WildfireSimulation/fireSimu.html"
webbrowser.open(url)
# simulate values button
simuBtn = tk.Button(window, text="SIMULATE VALUES", fg="blue", width=15,
command=simulateValues) # , command=recieverValues
simuBtn.grid(row=5, column=1)
initBtn = tk.Button(window, text="INITIALIZE VALUES", fg="red", width=15,
command=initValues) # , command=recieverValues
initBtn.grid(row=5, column=0)
window.mainloop()
time = row['date_start']
iframe = folium.IFrame(table('Deaths', name, deaths, time),
width=width,
height=height)
popups[year].append(iframe)
h = folium.FeatureGroup(name='Deaths')
print(len(locations))
print(len(popups))
#for year in tqdm(conflict_df.date_start.unique()-1989):
#
# mc = MarkerCluster(locations=locations[year], popups=popups[year], overlay=True, control=True)
# mc.add_to(m)
#folium.LayerControl().add_to(m)
h.add_child(FastMarkerCluster(locations))
#m.add_child(h)
m.save(os.path.join('results', "output_map.html"))
m = folium.Map(tiles='cartodbpositron', world_copy_jump=True, no_wrap=True)
event_list = conflict_df[["latitude", "longitude", "best", "date_start"]]
list_of_event = [[row.latitude, row.longitude, row.best]
for row in event_list.itertuples()]
date_list = [row.date_start for row in event_list.itertuples()]
hm = HeatMapWithTime(data=list_of_event[:100],
index=event_list.date_start[:100],
max_opacity=0.3)
hm.add_to(m)
m.save(os.path.join('results', "output_map_heat.html"))
[-37.8190, 144.9682,
float(Princes_Bridge[i]) / 3000], #
[
-37.8181, 144.9670,
float(Flinders_St_Station_Underpass[i]) / 3000
],
[-37.8202, 144.9629,
float(Sandridge_Bridge[i]) / 3000]
]
Data.append(data)
except (ValueError):
print(Time[i])
i = i + 1
HeatMapWithTime(Data,
name="墨尔本人行道人流情况",
auto_play=True,
radius=40,
index=Time,
min_speed=1,
max_speed=24).add_to(m)
m.add_child(folium.LatLngPopup())
i = 0
print(len(data))
print(len(AD))
while (i + 7) < len(AD) / 9:
folium.Marker([data[i][0], data[i][1]], popup=AD[i + 7]).add_to(m)
i = i + 1
m.save("墨尔本人行道人流情况.html")
foliumacc.rr("墨尔本人行道人流情况.html")
webbrowser.open("墨尔本人行道人流情况.html")
