def create_fault_layer():
blind_faults = shapefile.Reader(faults_blind)
nonblind_faults = shapefile.Reader(faults_nonblind)
faults = [
dl.Polyline(
color='#404040',
weight=1.25,
dashArray='2, 3',
positions=[[
coord[1], coord[0]
] for coord in feature.shape.__geo_interface__['coordinates']])
for feature in blind_faults.shapeRecords()
]
faults += [
dl.Polyline(
color='black',
weight=1,
positions=[[
coord[1], coord[0]
] for coord in feature.shape.__geo_interface__['coordinates']])
for feature in nonblind_faults.shapeRecords()
]
return dl.LayerGroup(id='fault-layer', children=faults)
def make_empty_map(lat_center=51.326863, lon_center=10.354922, zoom=5):
fig = [
dl.Map(
[
dl.TileLayer(url=mapURL,
attribution=attribution,
tileSize=512,
zoomOffset=-1),
dl.LayerGroup(id="layer"),
dl.WMSTileLayer(url="https://maps.dwd.de/geoserver/ows?",
layers="dwd:RX-Produkt",
format="image/png",
transparent=True,
opacity=0.7,
version='1.3.0',
detectRetina=True),
dl.LocateControl(
options={'locateOptions': {
'enableHighAccuracy': True
}}),
],
center=[lat_center, lon_center],
zoom=zoom,
style={
'width': '100%',
'height': '45vh',
'margin': "auto",
"display": "block"
},
id='map')
]
return fig
def get_event_layer(eq_data, sizes, colors, opacities):
"""Return a LayerGroup that contains earthquakes represented as circles.
Keyword arguments:
eq_data -- EarthquakeData object containing the quakes to be drawn.
sizes -- An array containing a size for each data point
colors -- An array containing a color for each data point
opacities -- An array containing an opacity for each data point
"""
quake_circles = [
dl.Circle(center=[quake['LATITUDE'], quake['LONGITUDE']],
radius=sizes[idx],
color=colors[idx],
fillOpacity=opacities[idx],
weight=2,
children=[
dl.Popup(dcc.Markdown(
list(
map(
lambda x: '**{}**: {} '.format(
x.replace('[', r'\['), quake[x]),
quake.keys()))),
className='earthquake-popup')
]) for idx, quake in eq_data.data.reset_index().iterrows()
]
return dl.LayerGroup(id='layer-id', children=quake_circles)
def build_alerts_map():
"""
The following function mobilises functions defined hereabove or in the utils module to
instantiate and return a dl.Map object, corresponding to the "Alerts and Infrastructure" view.
"""
map_object = dl.Map(
center=[44.73,
4.27], # Determines the point around which the map is centered
zoom=9, # Determines the initial level of zoom around the center point
children=[
dl.TileLayer(id='tile_layer'),
build_departments_geojson(),
build_filters_object(map_type='alerts'),
build_legend_box(map_type='alerts'),
dl.MarkerClusterGroup(
children=build_sites_markers(sites_with_live_alerts=[]),
id='sites_markers'),
dl.LayerGroup(id='vision_polygons'),
html.Div(id="live_alerts_marker"),
html.Div(id="live_alert_header_btn"),
html.Div(id='fire_markers_alerts')
], # Will contain the past fire markers of the alerts map
style=map_style, # Reminder: map_style is imported from utils.py
id='map')
return map_object
def create_map(self):
self.ns = Namespace("dlx", "scatter")
self.markers = [
dl.Marker(
dl.Tooltip(f"({pos[0]}, {pos[1]}), time:{self.times[i]}"),
position=pos,
id="marker{}".format(i))
for i, pos in enumerate(self.locations)
]
self.cluster = dl.MarkerClusterGroup(
id="markers",
children=self.markers,
options={"polygonOptions": {
"color": "red"
}})
self.app = dash.Dash(external_scripts=[
"https://cdnjs.cloudflare.com/ajax/libs/chroma-js/2.1.0/chroma.min.js"
])
self.polyline = dl.Polyline(positions=self.locations)
self.app.layout = html.Div([
dl.Map([
dl.TileLayer(), self.cluster, self.polyline,
dl.LayerGroup(id="layer")
],
id="map",
center=(40.4259, -86.9081),
zoom=8,
style={'height': '100vh'}),
])
def get_location_uncertainty_layer(eq_data, visible):
"""Return a map layer with uncertainties visualized for each data point.
Keyword arguments:
eq_data -- An Earthquake data object containing the data visible on the map
visible -- A boolean indicating whether to display the uncertainties in
location of each data point
"""
if eq_data.data.shape[0] == 0 or not visible:
return dl.LayerGroup(id='location-uncertainties')
location_uncertainties = eq_data.get_location_uncertainties()
reset_data = eq_data.data.reset_index()
uncertainties = []
if type(location_uncertainties) == int:
uncertainties = [
dl.Circle(center=[quake['LATITUDE'], quake['LONGITUDE']],
radius=location_uncertainties,
color='black',
fillOpacity=0,
dashArray='5, 5',
weight=1.5,
children=[
dl.Popup(dcc.Markdown(
list(
map(
lambda x: '**{}**: {} '.format(
x.replace('[', r'\['), quake[x]),
quake.keys()))),
className='earthquake-popup')
]) for _, quake in reset_data.iterrows()
]
else:
uncertainties += [
dl.Polyline(positions=[[
quake['LATITUDE'], quake['LONGITUDE']
], location_uncertainties[idx + direction * reset_data.shape[0]]],
color='black',
dashArray='5, 5',
weight=1.5) for direction in range(4)
for idx, quake in reset_data.iterrows()
]
return dl.LayerGroup(id='location-uncertainties', children=uncertainties)
def build_historic_markers(dpt_code=None):
"""
This function reads through the 'historic_fires.csv' file stored in the /data folder.
It takes as input a department code (as a character string), which will correspond to the department
on which the user chooses to click and it returns past fires (as markers on the map) for this area.
More precisely, it returns a dl.LayerGroup object that gathers all relevant past fire markers.
"""
# As long as the user does not click on a department, dpt_code is None and we return no fire marker
if not dpt_code:
return None
# We read the csv file that locates the old fires
old_fire_positions = pd.read_csv(Path(__file__).parent.joinpath('data', 'historic_fires.csv'), ',')
# The line below allows us to filter for the department of interest
old_fire_positions = old_fire_positions[old_fire_positions['Département'] == int(dpt_code)].copy()
icon = {"iconUrl": '../assets/pyro_oldfire_icon.png',
"iconSize": [50, 50], # Size of the icon
"iconAnchor": [25, 45], # Point of the icon which will correspond to marker's and popup's location
"popupAnchor": [0, -20] # Point from which the popup should open relative to the iconAnchor
}
# We build a list of dictionaries containing the coordinates of each fire
fire_markers = []
for i, row in old_fire_positions.iterrows():
lat = row['latitude']
lon = row['longitude']
location = row['location']
date = datetime.datetime.strptime(row['acq_date'], '%Y-%m-%d')\
.strftime('%d %b %Y')
if row['daynight'] == 'D':
daynight = 'Diurne'
elif row['daynight'] == 'N':
daynight = 'Nocturne'
else:
daynight = None
fire_markers.append(dl.Marker(id=f'historic_fire_{i}', # Set an id for each marker to receive callbacks
position=(lat, lon),
icon=icon,
children=[dl.Tooltip(f"Date: {date}"),
dl.Popup([html.H4(f'Incendie du {date}'),
html.P(f'Commune : {location}'),
html.P(f'Type : {daynight}')])
]
)
)
# We gather all markers stored in the fire_markers list in a dl.LayerGroup object, which is returned
return dl.LayerGroup(children=fire_markers,
id='historic_fires_markers')
def get_fault_layer(show_faults=False):
"""Return a LayerGroup that contains the Southern California
fault lines as PolyLines.
Blind faults are represented by dashed, dark grey lines and
non-blind faults by solid, black lines.
Keyword arguments:
show_faults -- A boolean indicating whether to show the faults
"""
if show_faults:
return fault_layer
return dl.LayerGroup(id='fault-layer', children=[])
def plot_coordinate(value='11 Cadogan Gardens'):
search_data = df[df['Hotel_Name'] == value]
lat = search_data.lat.values[0]
lng = search_data.lng.values[0]
name = search_data.Hotel_Name.values[0]
address_ = search_data.Hotel_Address.values[0]
markers = [
dl.Marker(
position=[lat, lng],
children=[dl.Popup('Name: ' + name + ', Address: ' + address_, )])
]
return html.Div([
dl.Map([dl.TileLayer(), dl.LayerGroup(id="layer")] +
[dl.LayerGroup(markers)],
center=[lat, lng],
zoom=14,
id="map",
style=MAP_STYLE),
]),
def update_routes(agregation_option, routes):
# Routes Layer Map
df = df_routes.copy()
df = df[df[agregation_option].isin(routes)]
map_routes_children = []
for row in df.itertuples():
map_routes_children.append(dl.Polygon(positions = [(p[1], p[0]) for p in row.geometry.exterior.coords],
children = dl.Tooltip(row.Route),
color = dict_colors[row.Route],
fillColor = dict_colors[row.Route]
)
)
return dl.LayerGroup(map_routes_children),
def generate_map_plot(data):
if data is not None:
start_point = data['STATION_NAME'].item()
point = [data['LAT'].item(), data['LON'].item()]
fig = [
dl.Map(
[
dl.TileLayer(url=mapURL,
attribution=attribution,
tileSize=512,
zoomOffset=-1),
dl.LayerGroup(id="layer"),
dl.WMSTileLayer(url="https://maps.dwd.de/geoserver/ows?",
layers="dwd:SAT_WELT_KOMPOSIT",
format="image/png",
transparent=True,
opacity=0.7,
version='1.3.0',
detectRetina=True),
dl.WMSTileLayer(url="https://maps.dwd.de/geoserver/ows?",
layers="dwd:SAT_EU_RGB",
format="image/png",
transparent=True,
opacity=0.7,
version='1.3.0',
detectRetina=True),
dl.LocateControl(options={
'locateOptions': {
'enableHighAccuracy': True
}
}),
dl.Marker(position=point,
children=dl.Tooltip(start_point)),
],
center=point,
zoom=4,
style={
'width': '100%',
'height': '35vh',
'margin': "auto",
"display": "block"
},
id='map')
]
else: # make an empty map
fig = make_empty_map()
return fig
def get_event_layer(eq_data):
"""Return a LayerGroup that contains earthquakes represented as circles.
Keyword arguments:
eq_data -- EarthquakeData object containing the quakes to be drawn.
"""
quake_circles = [
dl.Circle(center=[quake['LATITUDE'], quake['LONGITUDE']],
radius=100,
color='red',
fillOpacity=0.1,
weight=2) for _, quake in eq_data.data.iterrows()
]
return dl.LayerGroup(id='layer-id', children=quake_circles)
def update_events(start_date, end_date, agregation_option,routes):
# Events Layer Map
df = df_events.copy()
df = df[(df[agregation_option].isin(routes)) & (df['Reported Date'].between(start_date, end_date))]
df['color'] = [select_df_color[agregation_option][r] for r in df[agregation_option]]
map_events_children = []
for row in df.itertuples():
map_events_children.append(dl.Marker(position = [row.geometry.y, row.geometry.x],
children = dl.Popup('Reported Date: {}'.format(row._1.date()
)
)
)
)
return dl.LayerGroup(map_events_children),
def generate_map_plot(df):
if df is not None:
lons = df.lons.values
lats = df.lats.values
trajectory = np.vstack([lats, lons]).T.tolist()
start_point = df.source.values[0]
end_point = df.destination.values[0]
zoom, center = zoom_center(lons, lats, width_to_height=8)
fig = [
dl.Map(
[
dl.TileLayer(url=mapURL,
attribution=attribution,
tileSize=512,
zoomOffset=-1),
dl.LayerGroup(id="layer"),
dl.WMSTileLayer(url="https://maps.dwd.de/geoserver/ows?",
layers="dwd:RX-Produkt",
format="image/png",
transparent=True,
opacity=0.7),
dl.LocateControl(options={
'locateOptions': {
'enableHighAccuracy': True
}
}),
dl.Polyline(positions=trajectory),
dl.Marker(position=trajectory[0],
children=dl.Tooltip(start_point)),
dl.Marker(position=trajectory[-1],
children=dl.Tooltip(end_point))
],
center=[center['lat'], center['lon']],
zoom=zoom,
style={
'width': '100%',
'height': '45vh',
'margin': "auto",
"display": "block"
},
id='map')
]
else: # make an empty map
fig = make_empty_map()
return fig
html.Div(id='print_districts',
style={
'font-size': '14px',
'display': 'inline-block'
}),
html.Hr(),
html.Div([
html.Div(
# Fifth: row contains map and graph
dl.Map(
id="map",
# Order of this list determines overlay order
children=[
grid_rivers,
dl.TileLayer(),
dl.LayerGroup(id="start_marker"),
dl.LayerGroup(id='rec_neighbours'),
dl.LayerGroup(id='rec_pois'),
dl.LayerGroup(id='marker_stations'),
dl.LayerGroup(id="marker_floods"), color_bar, grid_geo,
districts_geo
],
zoom=7,
center=[1.40, 32.30],
doubleClickZoom=True,
maxBounds=bounds_uganda),
style={
'width': '60%',
'height': '70vh',
"display": "inline-block"
}),
def get_app():
"""Create a new Dash instance with a Terracotta instance embedded in it.
Args:
tc_app: Flask instance of Terracotta
Returns:
A Flask instance of a Dash app.
"""
# pylint: disable=unused-variable
data = _get_data()
app = dash.Dash(__name__, server=False)
app.title = 'Taswira'
options = [{'label': k, 'value': k} for k in list(data)]
app.layout = html.Div(
[
dcc.Store(id='raster-layers-store'),
dcc.Dropdown(id='title-dropdown',
clearable=False,
options=options,
value=options[0]['value'],
style={
'position': 'relative',
'top': '5px',
'zIndex': '500',
'height': '0',
'maxWidth': '200px',
'marginLeft': 'auto',
'marginRight': '10px'
}),
html.Div(dl.Map([
dl.TileLayer(attribution=BASE_MAP_ATTRIBUTION),
dl.LayerGroup(id='raster-layers'),
dl.LayerGroup(id='colorbar-layer')
],
id='main-map'),
id='main-map-div',
style={
'position': 'relative',
'width': '100%',
'height': '70%',
'top': '0',
'left': '0'
}),
html.Div(
[
html.Button(id='animation-btn'),
dcc.Interval(id='animation-interval', disabled=True)
],
style={
'position': 'relative',
'top': '-50px',
'left': '10px',
'zIndex': '500',
'height': '0',
},
id="animation-control"),
html.Div(
[dcc.Slider(
id='year-slider',
step=None,
value=0,
)],
style={
'position': 'relative',
'top': '-50px',
'left': '60px',
'zIndex': '500',
'height': '0',
'marginRight': '9em'
},
id='year-slider-div'),
dcc.Graph(id='indicator-change-graph',
responsive=True,
style={
'width': '100%',
'height': '30%'
})
],
style={
'position': 'absolute',
'width': '100%',
'height': '100%',
'top': '0',
'left': '0',
'fontFamily': 'sans-serif'
})
app.clientside_callback(
"""
function(year, layers){
return layers.map(l => {
console.log(typeof l.props.id, typeof year);
if (Number(l.props.id) === year)
return {...l,props: {...l.props, opacity: 1.0}};
return l;
});
}
""", Output('raster-layers', 'children'),
[Input('year-slider', 'value'),
Input('raster-layers-store', 'data')],
[State('raster-layers', 'children')])
@app.callback([
Output('raster-layers-store', 'data'),
Output('colorbar-layer', 'children'),
Output('main-map', 'bounds')
], [Input('title-dropdown', 'value')])
def update_raster_layers_colobar_map_bounds(title):
ranges = [data[title][year]['range'] for year in data[title].keys()]
lowers, uppers = list(zip(*ranges))
stretch_range = [min(lowers), max(uppers)]
xyz = '{z}/{x}/{y}'
layers = []
for year in data[title]:
raster_data = data[title][year]
colormap = raster_data['metadata']['colormap']
bounds = format_bounds(raster_data['bounds'])
layers.append(
dl.TileLayer(
url=
f'/singleband/{title}/{year}/{xyz}.png?colormap={colormap}',
opacity=0,
id=year))
colorbar = get_colorbar(stretch_range, colormap)
return layers, [colorbar], bounds
@app.callback([
Output('year-slider', 'marks'),
Output('year-slider', 'min'),
Output('year-slider', 'max'),
], [Input('title-dropdown', 'value')])
def update_slider(title):
mark_style = {'color': '#fff', 'textShadow': '1px 1px 2px #000'}
marks = {
int(k): dict(label=k, style=mark_style)
for k in data[title].keys()
}
min_value = min(marks.keys())
max_value = max(marks.keys())
return marks, min_value, max_value
@app.callback(Output('year-slider', 'value'), [
Input('year-slider', 'marks'),
Input('animation-interval', 'n_intervals')
], [State('year-slider', 'value')])
def update_slider_value(marks, n_intervals, current_value): # pylint: disable=unused-argument
ctx = dash.callback_context
min_value = min(marks.keys())
if ctx.triggered:
trigger = ctx.triggered[0]['prop_id'].split('.')[0]
trigger_value = ctx.triggered[0]['value']
if trigger == 'animation-interval' and trigger_value:
new_value = get_element_after(str(current_value),
iter(marks.keys()))
if new_value is not None:
return int(new_value)
elif current_value:
return current_value
return int(min_value)
@app.callback(Output('indicator-change-graph', 'figure'),
[Input('title-dropdown', 'value')])
def update_graph(title):
fig = go.Figure()
x_marks = []
y_margs = []
for year, meta in data[title].items():
x_marks.append(year)
y_margs.append(meta['metadata']['indicator_value'])
fig.add_trace(go.Scatter(x=x_marks, y=y_margs, mode='lines+markers'))
unit = ''
for _, meta in data[title].items():
unit = meta['metadata']['unit']
break
fig.update_layout(autosize=False,
xaxis_title='Year',
yaxis_title=f'{title} ({unit})',
xaxis_type='category',
height=150,
margin=dict(t=10, b=0))
return fig
@app.callback(Output('animation-control', 'children'),
[Input('animation-btn', 'n_clicks')], [
State('animation-btn', 'value'),
])
def update_animation_control(n_clicks, current_value): # pylint: disable=unused-argument
new_value = 'pause' if current_value == 'play' else 'play'
btn = html.Button(new_value.capitalize(),
value=new_value,
id='animation-btn',
style={
'height': '30px',
'backgroundColor': '#fff',
'textAlign': 'center',
'borderRadius': '4px',
'border': '2px solid rgba(0,0,0,0.2)',
'fontWeight': 'bold'
})
is_paused = (new_value == 'play')
interval = dcc.Interval(id='animation-interval', disabled=is_paused)
return [btn, interval]
return app
import style
from setting import app
from elements import country_dropdown
server = app.server
app.layout = dbc.Container([
dcc.Location(id='url', refresh=False),
dbc.Row('土地面積計算', className="h1 text-primary py-5", justify='center'),
dbc.Row([
dbc.Col(dl.Map([
dl.TileLayer(
url='http://mt0.google.com/vt/lyrs=s,h&x={x}&y={y}&z={z}',
maxZoom=20),
dl.LayerGroup(id="drawing"),
dl.LayerGroup([], id="polygons")
],
id="map",
style=style.map,
center=(23.5, 120.5),
zoom=8),
width=6,
className='pl-5'),
dbc.Col([dbc.Row('', id='client_ip'),
dbc.Row(country_dropdown)],
width=6,
className='pr-5')
]),
dcc.Store(id="store", data=[])
],
def render_map(show_labels):
show_labels = 'show-all-labels' in show_labels
simplify = False
nodes = []
links = []
lats = []
lons = []
tt_paths = {}
for i, (abbr, full_name) in enumerate(BASINS.items()):
oa_network_path = '../openagua_schematics/{} River.json'.format(
full_name)
if not os.path.exists(oa_network_path):
continue
with open(oa_network_path) as f:
oa_network = json.load(f)
pywr_model_path = '../{}/temp/pywr_model_Livneh_simplified.json'.format(
full_name.replace(' ', '_').lower())
if not os.path.exists(pywr_model_path):
continue
with open(pywr_model_path) as f:
pywr_network = json.load(f)
net = oa_network['network']
tmpl = oa_network['template']
node_lookup = {n['name']: n for n in net['nodes']}
if i == 0:
for tt in tmpl['templatetypes']:
tt_name = tt['name']
tt_svg = tt['layout'].get('svg')
if not tt_svg:
continue
tt_path = './icons/{}.svg'.format(tt_name.replace(' ', '_'))
with open(os.path.join('./assets', tt_path), 'w') as f:
f.write(tt_svg)
tt_paths[tt['name']] = tt_path
if simplify:
for n in pywr_network['nodes']:
if n['name'] not in node_lookup:
continue
node = node_lookup[n['name']]
lat, lon = float(node['y']), float(node['x'])
lats.append(lat)
lons.append(lon)
nodes.append(leaflet.Marker(position=[lat, lon]))
for n1, n2 in pywr_network['edges']:
if n1 not in node_lookup or n2 not in node_lookup:
continue
node1 = node_lookup[n1]
node2 = node_lookup[n2]
lat1, lon1 = float(node1['y']), float(node1['x'])
lat2, lon2 = float(node2['y']), float(node2['x'])
positions = [[lat1, lon1], [lat2, lon2]]
links.append(leaflet.Polyline(positions=positions))
else:
for node in net['nodes']:
lat, lon = float(node['y']), float(node['x'])
tt = [
t for t in node['types'] if t['template_id'] == tmpl['id']
][-1]
tt_path = tt_paths.get(tt['name'])
kwargs = {}
if tt_path:
if tt['name'].lower(
) == 'junction' or 'gauge' in tt['name'].lower():
size = 12
else:
size = 24
kwargs.update(icon=dict(iconUrl=app.get_asset_url(tt_path),
iconSize=[size, size],
iconAnchor=[size / 2, size / 2]))
nodes.append(leaflet.Marker(position=[lat, lon], **kwargs))
lats.append(lat)
lons.append(lon)
for link in net['links']:
coords = link['layout']['geojson']['geometry']['coordinates']
lons_, lats_ = zip(*coords)
positions = list(zip(*[lats_, lons_]))
tt = [
t for t in link['types'] if t['template_id'] == tmpl['id']
][-1]
linestyle = tt['layout'].get('linestyle')
if type(linestyle) == str:
try:
linestyle = json.loads(linestyle)
except:
linestyle = {}
links.append(leaflet.Polyline(positions=positions,
**linestyle))
clat = (min(lats) + max(lats)) / 2
clon = (min(lons) + max(lons)) / 2
return [
leaflet.Map(
style={
'width': '100%',
'height': '100%'
},
center=[clat, clon],
zoom=9,
children=[
leaflet.TileLayer(
url="https://a.tile.openstreetmap.org/{z}/{x}/{y}.png"),
leaflet.LayerGroup(children=nodes + links)
])
]
)
wards = dl.GeoJSON(
data=ward_geojson, # TODO: Faster is to get PBFs
options={"style": {
"color": "red",
"fillOpacity": 0.5,
"weight": 2
}},
zoomToBoundsOnClick=
True, # when true, zooms to bounds of feature (e.g. polygon) on click
hoverStyle=arrow_function(
dict(weight=4, fillOpacity=0.2,
dashArray="")), # special style applied on hover)
id="wards-geojson",
)
ward_overlay = dl.Overlay(dl.LayerGroup(wards), name="wards", checked=True)
# Wards: Show election info on click
@app.callback(
Output("ward-info-panel", "children"),
[Input("wards-geojson", "click_feature")],
State("election-dropdown", "value"),
)
def ward_click(feature, election_selected):
div_children = []
races_per_election = dict(
aug_2020=dict(
rep1_dem=dict(
name="U.S Congress MO-1 (Democratic Primary)",
candidates=["Clay", "Bush"],
def tabulate(activetabs,hashkey):
global df,params
#
# print
# (activetabs,hashkey)
if activetabs == 'filter':
info('enabling filter options')
params['precompute']= True
return None,None,None
if type(df) != type(None):
# '''
# table
# '''
if activetabs == 'table_tab':
message = md('''
# Table Sample
Showing a *random* sample of *500* values from the selected dataframe
''')
newdf = df
if len(df)>500: newdf = newdf.sample(500).reset_index()
try: newdf.drop(['UNIXTIME'],inplace=True)
except: None
print(newdf)
return [message,br,table(newdf,'tab_table',{'width':'80%','margin':'auto'})],None,None
# '''
# scatter_tab
# '''
elif activetabs == 'scatter_tab':
gc = 'PM1 PM3 PM2.5 PM10 UNIXTIME'.split()
cols = list(filter(lambda x:x in gc ,df.columns))
dfp = df[cols]
dfp['hour'] = df.index.hour + (df.index.minute/15)//4
dfp = dfp.groupby('hour').mean().reset_index()
print(dfp)
sizes = {'PM1':2,'PM2.5':3, 'PM3':3, 'PM10':10}
alpha = 0.8
for i in 'PM1 PM3 PM2.5 PM10'.split()[::-1]:
if i in dfp.columns:
# print(i)
try:
ax = dfp.plot(kind='scatter',x='hour', y=i, c='UNIXTIME',colormap='viridis',ax=ax,colorbar=False,label=i, s = sizes[i],alpha = alpha)
except:
ax = dfp.plot(kind='scatter',x='hour', y=i, c='UNIXTIME',colormap='viridis', label=i, s = sizes[i],alpha=alpha)
plt.legend()
plt.tight_layout()
plt.xlabel('HOUR')
plt.ylabel('Avg value')
'''
save to a base 64str
'''
import base64
import io
IObytes = io.BytesIO()
plt.savefig(IObytes, format='png')
plt.close()
IObytes = base64.b64encode(IObytes.getvalue()).decode("utf-8").replace("\n", "")
plot = html.Img(src="data:image/png;base64,{}".format(IObytes))
return None,[md('# A grouped summary of the following dataframe:'),br,br,table(dfp.describe().reset_index(),'descplot'), br,br,plot],None
elif activetabs == 'map_tab':
dfp = df['LAT LON'.split()].dropna(subset=['LON'])
if len(dfp)>1000: dfp.dfp.sample(1000)
print(dfp)
desc = md('''
# Location overview
An interactive map showing a *random* subset of *1000* datapoints from the selected subset.
These vary between each initiation due to the above reason.
The centre of the map is calculated by taking the median latitude and Longitude, the colour shows the time of day, and the tooltip produces the index value from the dataset.
''')
log.critical('Known: -ves on Longitude are lost!!!!!')
mid = (dfp.LAT.median(), -dfp.LON.median())
dfp.columns = ['lat','lon']
print(mid)
cc = [dl.CircleMarker( dl.Tooltip(str(row[0])), center=(row[1].lat,-row[1].lon), radius=5, stroke=True,color='none',weight=0,fillColor='blue' ) for row in dfp.iterrows()]
circles = dl.LayerGroup(cc,id='markers')
''' when the regeneratorRuntime issue is solved '''
log.critical(' Known: cannot show superCluster due to regeneratorRuntime issue')
# ll = dlx.dicts_to_geojson(dfp.to_dict('records'))
#
# # markers = dl.GeoJSON(data=ll, cluster=True, zoomToBoundsOnClick=True,
# # # superClusterOptions={"radius": 100}
# # )
# markers = []
plot = html.Div(
id="bibmap",
children=[ desc,br,br,
dl.Map([dl.TileLayer(),circles], center=mid, zoom=12,style={'width': '90vw', 'height': '50vh'})
],
# style={'width': '100vw', 'height': '50vh', 'margin': "auto", "display": "block"}
)
return None,None,plot
else:
return None,None,None
else:
return None,None,None
"name": "viewport",
"content": "width=device-width, initial-scale=1"
}],
)
server = app.server
url = 'https://tiles.stadiamaps.com/tiles/alidade_smooth_dark/{z}/{x}/{y}{r}.png'
attribution = '© <a href="https://stadiamaps.com/">Stadia Maps</a> '
click_positions = []
if len(click_positions) > 2:
click_positions = []
app.layout = html.Div([
dl.Map([
dl.TileLayer(url=url, maxZoom=20, attribution=attribution),
dl.LayerGroup(id="position")
],
id="map",
style={
'width': '100%',
'height': '50vh',
'margin': "auto",
"display": "block"
})
])
@app.callback(Output("position", "children"), [Input("map", "click_lat_lng")])
def map_click(dbl_click_lat_lng):
click_positions.append(dbl_click_lat_lng)
print(click_positions[-2:])
def run():
# defining the number of steps
n = 500
#creating two array for containing x and y coordinate
#of size equals to the number of size and filled up with 0's
x = numpy.zeros(n)
y = numpy.zeros(n)
global locations
locations = [] #used in map generator
locations_base = [] #the base data.
start_location = [40.4259, -86.9081]
at_risk = numpy.random.uniform(low=0.0, high=1.1, size=(n, ))
start_time = 0
map_dir = "index.html"
MINUTES_IN_DAY = 1440
start_date = datetime.datetime.now()
times = list(range(0, n))
time_index = 0
datetimes = []
for i in range(len(times)):
noise = random.randint(1, 5)
times[i] = (times[i] + noise)
datetimes.append(start_date + timedelta(minutes=times[i]))
datetimeindex = pd.Series(range(0, n), index=datetimes)
#filling the coordinates with random variables
for i in range(1, n):
val = random.randint(1, 4)
if val == 1:
x[i] = x[i - 1] + 0.001
y[i] = y[i - 1]
elif val == 2:
x[i] = x[i - 1] - 0.001
y[i] = y[i - 1]
elif val == 3:
x[i] = x[i - 1]
y[i] = y[i - 1] + 0.001
else:
x[i] = x[i - 1]
y[i] = y[i - 1] - 0.001
locations_base.append(
[x[i] + start_location[0], y[i] + start_location[1]])
ns = Namespace("dlx", "scatter")
new_markers = [
dl.Marker(dl.Tooltip(f"({pos[0]}, {pos[1]}), time:{times[i]}"),
position=pos,
id="marker{}".format(i)) for i, pos in enumerate(locations)
]
cluster = dl.MarkerClusterGroup(
id="new_markers",
children=new_markers,
options={"polygonOptions": {
"color": "red"
}})
patterns = [dict(offset='0%', repeat='0', marker={})]
polyline = dl.Polyline(positions=[locations], id="id_polyline")
marker_pattern = dl.PolylineDecorator(id="id_marker_pattern",
children=polyline,
patterns=patterns)
app = dash.Dash(external_scripts=[
"https://cdnjs.cloudflare.com/ajax/libs/chroma-js/2.1.0/chroma.min.js"
])
app.layout = html.Div(
html.Div([
dl.Map([
dl.TileLayer(), cluster, marker_pattern,
dl.LayerGroup(id="layer")
],
id="map",
center=(40.4259, -86.9081),
zoom=8,
style={'height': '100vh'}),
#html.Div(id='live-update-text'),
dcc.Interval(
id="interval",
interval=1 * 1000, # in milliseconds
n_intervals=0)
]))
@app.callback(Output('id_marker_pattern', 'children'),
[Input('interval', 'n_intervals')])
def update_polyline(b):
polyline = dl.Polyline(positions=locations)
return polyline
@app.callback(Output('new_markers', 'children'),
[Input('interval', 'n_intervals')])
def update_metrics(a):
locations.append([locations_base[a][0], locations_base[a][1]])
if (len(locations) >= 100):
locations.pop(0)
new_markers = [
dl.Marker(dl.Tooltip(f"({pos[0]}, {pos[1]}), time:{times[i]}"),
position=pos,
id="marker{}".format(i))
for i, pos in enumerate(locations)
]
return new_markers
def rgb_to_hex(rgb):
return ('%02x%02x%02x' % rgb)
def get_time_interval(sd, ed):
indices = datetimeindex[sd:ed].to_numpy()
print(indices)
def change_color_to_time():
for i in range(len(locations)):
time = times[i]
r = 255 - math.trunc(255 * (time / MINUTES_IN_DAY))
color_tuple = (r, r, r)
rgb = rgb_to_hex(color_tuple)
icon = {
"iconUrl":
f"http://chart.apis.google.com/chart?chst=d_map_pin_letter&chld=%E2%80%A2|{rgb}&chf=a,s,ee00FFFF",
"iconSize": [20, 30], # size of the icon
}
markers[i].icon = icon
def change_color_to_risk():
for i in range(len(locations)):
time = times[i]
risk = math.trunc(at_risk[i])
if (risk == 1):
icon = {
"iconUrl":
"http://chart.apis.google.com/chart?chst=d_map_pin_letter&chld=%E2%80%A2|FF0000&chf=a,s,ee00FFFF",
"iconSize": [20, 30], # size of the icon
}
else:
icon = {
"iconUrl":
"http://chart.apis.google.com/chart?chst=d_map_pin_letter&chld=%E2%80%A2|00FF00&chf=a,s,ee00FFFF",
"iconSize": [20, 30], # size of the icon
}
markers[i].icon = icon
print("risk")
def clamp(n, minn, maxn):
return max(min(maxn, n), minn)
def change_color_to_speed():
speed = 0
avewalk = 0.084
speeddiff = 0
for i in range(len(locations)):
if i == 0:
speed = 0
elif (times[i] - times[i - 1]) == 0:
speed = 0
else:
#coords_1 = [locations[i][0], locations[i][1]]
#coords_2 = [locations[i-1][0], locations[i-1][1]]
#distance = h3.point_dist(coords_1,coords_2)
R = 6373.0
lat1 = radians(locations[i][0])
lon1 = radians(locations[i][1])
lat2 = radians(locations[i - 1][0])
lon2 = radians(locations[i - 1][1])
dlon = lon2 - lon1
dlat = lat2 - lat1
a = 2
##sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
c = 2
##2 * atan2(sqrt(a), sqrt(1 - a))
distance = R * c
speed = abs(distance / (times[i] - times[i - 1]))
speeddiff = speed * 1000 / 60 - 1.4
r = clamp(100 + speeddiff * 300, 0,
255) #grey normal, yellow fast, blue slow
g = clamp(100 + speeddiff * 100, 0, 255)
b = clamp(100 - speeddiff * 100, 0, 255)
color_tuple = (int(r), int(g), int(b))
rgb = rgb_to_hex(color_tuple)
icon = {
"iconUrl":
f"http://chart.apis.google.com/chart?chst=d_map_pin_letter&chld=%E2%80%A2|{rgb}&chf=a,s,ee00FFFF",
"iconSize": [20, 30], # size of the icon
}
markers[i].icon = icon
app.run_server(port=8050)
url = 'https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}{r}.png'
attribution = '© <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors © <a href="https://carto.com/attributions">CARTO</a>'
map_coord = html.Div([
html.P("Click on map to choose Coordinate:"),
dl.Map(id="map-id",
style={
'width': '100%',
'height': '300px'
},
center=NYC_coor,
zoom=10,
children=[
dl.TileLayer(url=url, maxZoom=20, attribution=attribution),
dl.LayerGroup(id="layer")
])
])
text1 = """On this page you can find a suggested price for your own Airbnb listing by moving the sliders to match your condo and clicking on the map to indicate the location.
We recommend choosing the position of your condo first, by navigating the map and zooming to its location and clicking. This way you can see the increase or decrease in price as you adjust how much of your condo you want to rent out, for how long, and if you need to buy a botnet to leave reviews on your listing to inflate the price.
"""
text2 = """Behind the scenes our machine learning algorithms calculate how much the features you were introduced to on the previous pages increase or decrease the mean price of a condo in a given New York location.
When you click on the map and adjust the sliders the page gives you a suggested price, this will be an approximation of a likely price in that position with the given parameters."""
def page_9(df):
return html.Div([
dbc.Row([
geolocator = Nominatim(user_agent='locator-for-dash-app')
app = Dash(prevent_initial_callbacks=True,
external_stylesheets=[dbc.themes.BOOTSTRAP])
app.layout = html.Div([
html.Div([
html.P('Insert location search string'),
dcc.Input(id='location-input', type='text', debounce=True),
dbc.Button(
'Search',
id='search-button',
color='secondary',
size='lg',
)
]),
dl.Map([dl.TileLayer(), dl.LayerGroup(id="layer")],
id="map",
style={
'width': '20%',
'height': '50vh',
'margin': "auto",
"display": "block"
}),
html.P(id='coordinates-display'),
])
@app.callback(
Output("layer", "children"),
Output("coordinates-display", "children"),
Input("search-button", "n_clicks"),
markers = [
dl.CircleMarker(dl.Tooltip(str(row)),
center=[row[1].LAT, row[1].LON],
radius=25 * row[1][what] / mx,
stroke=True,
weight=1,
color='red',
fillColor=cols[row[1]['cat']],
fillOpacity=0.7) for row in df.iterrows()
]
#fillColor
#color fillOpacity
app = dash.Dash()
app.layout = html.Div(
id="BornInBradford",
children=dl.Map(
[dl.TileLayer(), dl.LayerGroup(markers, id='markers')],
center=mid,
zoom=13,
style={
'width': '100%',
'height': '100vh',
'margin': "auto",
"display": "block"
}))
if __name__ == '__main__':
app.run_server(debug=True)
def build_alerts_elements(images_url_live_alerts, live_alerts, map_style):
"""
This function is used in the main.py file to create alerts-related elements such as the alert button (banner)
or the alert markers on the map.
It takes as arguments:
- 'images_url_live_alerts': url dict with live_alerts urls having event_id keys
- 'live_alerts': json containing live_alerts data
- 'map_style': the type of map in place, either 'alerts' or 'risks'.
All these inputs are instantiated in the main.py file via a POST from the API.
In the base case, the function returns:
- the urls addresses of the image to be displayed on the left of the map;
- the new_alert_button;
- the alert markers displayed on the map;
- new navbar_color as in alert mode;
- new navbar title;
- a list of individual storage components, one for each alert/event to be displayed, that give the URL addresses of
the corresponding frames.
But if the style of map in place is 'risks', we don't want to display neither the alert markers.
So in this case, the third output of the function is a void string.
"""
# Changing the navabar color and title
navbar_color = "#f34848"
navbar_title = "Départs de feux détectés"
# Format of the alert marker icon
icon = {
"iconUrl": '../assets/pyro_alert_icon.png',
"iconSize": [50, 50], # Size of the icon
"iconAnchor": [
25, 45
], # Point of the icon which will correspond to marker's and popup's location
"popupAnchor":
[0, -20
] # Point from which the popup should open relative to the iconAnchor
}
# Building the list of alert markers to be displayed
alerts_markers = []
live_alerts_check = json.loads(live_alerts)
if ((isinstance(live_alerts_check, dict)
and 'status' in live_alerts_check.keys()
and live_alerts_check['status'] == 'never_loaded_alerts_data')
or not live_alerts_check):
# When there is no live alert to display, we return a alert header button that will remain hidden
hidden_header_alert_button = html.Div(
html.Button(id=f'alert_button_{map_style}'),
style={'display': 'none'})
# This is to ensure that the "click_new_alerts_button" callback gets triggered with n_clicks=0 and hides the
# blank user selection area, letting the map take the full width of the screen
# (It can be interesting to test returning [] instead of [hidden_header_alert_button] and erase all alerts one
# by one if explanations are unclear)
return [hidden_header_alert_button
], [], '#054546', 'Surveillez les départs de feux'
else:
all_alerts = pd.read_json(live_alerts)
all_events = all_alerts.drop_duplicates(
['id', 'event_id']).groupby('event_id').head(1) # Get unique events
for _, row in all_events.iterrows():
alert_id = str(row['event_id'])
alert_lat = row['lat']
alert_lon = row['lon']
alerts_markers.append(
dl.Marker(
id={
'type': 'alert_marker',
'index': alert_id
}, # Setting a unique id for each alert marker
position=(alert_lat, alert_lon),
icon=icon))
# Wrapping all markers in the list into a dl.LayerGroup object
alerts_markers_layer = dl.LayerGroup(children=alerts_markers,
id='alerts_markers')
# Building the alerts notification btn
nb_alerts = len(all_events) # Number of unique events
alert_button = html.Div(dbc.Button(
"Nouvelles alertes | {}".format(nb_alerts),
className="btn-header-alerts"),
id=f'alert_button_{map_style}',
style={
'position': 'absolute',
'top': '10px',
'right': '30px',
'z-index': '1000'
})
individual_alert_frame_placeholder_children = []
for event_id, frame_url_list in images_url_live_alerts.items():
individual_alert_frame_placeholder_children.append(
html.Div(id={
'type': 'individual_alert_frame_storage',
'index': str(event_id)
},
children=frame_url_list,
style={'display': 'none'}))
return [alert_button, alerts_markers_layer, navbar_color, navbar_title]
def build_historic_markers(dpt_code=None):
fire_markers = dl.LayerGroup(children=get_old_fire_positions(dpt_code),
id='historic_fires_markers')
return fire_markers
import pandas
import dash_html_components as html
from dash.dependencies import Input, Output
import numpy as np
csv = pandas.read_csv('./ASC2021_draft.csv', names=[0, 1])
csv_list = csv.values.tolist()
markers = [
dl.Marker(position=pos, id="marker{}".format(i), draggable=True)
for i, pos in enumerate(csv_list)
]
app = dash.Dash()
app.layout = html.Div([
html.Div(dl.Map(
[dl.TileLayer(), dl.LayerGroup(id="layer"), *markers],
zoom=4,
center=(csv_list[0][0], csv_list[0][1])),
style={
'width': '60%',
'height': '50vh',
'margin': "auto",
"display": "block"
}),
html.Div(id='clickdata')
])
@app.callback(Output("layer", "children"),
[Input(marker.id, "position") for marker in markers])
def marker_click(*args):
)
],
),
],
),
],
),
# Column for app graphs and plots
html.Div(
className="eight columns div-for-charts bg-grey",
children=[
dl.Map(
dl.Map(
[
dl.TileLayer(),
dl.LayerGroup(id="my-position"),
dl.LayerGroup(id="places-markers"),
],
id="result-map",
style={
"width": "100%",
"height": "100vh",
"margin": "auto",
"display": "block",
},
center=start_point,
zoom=10,
), ),
html.Div(
className="text-padding",
id="result-text",
month_picker_slider2 = dcc.Slider(
id='month_slider2',
min=1,
max=12,
marks={
1: "January", 2: "February", 3: "March", 4: "April", 5: "May", 6: "June", 7: "July", 8: "August", 9: "September", 10: "October", 11: "November", 12: "December"
},
step=1,
value=1,
)
month_picker_row2 = html.Div(style={'textAlign': 'center', 'padding-bottom':'2rem'}, children=[html.Div(children='Query a Month:'), month_picker_slider2])
th = daq.Thermometer(id = 'th', value=0.00, min=0.00, max=100, showCurrentValue=True, width=20, height=450, label='Risk Percentage')
label_cali_map2 = html.Div(html.H3(''),style={'margin-bottom':5, 'margin-left':5})
cali_map2 = dl.Map([dl.TileLayer(), dl.LayerGroup(id="layer")], id='map-id', style={'width':'100%', 'height':550}, center=[37.219306366090116, -119.66673872628975], zoom=5)
cali_map_subdiv2 = html.Div(id = 'cal-map2',style={'columnCount': 2}, children=[cali_map2, th])
cali_map_div2 = html.Div(id = 'calmap2', children=[label_cali_map2, cali_map_subdiv2])
pred_div2 = html.Div(id = 'pred', children=[month_picker_row2, html.H3(className='county_graph_title', children=[f'Please pick a point from the map below']), cali_map_div2])
# End of Geo Located Based Prediction
# Building App
app.title = 'Cal Fire Dashboard'
app.layout = html.Div(children=[dcc.Location(id='url', refresh=False), header, navbar, html.Div(id='page-content', children=[prompt_message_container, our_services])])
# Observer Functions
@app.callback(
dash.dependencies.Output(component_id='desc_heading', component_property='children'), [dash.dependencies.Input('incident_map', 'n_clicks'),
