def render_example6():
# Generate some in-memory data.
bermuda = dlx.dicts_to_geojson([dict(lat=32.299507, lon=-64.790337)])
biosfera = dlx.geojson_to_geobuf(
dlx.dicts_to_geojson([dict(lat=29.015, lon=-118.271)]))
with open("data/KCNeighborhood.json", 'r') as f:
statesData = json.load(f)
return [
dl.Map(
center=[39, -98],
zoom=4,
children=[
dl.TileLayer(),
dl.GeoJSON(data=bermuda), # in-memory geojson (slowest option)
dl.GeoJSON(
data=biosfera, format="geobuf"
), # in-memory geobuf (smaller payload than geojson)
dl.GeoJSON(
data=statesData,
id="capitals"), # geojson resource (faster than in-memory)
],
style={
'width': '100%',
'height': '50vh',
'margin': "auto",
"display": "block"
},
id="map"),
html.Div(id="state"),
html.Div(id="capital")
]
def build_geojson_counties(color_prop=None):
id = 'geojson_counties'
url = ASSETS['geojson_counties']
zoomToBounds = False
zoomToBoundsOnClick = False
if color_prop:
hideout = dict(classes=PROPERTIES[color_prop]['classes'],
color_prop=color_prop,
colorscale=PROPERTIES[color_prop]['color_scale'],
style=GEOJSON_COUNTIES_STYLE_1)
# hoverStyle = GEOJSON_HOVER_STYLE_2
hoverStyle = None
options = dict(style=dlx.choropleth.style)
else:
hideout = dict()
# hoverStyle = GEOJSON_HOVER_STYLE_1
hoverStyle = None
options = dict(style=GEOJSON_COUNTIES_STYLE_1)
return dl.GeoJSON(hideout=hideout,
id=id,
hoverStyle=hoverStyle,
options=options,
url=url,
zoomToBounds=zoomToBounds,
zoomToBoundsOnClick=zoomToBoundsOnClick)
def get_map_panel_zip_layout():
classes = [0, 100, 500, 1000, 2000, 5000, 10000, 20000]
colorscale = [
"#FFEDA0",
"#FED976",
"#FEB24C",
"#FD8D3C",
"#FC4E2A",
"#E31A1C",
"#BD0026",
"#800026",
]
style = {
"weight": 2,
"opacity": 1,
"color": "white",
"dashArray": 3,
"fillOpacity": 0.7,
}
ctg = ["{}+".format(cls, classes[i + 1]) for i, cls in enumerate(classes[:-1])] + [
"{}+".format(classes[-1])
]
colorbar = dlx.categorical_colorbar(
categories=ctg,
colorscale=colorscale,
width=400,
height=30,
position="bottomright",
)
ns = Namespace("dlx", "choropleth")
zip_geojson = dl.GeoJSON(
data=None, # url to geojson file
options=dict(style=ns("style")), # how to style each polygon
zoomToBounds=False, # when true, zooms to bounds when data changes (e.g. on load)
zoomToBoundsOnClick=True, # when true, zooms to bounds of feature (e.g. polygon) on click
hoverStyle=arrow_function(
dict(weight=5, color="#666", dashArray="")
), # style applied on hover
hideout=dict(
colorscale=colorscale, classes=classes, style=style, colorProp="Amount"
),
id="zips-geojson",
)
stl_center = [38.648, -90.253]
city_map_style = {"height": "100vh", "margin": "none", "display": "block"}
city_map = html.Div(
dl.Map(
children=[get_base_toner_tile_layer(), zip_geojson, colorbar],
zoom=12,
center=stl_center,
),
style=city_map_style,
id="map",
)
map_panel_style = {"width": "100%", "height": "100vh", "display": "block"}
map_panel = html.Div(id="map-panel", children=city_map, style=map_panel_style)
return map_panel
def get_map(run_by, paved_status, lighted_status, spaces_range):
df = lots[(lots["operator"].isin(run_by))
& (lots["is_paved"].isin(paved_status)) &
(lots["light"].isin(lighted_status)) &
(lots["available_spaces"] >= spaces_range[0]) &
(lots["available_spaces"] <= spaces_range[1])]
titles = df[df.columns[0]]
lat = df[df.columns[7]]
long = df[df.columns[8]]
avg_lat = sum(lat) / len(lat)
avg_long = sum(long) / len(long)
print(len(df))
points = []
for i in range(0, len(lat) - 1):
points.append(dict(lat=lat[i], lon=long[i]))
return dl.Map(center=[avg_lat, avg_long],
zoom=7,
children=[
dl.TileLayer(),
dl.GeoJSON(data=dlx.dicts_to_geojson(points))
],
style={
'width': '100%',
'height': '50vh',
'margin': "auto",
"display": "block"
},
id="map-object")
def build_geojson_states():
id = 'geojson_states'
options = dict(style=GEOJSON_STATES_STYLE_1)
url = ASSETS['geojson_states']
zoomToBounds = False
zoomToBoundsOnClick = False
return dl.GeoJSON(id=id,
options=options,
zoomToBounds=zoomToBounds,
zoomToBoundsOnClick=zoomToBoundsOnClick,
url=url)
def get_neighborhood_geojson():
ns = Namespace("dlx", "choropleth")
neighborhoods_geobuf_path = "static/geobuf/neighborhoods-and-municipalities.pbf"
neighborhoods_geojson = dl.GeoJSON(
format="geobuf",
options=dict(style=ns("style")),
hoverStyle=arrow_function(dict(weight=5, color="#666", dashArray="")),
hideout=bootstrap_stuff.build_choropleth_hideout(
"total_monetary_donations"),
id="neighborhood-geojson",
)
return neighborhoods_geojson
def get_precinct_geojson():
ns = Namespace("dlx", "choropleth")
precincts_geobuf_path = "dsadata/static/geobuf/stl-city-and-county-precincts.pbf"
precincts_geojson = dl.GeoJSON(
format="geobuf",
options=dict(style=ns("style")),
hoverStyle=arrow_function(dict(weight=5, color="#666", dashArray="")),
hideout=bootstrap_stuff.build_choropleth_hideout(
"total_monetary_donations"),
id="precincts-geojson",
)
return precincts_geojson
def get_neighborhood_geojson():
ns = Namespace("dlx", "choropleth")
neighborhoods_geojson = dl.GeoJSON(
format="geobuf",
options=dict(style=ns("style")),
hoverStyle=arrow_function(dict(weight=5, color="#666", dashArray="")),
zoomToBoundsOnClick=
False, # when true, zooms to bounds of feature (e.g. polygon) on click
hideout=bootstrap_stuff.build_choropleth_hideout(
"total_monetary_donations"),
id="neighborhood-geojson",
)
return neighborhoods_geojson
def build_departments_geojson():
"""
This function reads the departments.geojson file in the /data folder thanks to the json module
and returns an interactive dl.GeoJSON object containing its information, to be displayed on the map.
"""
# We plug departments in a Dash Leaflet GeoJSON object that will be added to the map
geojson = dl.GeoJSON(data=departments,
id='geojson_departments',
zoomToBoundsOnClick=False,
hoverStyle=dict(weight=3, color='#666', dashArray=''))
# We simply return the GeoJSON object for now
return geojson
def get_precinct_overlay():
# original file was wrong hand rule, whis one was rewound with geojson-rewind:
precinct_geojson_path = "data/geojson/stl-city/precincts_rw.geojson"
with open(precinct_geojson_path) as read_file:
precinct_geojson = json.load(read_file)
precincts = dl.GeoJSON(
data=precinct_geojson,
options=dict(style=dict(color="blue", fillOpacity=0.5)),
zoomToBoundsOnClick=True,
hoverStyle=arrow_function(dict(weight=4, fillOpacity=0.2, dashArray="")),
id="precincts-geojson",
)
precinct_overlay = dl.Overlay(precincts, name="precincts", checked=False)
return precinct_overlay
def geojson(data, *args, style, **kwargs):
feature_id = "id"
# If id missing and/or not unique, a new id (this list index) is assigned (this is NOT recommended).
if not _validate_feature_ids(data):
feature_id = "dash_id"
for i, f in enumerate(data["features"]):
f[feature_id] = i
# Setup style.
feature_style = {f[feature_id]: style(f) for f in data["features"]}
return dl.GeoJSON(*args,
data=data,
featureStyle=feature_style,
featureId=feature_id,
**kwargs)
def get_precinct_overlay():
# original file was wrong hand rule, whis one was rewound with geojson-rewind:
precinct_pbf_url = "dsadata/static/geobuf/stl-city-precincts.pbf"
ns = Namespace("dlx", "choropleth")
precincts = dl.GeoJSON(
url=precinct_pbf_url,
format="geobuf",
options=dict(style=ns("style")),
zoomToBoundsOnClick=True,
hoverStyle=arrow_function(dict(weight=4, fillOpacity=0.2,
dashArray="")),
hideout=bootstrap_stuff.build_choropleth_hideout("total_donations"),
id="precincts-geojson",
)
precinct_overlay = dl.Overlay(precincts, name="precincts", checked=False)
return precinct_overlay
def get_zip_geojson():
ns = Namespace("dlx", "choropleth")
zip_geojson = dl.GeoJSON(
format="geobuf",
options=dict(style=ns("style")), # how to style each polygon
# options=dict(style=dict(color="blue")),
zoomToBounds=
False, # when true, zooms to bounds when data changes (e.g. on load)
zoomToBoundsOnClick=
False, # when true, zooms to bounds of feature (e.g. polygon) on click
hoverStyle=arrow_function(dict(weight=5, color="#666", dashArray="")),
hideout=bootstrap_stuff.build_choropleth_hideout(
"total_monetary_donations"),
id="zip-geojson",
)
return zip_geojson
def build_departments_geojson():
# We fetch the json file online and store it in the departments variable
with open(
Path(__file__).parent.joinpath('data', 'departements.geojson'),
'rb') as response:
departments = json.load(response)
# We plug departments in a Dash Leaflet GeoJSON object that will be added to the map
geojson = dl.GeoJSON(data=departments,
id='geojson_departments',
zoomToBoundsOnClick=True,
hoverStyle=dict(weight=3, color='#666', dashArray=''))
# We simply return the GeoJSON object for now
return geojson
def build_risks_geojson_and_colorbar(opacity_level=0.75):
"""
This function creates the main attributes specific to the choropleth map.
It simply takes as input an opacity level, which defaults to 0.75, for coloring the departments.
It returns:
- a dl.GeoJSON object that allows to displays the departments' boundaries and respective risk score categories;
- a colorbar object that distinguishes, as shades of yellow and red, 8 categories of risk score from 0 to 1.
"""
# First step is to prepare the choropleth map by building the color scale corresponding to score risks
# To define 8 risk levels between 0 and 1, we need to choose 9 floats that will serve as borders
classes = np.linspace(0, 1, 9)
# We choose 8 shades of yellow and red to define our color scale
colorscale = ['#FFEDA0', '#FED976', '#FEB24C', '#FD8D3C', '#FC4E2A', '#E31A1C', '#BD0026', '#800026']
# We create a 'categories' object of the right format, then plug it into the Dash Leaflet
# function instantiating the colorbar
ctg = ["{}+".format(round(cls, 2)) for i, cls in enumerate(classes[:-1])]
colorbar = dlx.categorical_colorbar(categories=ctg, colorscale=colorscale, width=500, height=30,
position="bottomleft")
# We define the style of department delimitations on the map
# (opacity and color of borders, opacity of color backgrounds...)
scale_style = dict(weight=2, opacity=0.9, color='white', dashArray='3', fillOpacity=opacity_level)
# We finally instantiate the dl.GeoJSON object that will be attributed to the "Niveaux de Risque" map
geojson = dl.GeoJSON(data=departments,
id='geojson_risks',
zoomToBoundsOnClick=True,
hoverStyle=dict(weight=3,
color='#666',
dashArray=''),
hideout=dict(colorscale=colorscale,
classes=classes,
style=scale_style,
color_prop='score'),
options=dict(style=dlx.choropleth.style))
return geojson, colorbar
def get_zip_overlay(mec_df, candidate):
if candidate is not None:
cand_df = contrib.sum_funds_by_zip(cand_zip_df)
else:
df = cand_zip_df[cand_zip_df[" MECID"] == candidate]
# original file was wrong hand rule, whis one was rewound with geojson-rewind:
zip_geojson_path = "data/geojson/stl-region-zip_rw.geojson"
gdf = gpd.read_file(zip_geojson_path)
gdf = gdf.merge(cand_zip_df, left_on="ZCTA5CE10", right_on="ZIP5")
if candidate is not None:
df = contrib.sum_funds_by_zip(cand_zip_df)
else:
df = cand_zip_df[cand_zip_df[" MECID"] == candidate]
with open(zip_geojson_path) as read_file:
zip_geojson = json.load(read_file)
zips = dl.GeoJSON(
data=zip_geojson,
options=dict(style=dict(color="purple", fillOpacity=0.5)),
zoomToBoundsOnClick=True,
hoverStyle=arrow_function(dict(weight=4, fillOpacity=0.2, dashArray="")),
id="zips-geojson",
)
zip_overlay = dl.Overlay(zips, name="zips", checked=True)
return zip_overlay
coords_list = []
# Switch lat/lon, and append river coords to coords_list
for coords in river_coords:
points = []
for point in coords:
rev_point = point[::-1]
points.append(rev_point)
coords_list.append(points)
# Transform gridded data in right style
grid_geo = dl.GeoJSON(data=grid,
id="grid_geojson",
options=dict(hoverStyle=dict(weight=5,
color='#666',
dashArray=''),
zoomToBoundsOnClick=False,
style=dict(fill=False,
weight=1,
opacity=1,
color='white',
dashArray='3',
fillOpacity=0.1)))
districts_geo = dl.GeoJSON(data=admin_boundaries,
id="districts_geojson",
options=dict(hoverStyle=dict(weight=5,
color='#666',
dashArray=''),
zoomToBoundsOnClick=False,
style=dict(fill=False,
weight=1,
opacity=0.8,
color='black',
geobuf = dlx.geojson_to_geobuf(geojson)
return geobuf
# create cpa dropdown
cpas = df['cpa_name'].unique()
cpa_options = [{'label': cpa, 'value': cpa} for cpa in cpas]
dd_cpa = dcc.Dropdown(options=cpa_options, id='dd_cpa')
# set up scatter points
ns = Namespace('dlx', 'scatter')
geojson = dl.GeoJSON(
data=get_data(None),
id='geojson',
format='geobuf',
zoomToBounds=True,
cluster=True,
# clusterToLayer=ns("clusterToLayer"),
zoomToBoundsOnClick=True,
# options=dict(pointToLayer=ns('pointToLayer')),
superClusterOptions=dict(radius=150))
# hideout=dict(colorscale='Viridis', colorProp='cpa'))
# add cpa boundaries
cpa_boundaries = dl.GeoJSON(
id='rfmp',
url="/assets/rfmp4.json",
zoomToBounds=True,
hoverStyle=arrow_function(dict(weight=5, color='#666',
dashArray=''))) # must be in assets folder
# create map
className="container_title"),
html.Div(
[
dl.Map([
dl.LayersControl([
dl.BaseLayer(
dl.TileLayer(url=url_template.format(key),
attribution=attribution),
name=key,
checked=key == checked_key) for key in keys
] + [
dl.LayerGroup(id="layer"),
dl.GeoJSON(
id='polygons',
options=dict(style=ns("style")),
hideout=dict(colorscale=colorscale,
classes=classes,
style=style,
colorProp="index"),
)
]),
],
id="map-graph",
zoom=4,
center=(39, -100)),
html.Div(
[
html.H5("Average Speed",
style={"color": "#191a1a"}),
dcc.Dropdown(id='average-speed',
options=[{
'label': i,
r"C:\Users\julien_schroder\Desktop\JM_FinaleMaps_Repo\Routes4326.geojson"
) as g:
routes = geojson.load(g)
dRoutes = FeatureCollection([f for f in routes['features']])
dPoints = FeatureCollection([f for f in points['features']])
biosfera = dlx.geojson_to_geobuf(
dlx.dicts_to_geojson([dict(lat=29.015, lon=-118.271)]))
app.layout = html.Div([
dl.Map(
center=[39, -98],
zoom=4,
children=[
dl.TileLayer(),
dl.GeoJSON(data=dPoints, id='capitals',
cluster=True), # in-memory geojson (slowest option)
dl.GeoJSON(data=dRoutes, id='states'
), # in-memory geobuf (smaller payload than geojson)
],
style={
'width': '100%',
'height': '100vh',
'margin': "auto",
"display": "block"
},
id="map"),
html.Div(id="state"),
html.Div(id="capital")
])
du.get_col("Amount", year): "Amount",
du.get_col("Per Capita", year): "Per Capita",
du.get_col("Per Student", year): "Per Student",
})
# leaflet map: Create geojson.
geojson = dl.GeoJSON(
id="geojson",
format="geobuf",
zoomToBounds=True, # when true, zooms to bounds when data changes
cluster=True, # when true, data are clustered
clusterToLayer=dlx.scatter.cluster_to_layer, # how to draw clusters
zoomToBoundsOnClick=
True, # when true, zooms to bounds of feature (e.g. cluster) on click
options=dict(
pointToLayer=dlx.scatter.point_to_layer,
onEachFeature="window.dash_props.module.on_each_feature",
), # popup in callback, how to draw points
superClusterOptions=dict(radius=150), # adjust cluster size
hideout={},
)
local_map = dl.Map(
[
dl.TileLayer(
url=
"https://stamen-tiles-{s}.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png"
),
geojson,
],
value=default_state,
id="dd_state",
clearable=False)
# endregion
minmax = get_minmax(default_state)
# Create geojson.
ns = Namespace("dlx", "scatter")
geojson = dl.GeoJSON(
data=get_data(default_state, [2015, 2020]),
id="geojson",
format="geobuf",
zoomToBounds=True, # when true, zooms to bounds when data changes
cluster=True, # when true, data are clustered
clusterToLayer=ns("clusterToLayer"), # how to draw clusters
zoomToBoundsOnClick=
True, # when true, zooms to bounds of feature (e.g. cluster) on click
options=dict(pointToLayer=ns("pointToLayer")), # how to draw points
superClusterOptions=dict(radius=150), # adjust cluster size
hideout=dict(colorscale=csc_map[default_csc],
colorProp=color_prop,
**minmax))
# Create a colorbar.
colorbar = dl.Colorbar(colorscale=csc_map[default_csc],
id="colorbar",
width=20,
height=150,
**minmax)
# Create the app.
chroma = "https://cdnjs.cloudflare.com/ajax/libs/chroma-js/2.1.0/chroma.min.js"
external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
def serve_layout():
dd_variable = dcc.Dropdown(options=variable_options,
value=default_variable, id="dd_variable", clearable=False)
minmax = get_minmax(default_variable)
# # Create a colorbar.
colorbar = dl.Colorbar(
colorscale=csc_map[default_csc], id="colorbar", width=20, height=150, **minmax)
geojson = dl.GeoJSON(data=get_data(default_variable), id="geojson",
format='geobuf',
cluster=True, # when true, data are clustered
# how to draw clusters
clusterToLayer=ns("clusterToLayer"),
# how to draw points
options=dict(pointToLayer=ns("pointToLayer")),
superClusterOptions=dict(radius=50), # adjust cluster size
hideout=dict(colorscale=csc_map[default_csc],
colorProp=default_variable, **minmax))
times = pd.date_range(start=pd.to_datetime('now', utc=True).round('15min') - pd.Timedelta('2hours'),
end=pd.to_datetime('now', utc=True).round(
'15min') - pd.Timedelta('15min'),
freq='5min')
latest = times[-1].strftime('%Y-%m-%dT%H:%M:00.000Z')
numdate = [x for x in range(len(times))]
marks = {numd: date.strftime('%H:%M')
for numd, date in zip(numdate, times)}
slider = dcc.Slider(id='time_slider', min=numdate[0],
max=numdate[-1],
value=numdate[-1],
marks=marks)
layout = html.Div([
dl.Map([
dl.LayersControl(
[
dl.BaseLayer(dl.TileLayer(url=mapURL, attribution=attribution,
tileSize=512, zoomOffset=-1), name='map', checked=True),
dl.Overlay(dl.WMSTileLayer(url="https://maps.dwd.de/geoserver/ows?",
layers="dwd:SAT_EU_RGB",
format="image/png",
transparent=True, opacity=0.6,
version='1.3.0',
detectRetina=True), name='sat eu', checked=True),
dl.Overlay(dl.WMSTileLayer(id='radar_it',
url="http://www.protezionecivile.gov.it/geowebcache/service/wms?tiled=True&time=%s" % latest,
layers="radar:vmi",
transparent=True,
format="image/png",
opacity=1.0,
version='1.1.1'),
name='radar IT', checked=True),
dl.Overlay([geojson, colorbar], name='obs', checked=True)
]),
geojson_countries,
], center=[41, 12], zoom=6),
html.Div(id='date-div', style={'display': 'none'},
children=times.strftime('%Y-%m-%dT%H:%M:00.000Z')),
html.Div([slider],
style={"position": "absolute", "bottom": "20px",
"left": "10px", "z-index": "1000", "width": "800px",
"background-color": 'rgba(1, 1, 1, 0.3)'}),
html.Div([dd_variable],
style={"position": "absolute", "top": "300px", "right": "16px", "z-index": "1000", "width": "100px"})
], style={'width': '100%', 'height': '90vh', 'margin': "auto", "display": "block", "position": "relative"})
return layout
default_variable = "temperature"
variable_options = [
{'label': 'Temp.', 'value': 'temperature'},
{'label': 'MSLP', 'value': 'smlp'},
{'label': 'Hum.', 'value': 'rh'},
{'label': 'Wind Sp.', 'value': 'wind_speed'},
{'label': 'Wind G.', 'value': 'wind_gust'},
{'label': 'Rain', 'value': 'rain_rate'},
{'label': 'Daily Rain', 'value': 'daily_rain'},
{'label': 'Dewp', 'value': 'dew_point'},
{'label': 'Rad', 'value': 'rad'},
]
ns = Namespace("myNamespace", "mySubNamespace")
geojson_countries = dl.GeoJSON(data=statesData, id="geojson_countries",
options=dict(style=dict(weight=1, opacity=0.7, color='white', fillOpacity=0)))
# Create the app.
chroma = "https://cdnjs.cloudflare.com/ajax/libs/chroma-js/2.1.0/chroma.min.js"
app = Dash(__name__,
external_scripts=[chroma],
prevent_initial_callbacks=True,
url_base_pathname='/weathermap-it/')
server = app.server
cache = Cache(server, config={'CACHE_TYPE': 'filesystem',
'CACHE_DIR': '/tmp'})
@cache.memoize(900)
className="header",
),
# MAP
html.Div(
children=[
dl.Map(center=[lat_center, long_center],
zoom=14,
children=[
dl.TileLayer(url=url,
attribution=attribution,
maxZoom=20),
dl.GeoJSON(
data=data,
id="unique-squirrel-id",
format="geobuf",
cluster=True,
zoomToBoundsOnClick=True,
superClusterOptions={"radius": 50},
options=dict(pointToLayer=ns("pointToLayer"))),
],
className="squirrel-map",
style={'display': 'block'},
id="map"),
],
className="squirrel-map-container",
),
# SQUIRREL INFO
html.Div(id="squirrel-facts"),
# invisible sound containers
html.Div(id="placeholder1", style={"display": "none"}),
from dash.dependencies import Input, Output
from dash_transcrypt import inject_js, module_to_props
# Create some markers.
points = [
dict(lat=55.5 + random.random(),
lon=9.5 + random.random(),
value=random.random()) for i in range(100)
]
data = dlx.dicts_to_geojson(points)
# Create geojson.
js = module_to_props(rjs) # compiles the js
geojson = dl.GeoJSON(
data=data,
options=dict(pointToLayer=rjs.point_to_layer), # pass function as prop
hideout=dict(scale=10),
id="geojson") # pass variables to function
# Create the app.
app = dash.Dash()
app.layout = html.Div([
dl.Map([dl.TileLayer(), geojson],
center=(56, 10),
zoom=8,
style={'height': '50vh'}),
dcc.Slider(min=1, max=100, value=10, id="slider")
])
inject_js(app, js) # adds the js to the app
@app.callback(Output("geojson", "hideout"), [Input("slider", "value")],
dicts = df_state.to_dict('rows')
for item in dicts:
item["tooltip"] = item["city"] # bind tooltip
geojson = dlx.dicts_to_geojson(dicts, lon="lng") # convert to geojson
geobuf = dlx.geojson_to_geobuf(geojson) # convert to geobuf
with open('geobuf.pkl', 'wb') as f:
pickle.dump(geobuf, f, pickle.HIGHEST_PROTOCOL)
geojson = dl.GeoJSON(
data=geobuf,
id="geojson",
format="geobuf",
zoomToBounds=True, # when true, zooms to bounds when data changes
cluster=True, # when true, data are clustered
clusterToLayer=dlx.scatter.cluster_to_layer, # how to draw clusters
zoomToBoundsOnClick=
True, # when true, zooms to bounds of feature (e.g. cluster) on click
options=dict(
pointToLayer=dlx.scatter.point_to_layer), # how to draw points
superClusterOptions=dict(radius=150),
hideout={
'colorscale': ['green'],
'color_prop': color_prop,
'min': 0,
'max': 0
})
with open('geojson.pkl', 'wb') as g:
pickle.dump(geojson, g, pickle.HIGHEST_PROTOCOL)
circles = []
for idx, point in enumerate(points):
circle = {
"key": str(idx),
"properties": {
"radius": 10
},
"geometry": {
"type": "Point",
"coordinates": (center + point).tolist()
}
}
circles.append(circle)
circles = json.dumps(circles)
app = dash.Dash()
app.layout = html.Div([
dl.Map(style={
'width': '1000px',
'height': '500px'
},
center=center,
zoom=10,
children=[dl.TileLayer(), dl.GeoJSON(data=circles)])
])
if __name__ == '__main__':
app.run_server(debug=True, port=8053)
quantiles = [int(n) for n in quantiles.values]
classes = quantiles
colorscale = ['#FED976', '#FEB24C', '#FD8D3C', '#FC4E2A', '#800026']
style = dict(weight=2, opacity=1, color='white', dashArray='3', fillOpacity = 0.7)
# Create colorbar.
ctg = ["{}+".format(cls, classes[i + 1]) for i, cls in enumerate(classes[:-1])] + ["{}+".format(classes[-1])]
colorbar = dlx.categorical_colorbar(categories=ctg, colorscale=colorscale, width=300, height=30, position="bottomleft")
ns = Namespace("dlx", "choropleth")
### Define layouts
geojson = dl.GeoJSON(
data = json_data,
options=dict(style=ns("style")),
zoomToBoundsOnClick = False,
hoverStyle=arrow_function(dict(weight=2, color='#666', dashArray='', fillOpacity=0.2)), # style applied on hover
hideout=dict(colorscale=colorscale, classes=classes, style=style, colorProp = "cases"),
id = "geojson")
cont = dbc.Card(
[
dbc.CardImg(src = "assets/form.svg", top = True, className = "card-img"),
dbc.CardBody(
[
html.P(
"Casos: " + str(conf.return_data_size())
)
20: "20",
30: "30",
40: "40",
50: "50"
},
disabled=disable_odlines(default_zoomed),
id="sl_line",
)
# Create geojson foreground.
style_hover = {"weight": 5, "color": "#666", "dashArray": ""}
ns = Namespace("dlx", "choropleth")
geojson_fg = dl.GeoJSON(
url=get_url_fg(default_zoomed, default_region, default_name),
format="geobuf",
options=dict(style=ns("style")), # how to style each polygon
hideout=get_hideout(default_case),
zoomToBoundsOnClick=True, # when true, zooms to bounds of feature on click
hoverStyle=arrow_function(style_hover),
id="geojson_fg")
# Create geojson background.
style_bg = {
"weight": 2,
"opacity": 1,
"color": "white",
"dashArray": 3,
"fillOpacity": 0.5
}
geojson_bg = dl.GeoJSON(
url=get_url_bg(default_zoomed, default_region, default_name),
format="geobuf",
