def make_map(features):
#print('> Making map...')
m = f.Map()
a = {}
z = 0.3 * len(d)
y = int(z)
for i in range(0, y):
z1 = d.iloc[i]['latitude']
z2 = d.iloc[i]['longitude']
try:
loc.append((float(z1), float(z2)))
#a={i:{d.iloc[i]['tweetCreated']:{loc}}}
except:
pass
plugins.MarkerCluster(loc).add_to(m)
TimestampedGeoJson({
'type': 'FeatureCollection',
'features': features
},
period='P1M',
add_last_point=True,
auto_play=False,
loop=False,
max_speed=1,
loop_button=True,
date_options='YYYY/MM',
time_slider_drag_update=True).add_to(m)
#print('> Done.')
return pollution_map
def make_map(features):
""" Returns a HTML file with time interactive scatter plot
"""
print("Plotting the map...")
pollution_map = folium.Map(
width=width,
height=height,
location=location,
zoom_start=zoom_start,
control_scale=True,
tiles=tiles,
min_lat=min_lat,
max_lat=max_lat,
min_lon=min_lon,
max_lon=max_lon,
)
colormap.add_to(pollution_map)
TimestampedGeoJson(
{"type": "FeatureCollection", "features": features},
period=period,
add_last_point=True,
auto_play=False,
loop=False,
max_speed=1,
loop_button=True,
date_options=date_options,
time_slider_drag_update=True,
).add_to(pollution_map)
print("Saved the map.")
return pollution_map
def createPredictiveMap(self, features, areaId, cmap, outputPath,
period_str):
if period_str == 40000:
period_set = 'PT4H'
elif period_str == 6000:
period_set = 'PT1H'
elif period_str == 3000:
period_set = 'PT30M'
htmlFile = outputPath + 'map_congested_' + str(areaId) + '.html'
m = self.createBaseMap(areaId)
TimestampedGeoJson({
'type': 'FeatureCollection',
'features': features
},
transition_time=1000,
period=period_set,
add_last_point=True,
auto_play=True,
loop=True,
max_speed=1,
loop_button=True,
date_options='YYYY-MM-DD HH:mm:ss',
time_slider_drag_update=False).add_to(m)
m.add_child(cmap)
m.save(htmlFile)
self.beautifyDisplay(htmlFile)
def make_map(features, center_name, coverage):
print('> Making map...')
init_location = [customer.loc[0, 'latitude'], customer.loc[0, 'longitude']]
time_map = folium.Map(location=init_location, control_scale=True, zoom_start=11)
center[center.name == center_name].apply(lambda row: folium.Marker(location=[row['latitude'], row['longitude']],
icon=Icon(color='black', icon='fa-wrench',
prefix='fa')).add_to(time_map), axis=1)
time_map.choropleth(
geo_data=coverage,
fill_color='yellow',
fill_opacity=0.1
)
TimestampedGeoJson(
data={'type': 'Feature',
'features': features},
period='P1D',
duration='P1D',
auto_play=False,
loop=False,
max_speed=10,
loop_button=True,
date_options='YYYY/MM/DD',
time_slider_drag_update=True).add_to(time_map)
print('> Done.')
return time_map
def get_data():
data = pre.read_data()
variables = data['Variable'].unique().tolist()[:5] # Probando solo con 5
maps_data = {}
for var in variables:
print(var)
df_variable = pre.df_variable(data, var)
# add color column
df_variable['color'] = [
RdYlBu[11][val] for val in pd.cut(
x=df_variable['Concentración'], bins=11, labels=False)
]
geo_features = create_geojson_features(df_variable.reset_index())
maps_data[var] = TimestampedGeoJson(
{
'type': 'FeatureCollection',
'features': geo_features
},
period='P1D',
add_last_point=True,
auto_play=False,
loop=False,
max_speed=10,
loop_button=True,
date_options='YYYY/MM',
duration='P1D',
time_slider_drag_update=True)
return maps_data, variables
def plotPointMap(values, date_range):
base_map = folium.Map(location=[-31.420082, -64.188774])
TimestampedGeoJson(getGeojsonFeatures(values, date_range),
date_options='YYYY/MM/DD',
auto_play=True).add_to(base_map)
filename = tempfile.NamedTemporaryFile(prefix='pointmap_').name + '.html'
base_map.save(filename)
webbrowser.open(filename)
def value_map(pollutant):
"""
Returns a map with mesures values and their location for each instant
Args:
pollutant (string): name of the pollutant to display
Returns:
Map: folium map with time mesures
"""
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)
encoder = JSONEncoder(global_max)
features = []
for time in ordered_mesures:
features += [
encoder.encode_as_geoJSON(mesure)
for mesure in ordered_mesures[time]
]
tsjson = TimestampedGeoJson(
{
'type': 'FeatureCollection',
'features': features
},
period='PT1H',
add_last_point=True,
auto_play=False,
loop=False,
max_speed=1,
loop_button=True,
time_slider_drag_update=True)
tsjson.options["position"] = "topright"
tsjson.add_to(folium_map)
encoder.cm.caption = f"{pollutant} concentration in ug.m-3"
folium_map.add_children(encoder.cm)
return folium_map
def make_map(features):
coords = [44.981041, -93.232149]
this_map = folium.Map(location=coords, control_scale=True, zoom_start=10)
folium.TileLayer('cartodbpositron').add_to(this_map)
temp = TimestampedGeoJson(
{
'type': 'FeatureCollection',
'features': features
},
period='P1D',
add_last_point=True,
auto_play=True,
loop=True,
max_speed=.7,
loop_button=True,
date_options='YYYY/MM',
time_slider_drag_update=True)
temp.add_to(this_map)
return this_map
def add_traffic_timestamped_map(self, gjson_timestamped):
TimestampedGeoJson(
{
'type': 'FeatureCollection',
'features': gjson_timestamped
},
period='PT1H',
add_last_point=True,
auto_play=False,
loop=False,
max_speed=1,
loop_button=True,
date_options='YYYY/MM/DD HH',
time_slider_drag_update=True).add_to(self._map)
def visualize_traj(traj,
fmap=None,
animation=True,
color='blue',
weight=3,
icon='circle',
transition_time=100,
period='PT2M',
duration=None):
if fmap is None:
fmap = create_map()
if animation:
TimestampedGeoJson(
{
'type':
'FeatureCollection',
'features': [{
'type': 'Feature',
'geometry': {
'type':
'LineString',
'coordinates':
list(map(lambda x: [x[1], x[0]], traj['coordinates']))
},
'properties': {
'times': traj['times'],
'style': {
'color': color,
'weight': weight
},
'icon': icon
}
}]
},
transition_time=transition_time,
period=period,
duration=duration).add_to(fmap)
else:
fl.PolyLine(traj['coordinates'], color=color,
weight=weight).add_to(fmap)
fl.Circle(traj['coordinates'][-1],
color=color,
weight=weight,
radius=600).add_to(fmap)
return fmap
def __make_map(features, initial_coords):
coords = initial_coords #[52.24, 21.02]
map_ = folium.Map(location=coords, control_scale=True, zoom_start=8)
TimestampedGeoJson({
'type': 'FeatureCollection',
'features': features
},
period='PT15M',
duration='PT1M',
add_last_point=True,
auto_play=False,
loop=False,
loop_button=True,
time_slider_drag_update=True).add_to(map_)
return map_
def setup_business_time_series_map(business_data):
features = business_time_series_map_features_util(business_data)
business_time_series_map = folium.Map(location=seattle_coords,
min_zoom=13,
max_bounds=True)
business_time_series_map.add_child(
TimestampedGeoJson({
'type': 'FeatureCollection',
'features': features
},
period='P1D',
add_last_point=True,
auto_play=False,
loop=False,
loop_button=True,
date_options='MM/DD/YYYY',
duration="P1D"))
business_time_series_map.save("business_time_series_map.html")
def make_map(features):
print('> Making map...')
coords_belgium=[50.5039, 4.4699]
pollution_map = folium.Map(location=coords_belgium, control_scale=True, zoom_start=8)
TimestampedGeoJson(
{'type': 'FeatureCollection',
'features': features}
, period='P1M'
, add_last_point=True
, auto_play=False
, loop=False
, max_speed=1
, loop_button=True
, date_options='YYYY/MM'
, time_slider_drag_update=True
).add_to(pollution_map)
print('> Done.')
return pollution_map
def make_map2(features):
print('> Making map...')
coords=[37.0902,-95.7129]
m = f.Map(location=coords, tiles='cartodbpositron', control_scale=True, zoom_start=3)
TimestampedGeoJson(
{'type': 'FeatureCollection',
'features': features}
, period='P1D'
, add_last_point=True
, auto_play=False
, loop=False
, max_speed=2
, loop_button=True
, date_options='MM/DD'
, time_slider_drag_update=True
, duration='P0D' #prevents new data from layering on top of old
).add_to(m)
print("Done!")
return m
def make_map(df):
print('> Making map...')
bay_area_cord = [37.739417, -122.254747]
pollution_map = folium.Map(location = bay_area_cord, control_scale=True, zoom_start=10, tiles = 'Stamen Terrain')
for x,y,labels in zip(coords['Lat_DD'], coords['Long_DD'], coords['Station label']):
pollution_map.add_child(folium.CircleMarker([x,y], color = '#99b3cc', radius = 15, tooltip = labels))
features = create_geojson_features(df)
TimestampedGeoJson(
{'type': 'FeatureCollection',
'features': features}
, period='P1M'
, add_last_point=True
, auto_play=False
, loop=True
, max_speed=10
, loop_button=True
, date_options='YYYY/MM'
, time_slider_drag_update=True
).add_to(pollution_map)
print('> Done.')
return pollution_map
def make_map(features, legend_range):
m = folium.Map(location=[20, 0],
height='100%',
width='100%',
control_scale=True,
zoom_start=1.8)
TimestampedGeoJson({
'type': 'FeatureCollection',
'features': features
},
period='P1D',
add_last_point=True,
auto_play=False,
loop=False,
duration='P1D',
max_speed=10,
loop_button=True,
date_options='YYYY/MM/DD',
time_slider_drag_update=True).add_to(m)
color_range = np.round(
np.linspace(legend_range[0], legend_range[1], 10) / 1000).astype(int)
colormap = branca.colormap.LinearColormap(color_palette(),
index=color_range,
vmin=min(color_range),
vmax=max(color_range),
caption='Deaths (thousands)')
colormap.add_to(m)
caption = """<table>
<tr>
<td>Data sources: <a href="https://systems.jhu.edu/research/public-health/ncov/">John Hopkins University</a> & <a href="https://github.com/CSSEGISandData/COVID-19">GitHub</a></td>
</tr>
</table>"""
m.get_root().html.add_child(folium.Element(caption))
return m
def device_metric_map(self, channel, start_date, end_date, options=dict()):
'''
Creates a folium map showing the evolution of a metric dynamically with colors
Parameters
-------
channel: String
The channel to make the map from
start_date, end_date: String
Date convertible string
options: dict()
Possible keys are (default otherwise)
location: list
[41.400818, 2.1825157]
Center map location
tiles: (String)
'Stamen Toner'
Tiles for the folium.Map
zoom: (float)
2.5
Zoom to start with in folium.Map
period: 'String'
'1W'
Period for 'dynamic' map
radius: float
10
Circle radius for icon
fillOpacity: float
1
(<1) Fill opacity for the icon
stroke: 'String'
'false'
'true' or 'false'. For icon's stroke
icon: 'String'
'circle'
A valid folium.Map icon style
Returns
-------
Folium.Map object
'''
# Set defaults
options = dict_fmerge(config._map_def_opt, options)
# Make date range
date_r = date_range(start=start_date,
end=end_date,
normalize=True,
freq=options['period']).strftime('%Y-%m-%d')
date_l = list()
for item in date_r.values:
date_l.append(str(item))
# Get bins
for bname in config._channel_bins.keys():
if bname in channel:
bins = config._channel_bins[bname]
break
# Make features
features = []
for device in self.devices:
# Get lat, long
try:
self.devices[str(device)].api_device.get_device_lat_long()
_lat = self.devices[str(device)].api_device.lat
_long = self.devices[str(device)].api_device.long
except AttributeError:
std_out(f'Cannot retrieve [lat, long] from device {device}',
'WARNING')
pass
continue
if _lat is None or _long is None: continue
# Resample
try:
dfc = self.devices[str(device)].readings.resample(
options['period']).mean()
except:
pass
continue
if channel not in dfc.columns: continue
# Make color column
dfc['color'] = cut(dfc[channel],
bins,
labels=config._map_colors_palette)
# Add point for each date
for date in date_l:
if date not in dfc.index: continue
if date_l.index(date) > len(date_l) - 2: continue
features.append({
'type': 'Feature',
'geometry': {
'type': 'LineString',
'coordinates': [[str(_long), str(_lat)]] * 2,
'popup': str(device),
},
'properties': {
'times': [date, date_l[date_l.index(date) + 1]],
'icon': options['icon'],
'iconstyle': {
'fillColor': str(dfc.loc[date, 'color']),
'fillOpacity': options['fillOpacity'],
'stroke': options['stroke'],
'radius': options['radius']
},
'style': {
'weight': '0'
},
'id': 'man'
}
})
# Make map
m = Map(
location=options['location'],
tiles=options['tiles'],
zoom_start=options['zoom'],
)
TimestampedGeoJson(
{
'type': 'FeatureCollection',
'features': features
},
period='P' + convert_rollup(options['period']),
add_last_point=True,
auto_play=False,
loop=False,
max_speed=5,
loop_button=True,
# date_options='YYYY/MM/DD',
time_slider_drag_update=True,
duration='P' + options['period']).add_to(m)
return m
'style': {
'color': row['Color']
}
}
}
features.append(feature)
if row["id"] in ["DNK", "FRA", "ITA", "GBR", "GRC"]:
for geometry in compl.get(row["id"]).get("geometries"):
feature_new = dict(feature)
feature_new["geometry"] = geometry
features.append(feature_new)
new_map = folium.Map([50.736455, 17.666], zoom_start=4.5)
TimestampedGeoJson({
'type': 'FeatureCollection',
'features': features
},
period='P1M',
duration='P1M',
add_last_point=True,
auto_play=False,
loop=False,
max_speed=1,
loop_button=True,
date_options='YYYY/MM',
time_slider_drag_update=True).add_to(new_map)
colormap = LinearColormap(color_scale, vmin=0, vmax=bin_edges[-1])
colormap.caption = "Monthly average " + pollutant + " (in µg/m3)"
colormap.add_to(new_map)
new_map.save("../maps/avg_" + pollutant + ".html")
def layer_gen(self, group, group_id, show):
""" Generates a bubbles layer """
# Get the color of the bubble according to layer definitions
color = 'blue'
chart_options = self.options.get('chart_options', {})
for ind_index in range(len(chart_options.get('indicadores', []))):
if chart_options.get('indicadores')[ind_index] == group_id:
color = chart_options.get('colorArray')[ind_index]
break
# Adding circle radius to group, if it's not present in dataframe group
if 'radius' not in group.columns:
group['radius'] = self.assess_radius(group)
if 'timeseries' not in chart_options:
# Creating a layer for the group
layer = FeatureGroup(
name=ViewConfReader.get_layers_names(self.options.get('headers')).get(group_id),
show=show
)
# Check if popup data is present
has_tooltip = 'tooltip' in group.columns
# Generating circles
for _row_index, row in group.iterrows():
tooltip_data = None
if has_tooltip:
tooltip_data = row['tooltip']
CircleMarker(
location=[
row[chart_options.get('lat', 'latitude')],
row[chart_options.get('long', 'longitude')]
],
radius=row['radius'],
popup=tooltip_data,
color=color,
fill=True,
fill_color=color
).add_to(layer)
# Adding layer to map
return layer
else:
features = []
for _row_index, row in group.iterrows():
features.append({
'type': 'Feature',
'geometry': {
'type': 'Point',
'coordinates': [
row[chart_options.get('long', 'longitude')],
row[chart_options.get('lat', 'latitude')]
]
},
'properties': {
'time': pd.to_datetime(
row[chart_options.get('timeseries', 'nu_competencia')],
format='%Y'
).__str__(),
'style': {'color': color},
'icon': 'circle',
'iconstyle': {
'fillColor': color,
'fillOpacity': 0.8,
'stroke': 'true',
'radius': row['radius']
}
}
})
return TimestampedGeoJson(
features,
period='P1Y',
duration='P1Y',
date_options='YYYY',
transition_time=1000,
auto_play=True
)
def device_history_map(map_type='dynamic', dataframe=None, options=dict()):
'''
Creates a folium map with either location of devices or their "existence period"
-------
Parameters:
map_type: String
'dynamic'
'dynamic' or 'static'. Whether is a dinamic map or not
dataframe: Pandas Dataframe
None
Contains information about when the devices started posting data, ids, location.
It follows the format of world_map in api device
options: dict
dict()
Returns:
Folium.Map object
'''
def coordinates(x):
return [x['latitude'], x['longitude']]
def color(x):
iSCAPE_IDs = [19, 20, 21, 28]
making_sense_IDs = [11, 14]
SCK_21_IDs = [26]
color = '#0019ff'
try:
if x['kit_id'] in iSCAPE_IDs: color = '#7dbd4c'
elif x['kit_id'] in making_sense_IDs: color = '#f88027'
elif x['kit_id'] in SCK_21_IDs: color = '#ffb500'
except:
print_exc()
pass
return color
def validate(x):
if x['last_reading_at'] is None: return False
if x['added_at'] is None: return False
if any(x['coordinates']) is None or any(
[isnan(item) for item in x['coordinates']]):
return False
if map_type == 'dynamic':
if x['date_list'] == []: return False
return True
def range_list(x):
date_r = date_range(start=x['added_at'],
end=x['last_reading_at'],
normalize=True,
freq=options['period']).strftime('%Y-%m-%d')
date_l = list()
for item in date_r.values:
date_l.append(str(item))
return date_l
dataframe['color'] = dataframe.apply(lambda x: color(x), axis=1)
dataframe['coordinates'] = dataframe.apply(lambda x: coordinates(x),
axis=1)
options = dict_fmerge(config._map_def_opt, options)
# Make map
m = Map(
location=options['location'],
tiles=options['tiles'],
zoom_start=options['zoom'],
)
if map_type == 'dynamic':
dataframe['date_list'] = dataframe.apply(lambda x: range_list(x),
axis=1)
dataframe['valid'] = dataframe.apply(lambda x: validate(x), axis=1)
dataframe = dataframe[(dataframe['valid'] == True)]
features = list()
for sensor in dataframe.index:
features.append({
'type': 'Feature',
'geometry': {
'type':
'LineString',
'coordinates':
[dataframe.loc[sensor, 'coordinates'][::-1]] *
len(dataframe.loc[sensor, 'date_list']),
'popup':
f'<a href="http://smartcitizen.me/kits/{sensor}">{sensor}</a>',
},
'properties': {
'times': dataframe.loc[sensor, 'date_list'],
'icon': options['icon'],
'iconstyle': {
'fillOpacity': options['fillOpacity'],
'fillColor': dataframe.loc[sensor, 'color'],
'stroke': options['stroke'],
'radius': options['radius']
},
'style': {
'weight': '0'
},
'id': 'man'
}
})
TimestampedGeoJson(
{
'type': 'FeatureCollection',
'features': features
},
period='P' + convert_rollup(options['period']),
add_last_point=True,
auto_play=False,
loop=False,
max_speed=options['max_speed'],
loop_button=True,
# date_options='YYYY/MM/DD',
time_slider_drag_update=True,
duration='P' + options['period']).add_to(m)
elif map_type == 'static':
dataframe['valid'] = dataframe.apply(lambda x: validate(x), axis=1)
dataframe = dataframe[(dataframe['valid'] == True)]
for sensor in dataframe.index:
Circle(
location=dataframe.loc[sensor, 'coordinates'],
radius=options['radius'],
color=dataframe.loc[sensor, 'color'],
fill=True,
fillOpacity=options['fillOpacity'],
fillColor=dataframe.loc[sensor, 'color'],
popup=
f'<a href="http://smartcitizen.me/kits/{sensor}">{sensor}</a>'
).add_to(m)
return m
51, 50, 31, 32, 4, 38, 30, 26, 13, 49, 40, 6, 29, 20, 10, 41, 3, 58, 7
]
routes_gj = get_routes_geojson(bus_ids)
grid_gj = get_grid_geojson(bus_ids, ('weekday', '00:00', '23:59'),
stations_source='here')
m = folium.Map(location=[55.6795535, 12.542231],
zoom_start=13,
tiles='OpenStreetMap')
routes = folium.GeoJson(routes_gj,
name='routes',
style_function=lambda feature: {'color': 'blue'})
grid = TimestampedGeoJson(grid_gj,
period='PT1H',
duration='PT1M',
date_options='HH:mm',
auto_play=False,
max_speed=1,
loop=False,
time_slider_drag_update=True,
loop_button=True)
routes.add_to(m)
grid.add_to(m)
folium.features.GeoJsonTooltip(fields=['bus_id', 'name'],
aliases=['id', 'bus']).add_to(routes)
folium.LayerControl().add_to(m)
print(m)
lon = lon_init + (i+1) * 0.01 * random()
coordinates.append([lon, lat])
time.append(time_stamp + i * 60000)
print(coordinates)
print(time)
poly_line = TimestampedGeoJson(data={
"type": "FeatureCollection",
"features": [
{
"type": "Feature",
"geometry": {
"type": "LineString",
"coordinates": coordinates,
},
"properties": {
"times": time,
"style": {
"color": "red",
"weight": 2
}
}
}
]
}, period="PT1M")
poly_line.add_to(map)
# Create a tool to measure distance and area
tool_measure = MeasureControl()
tool_measure.add_to(map)
start.loc[start['count']<1, 'fillColor'] = '#e37222'
def create_geojson_features(df):
features = []
for _, row in df.iterrows():
feature = { 'type': 'Feature', 'geometry': { 'type':'Point', 'coordinates':[row['lon'],row['lat']]},
'properties': {'time': pd.to_datetime(row['hour'], unit='h').__str__(), 'style': {'color' : ' '}, 'icon': 'circle',
'iconstyle':{ 'color': row['fillColor'], 'fillColor': row['fillColor'], 'fillOpacity': 0.8, 'stroke': 'true',
'fill':'true', 'radius': row['count'] + 1 }}}
features.append(feature)
return features
start_geojson = create_geojson_features(start)
nyc_map = folium.Map(location = [40.744916, -73.989830], tiles = "CartoDB dark_matter", zoom_start = 12.5)
TimestampedGeoJson(start_geojson, period = 'PT1H', duration = 'PT1M', transition_time = 800, auto_play = True).add_to(nyc_map)
nyc_map.save('LiveMap.html')
nyc1= nyc.reset_index().set_index('stoptime')
end = nyc1.pivot_table('tripduration', index = ['end station id', 'end station latitude', 'end station longitude', nyc1.index.hour],
columns = 'type', aggfunc='count').reset_index()
end['station'] = end['station']/days
end.columns = ['station_id', 'lat', 'lon', 'hour', 'count']
end['fillColor'] = '#e64c4e'
end.loc[end['count']<1, 'fillColor'] = '#586065'
end_geojson = create_geojson_features(end)
df_hour_list = []
hours = pd.Series(nyc.index.hour.unique().sort_values())
def create_list(hour):
'type': "MultiPoint",
'coordinates': [all_truths[id]['lonlats'][time]]
}
})
# %%
# The Results
# ~~~~~~~~~~~
from folium.plugins import TimestampedGeoJson, Fullscreen
Fullscreen().add_to(m)
TimestampedGeoJson(data=geo_json,
transition_time=200,
auto_play=True,
add_last_point=False,
period='PT10S',
duration='PT0S').add_to(m)
# %%
# sphinx_gallery_thumbnail_path = '_static/sphinx_gallery/OpenSky_thumb.png'
m
# %%
# References
# ----------
# .. [#] The OpenSky Network, http://www.opensky-network.org
# .. [#] Bringing up OpenSky: A large-scale ADS-B sensor network for research
# Matthias Schäfer, Martin Strohmeier, Vincent Lenders, Ivan Martinovic, Matthias Wilhelm
def GenStaticTimemap(Datadic,val,ave,titlename,infos):
"""
Generate a static time series make for Date in a Datadirectory, the location come from the Datadic keys
needed functions Staticsitedatetime, colormap
Features:basics popups
Created:08/06/2019
#updated for RPI3 use
"""
for k , info in infos.items():
locs=infos[k]['Location:']
Lat=float(locs[2])
Lon=float(locs[3])
print(Lat,Lon)
#generate base map
m=folium.Map([Lat,Lon],
zoom_start=10,
tiles='OpenStreetMap')
#add colar bard
if "pm" in val:
index=[0,5,10,15,20,25,30,40,50]
colormap(m,index,"Mass concentration ug/m^3")
styledict=[] #Stlyed dict for the time stamped features to be added to map
#loop through data dic, getting the location and putting the data as geojseon data under style
for k, item in Datadic.items():
# print(item.head(4),loc)
if val.upper()=="PM2.5" or val.upper()=="PM10" and "SDS" in k.upper():
val="sds-"+val
item[val]=item[val].dropna()
style,df=Staticsitedatetime(item,infos[k],val,m) #Add the time stamed geoJson
styledict=styledict+style
#Read the styledict, puting the time onto the map
if ave.upper()=="RAW":
interval="1T"
else:
i=ave.find("T")
interval=ave[0:i]
# print(interval)
TimestampedGeoJson(
{
'type': 'FeatureCollection',
'features': styledict,
},
period='PT'+interval+'M'
, add_last_point=True
, auto_play=False
, loop=False
, max_speed=10
, loop_button=True
, time_slider_drag_update=True).add_to(m)
#save map
m.save(titlename+".html")
print("完成")
def generate_location_map(reportfolderbase, legend_title):
KML_path = os.path.join(reportfolderbase, iLEAPP_KMLs)
if not os.path.isdir(KML_path) or not os.listdir(KML_path):
return
location_path = os.path.join(reportfolderbase, 'LOCATIONS')
os.makedirs(location_path, exist_ok=True)
db = sqlite3.connect(os.path.join(KML_path, "_latlong.db"))
df = pd.read_sql_query(
"SELECT key as Name, Activity as Description, latitude, longitude FROM data ;",
db)
df["Point"] = df.apply(
lambda row: Point(float(row['longitude']), float(row['latitude']), .0),
axis=1)
#sorting is needed for correct display
df.sort_values(by=['Name'], inplace=True)
#Parse geo data and add to Folium Map
data_names = df[~df.Description.str.contains('Photos')].Description.unique(
)
featuresProp = {}
for c, d in zip(colors, data_names):
descFilter = d
if 'ZRT' in d:
fType = 'LineString'
icon = 'marker'
iconUrl = defaultIconUrl.format(c)
shadowUrl = defaultShadowUrl
else:
fType = 'MultiPoint'
icon = 'circle'
iconUrl = ''
shadowUrl = ''
color = c
featuresProp[d] = {
'fType': fType,
'color': c,
'icon': icon,
'iconUrl': iconUrl,
'shadowUrl': defaultShadowUrl,
}
location_map = folium.Map([df.iloc[0].Point.y, df.iloc[0].Point.x],
prefer_canvas=True,
zoom_start=6)
bounds = (
df[~df.Description.str.contains('Photos')]['longitude'].min(),
df[~df.Description.str.contains('Photos')]['latitude'].min(),
df[~df.Description.str.contains('Photos')]['longitude'].max(),
df[~df.Description.str.contains('Photos')]['latitude'].max(),
)
location_map.fit_bounds([
(bounds[1], bounds[0]),
(bounds[3], bounds[2]),
])
tsGeo = TimestampedGeoJson(
{
'type': 'FeatureCollection',
'features':
[geodfToFeatures(df, f, featuresProp) for f in data_names]
},
period="PT1M",
duration="PT1H",
loop=False,
transition_time=50,
time_slider_drag_update=True,
add_last_point=True,
max_speed=200).add_to(location_map)
#legend
legend = '\n'.join([
legend_tag.format(featuresProp[f]['color'], htmlencode(f))
for f in data_names
])
template = '\n'.join([
template_part1,
legend_title_tag.format(htmlencode(legend_title)),
legend_div.format(legend), template_part2
])
macro = MacroElement()
macro._template = Template(template)
location_map.get_root().add_child(macro)
location_map.save(os.path.join(location_path, "Locations_Map.html"))
report = ArtifactHtmlReport('Locations Map')
report.start_artifact_report(location_path, 'Locations Map',
'Map plotting all locations')
report.write_raw_html(
open(os.path.join(location_path, "Locations_Map.html")).read())
report.end_artifact_report()
def GenStaticTimemap(Datadic, val, ave, titlename, infos):
"""
Generate a static time series make for Date in a Datadirectory, the location come from the Datadic keys
needed functions Staticsitedatetime, colormap
Features:basics popups
Created:08/06/2019
#updated for RPI3 use
"""
print("Datadic")
print(Datadic)
print("")
#Set initital Lat / Lon to center map
for k, data in Datadic.items():
print("k")
print(k)
Lat = data["lat"].iloc[0]
Lon = data["lon"].iloc[0]
print("Lat = ", Lat)
print("Lon = ", Lon)
#generate base map
m = folium.Map([Lat, Lon], zoom_start=15, tiles='OpenStreetMap')
#add colar bard
if "pm" in val:
#index=[0,5,10,15,20,25,30,40,50]
#index=[0,0.5,1,1.5,2,2.5,3,3.5,4]
#colorbar_index=[0,1,2,3,4,5,6,7,8]
colormap(m, colorbar_values, "Mass concentration ug/m^3")
styledict = [
] #Stlyed dict for the time stamped features to be added to map
#loop through data dic, getting the location and putting the data as geojseon data under style
for k, item in Datadic.items():
print("k = ", k)
print("item = ", item)
print("*****")
print("*****")
print("*****")
print("*****")
# print(item.head(4),loc)
if val.upper(
) == "PM2.5" or val.upper() == "PM10" and "SDS" in k.upper():
val = "sds-" + val
print("val = ", val)
item = item.dropna()
style, df = Staticsitedatetime(item, infos[k], val,
m) #Add the time stamed geoJson
styledict = styledict + style
#Read the styledict, puting the time onto the map
if ave.upper() == "RAW":
interval = "1T"
else:
i = ave.find("T")
interval = ave[0:i]
print(interval)
print("interval = ", interval)
print("*******")
interval = "1"
TimestampedGeoJson({
'type': 'FeatureCollection',
'features': styledict,
},
period='PT' + interval + 'M',
add_last_point=True,
auto_play=False,
loop=False,
max_speed=10,
loop_button=True,
time_slider_drag_update=True).add_to(m)
m.save(titlename + ".html")
features = [
{
'type': 'Feature',
'geometry': {
'type': 'LineString',
'coordinates': [each[1]['longitude'], each[1]['latitude']],
},
'properties': {
'times': each[1]['acq_time'],
'style': {
# 'color': line['color'],
# 'weight': line['weight'] if 'weight' in line else 5
}
}
} for each in wildfireFile[0:searchLimit].iterrows()
]
TimestampedGeoJson({
'type': 'FeatureCollection',
'features': features,
},
period='PT1M',
add_last_point=True).add_to(m)
# WEB BROWSER PART ------
# m.add_child(markerCluster)
MousePosition().add_to(m)
m.save('index.html')
url = 'index.html'
webbrowser.open(url, new=1) # open in new tab
def path_plot(self,
channel=None,
map_type='dynamic',
devices='all',
start_date=None,
end_date=None,
options=dict()):
'''
Creates a folium map showing a path
Parameters
-------
channel: String
None
If None, shows path, otherwise, colored path with channel mapping
map_type: String
'dynamic'
'dynamic' or 'static'. Whether is a dinamic map or not
devices: list or 'all'
List of devices to include, or 'all' from self.devices
channel: String
The channel to make the map from
start_date, end_date: String
Date convertible string
options: dict()
Possible keys are (default otherwise)
location: list
[41.400818, 2.1825157]
Center map location
tiles: (String)
'Stamen Toner'
Tiles for the folium.Map
zoom: (float)
2.5
Zoom to start with in folium.Map
period: 'String'
'1W'
Period for 'dynamic' map
radius: float
10
Circle radius for icon
fillOpacity: float
1
(<1) Fill opacity for the icon
stroke: 'String'
'false'
'true' or 'false'. For icon's stroke
icon: 'String'
'circle'
A valid folium.Map icon style
Returns
-------
Folium.Map object
'''
# Set defaults
options = dict_fmerge(config._map_def_opt, options)
# Make features
features = []
if devices == 'all':
mdev = self.devices
else:
mdev = list()
for device in devices:
if device in self.devices: mdev.append(device)
else: std_out(f'Device {device} not found, ignoring', 'WARNING')
if len(mdev) == 0:
std_out('Requested devices not in test', 'ERROR')
return None
for device in mdev:
chs = ['GPS_LAT', 'GPS_LONG']
if channel is not None:
if channel not in self.devices[str(device)].readings.columns:
std_out(
f'Channel {channel} not in columns: {self.devices[str(device)].readings.columns}',
'ERROR')
return None
# Get bins
minmax = False
if not options['minmax']:
if all([key not in channel for key in config._channel_bins]):
std_out(
f'Requested channel {channel} not in config mapped bins {config._channel_bins.keys()}.Using min/max mapping',
'WARNING')
minmax = True
else:
minmax = True
if minmax:
bins = linspace(
self.devices[str(device)].readings[channel].min(),
self.devices[str(device)].readings[channel].max(),
config._channel_bin_n)
else:
for bname in config._channel_bins.keys():
if bname in channel:
bins = config._channel_bins[bname]
break
chs.append(channel)
# Create copy
dfc = self.devices[str(device)].readings[chs].copy()
# Resample and cleanup
# TODO THIS CAN INPUT SOME MADE UP READINGS
dfc = clean(dfc.resample(options['period']).mean(), 'fill')
# Make color column
legend_labels = None
if channel is not None:
dfc['COLOR'] = cut(dfc[channel], bins, labels =\
config._map_colors_palette)
# Make legend labels
legend_labels = {}
for ibin in range(len(bins) - 1):
legend_labels[f'{round(bins[ibin],2)} : {round(bins[ibin+1],2)}'] =\
config._map_colors_palette[ibin]
else:
dfc['COLOR'] = config._map_colors_palette[0]
if start_date is not None:
dfc = dfc[dfc.index > start_date]
if end_date is not None:
dfc = dfc[dfc.index < end_date]
# Add point for each date
for date in dfc.index:
if date == dfc.index[-1]: break
times = []
color = str(dfc.loc[date, 'COLOR'])
if color == 'nan' or isnan(dfc.loc[date, 'GPS_LONG'])\
or isnan(dfc.loc[date, 'GPS_LAT']):
std_out(f'Skipping point {date}', 'WARNING')
continue
geometry = {
'type':
'LineString',
'coordinates':
[[dfc.loc[date, 'GPS_LONG'], dfc.loc[date, 'GPS_LAT']],
[
dfc.loc[date + dfc.index.freq, 'GPS_LONG'],
dfc.loc[date + dfc.index.freq, 'GPS_LAT']
]],
}
properties = {
'icon':
options['icon'],
'iconstyle': {
'fillColor': color,
'fillOpacity': options['fillOpacity'],
'stroke': options['stroke'],
'radius': options['radius']
},
'device':
device,
'timestamp':
date.strftime('%Y-%m-%dT%H:%M:%S'),
"coordinates": [
dfc.loc[date + dfc.index.freq, 'GPS_LAT'],
dfc.loc[date + dfc.index.freq, 'GPS_LONG']
],
'style': {
'color': color,
'stroke-width': options['stroke-width'],
'fillOpacity': options['fillOpacity']
}
}
# Add reading to tooltip
if channel is not None:
properties['channel'] = channel
properties['value'] = dfc.loc[date, channel]
if map_type == 'dynamic':
properties['times'] = [
date.strftime('%Y-%m-%dT%H:%M:%S'),
(date + dfc.index.freq).strftime('%Y-%m-%dT%H:%M:%S')
]
features.append({
'type': 'Feature',
'geometry': geometry,
'properties': properties
})
featurecol = {'type': 'FeatureCollection', 'features': features}
# Make map
if options['location'] == 'average':
avg_long = dfc['GPS_LONG'].mean()
avg_lat = dfc['GPS_LAT'].mean()
loc = [avg_lat, avg_long]
else:
loc = options['location']
m = Map(
location=loc,
tiles=options['tiles'],
zoom_start=options['zoom'],
)
if map_type == 'static':
# TODO WORKAROUND UNTIL GEOJSON ACCEPTS MARKERS
if options['markers']:
for feature in features:
Circle(location=[
feature['geometry']['coordinates'][0][1],
feature['geometry']['coordinates'][0][0]
],
fill='true',
radius=feature['properties']['iconstyle']['radius'],
color=feature['properties']['iconstyle']['fillColor'],
fill_opacity=feature['properties']['iconstyle']
['fillOpacity']).add_to(m)
if channel is not None:
fields = ["device", "channel", "timestamp", "coordinates", "value"]
aliases = [
"Device:", "Sensor:", "Timestamp:", "Coordinates:", "Reading:"
]
else:
fields = ["device", "timestamp", "coordinates"]
aliases = ["Device:", "Timestamp:", "Coordinates:"]
popup = GeoJsonPopup(
fields=fields,
aliases=aliases,
localize=True,
labels=True,
max_width=800,
)
tooltip = GeoJsonTooltip(
fields=fields,
aliases=aliases,
localize=True,
sticky=True,
labels=True,
style="""
background-color: #F0EFEF;
border: 1px solid gray;
border-radius: 1px;
box-shadow: 2px;
""",
max_width=800,
)
GeoJson(
featurecol,
tooltip=tooltip,
popup=popup,
style_function=lambda x: {
'color': x['properties']['style']['color'],
'weight': x['properties']['style']['stroke-width'],
'fillOpacity': x['properties']['style']['fillOpacity']
},
).add_to(m)
elif map_type == 'dynamic':
TimestampedGeoJson(featurecol,
period='PT' + convert_rollup(options['period']),
add_last_point=True,
auto_play=False,
loop=False,
max_speed=options['max_speed'],
loop_button=True,
time_slider_drag_update=True).add_to(m)
else:
std_out(f'Not supported map type {map_type}', 'ERROR')
return None
if options['minimap']:
minimap = MiniMap(toggle_display=True, tile_layer=options['tiles'])
minimap.add_to(m)
if options['legend'] and not legend_labels is None:
templateLoader = FileSystemLoader(searchpath=join(dirname(__file__),\
'templates'))
templateEnv = Environment(loader=templateLoader)
template = templateEnv.get_template("map_legend.html")
filled_map_legend = template.render(legend_labels=legend_labels)
map_legend_html = '{% macro html(this, kwargs) %}'+\
filled_map_legend+\
'{% endmacro %}'
legend = element.MacroElement()
legend._template = element.Template(map_legend_html)
m.get_root().add_child(legend)
return m