# view a 2D-3D map of the data, shift key for 3D
'## Geo Data at %sh' % hour
midpoint = (np.average(data["lat"]), np.average(data["lon"]))
st.write(
pdk.Deck(
map_style="mapbox://styles/mapbox/light-v9",
initial_view_state={
"latitude": midpoint[0],
"longitude": midpoint[1],
"zoom": 11,
"pitch": 50,
},
layers=[
pdk.Layer(
"HexagonLayer",
data=data,
get_position=["lon", "lat"],
radius=100,
elevation_scale=4,
elevation_range=[0, 1000],
pickable=True,
extruded=True,
),
],
))
if st.checkbox('Show Raw Data'):
'## Geo Data at %sh' % hour, data # displays the comment and the data
"""
import pydeck as pdk
import pandas as pd
CPU_GRID_LAYER_DATA = ("https://raw.githubusercontent.com/uber-common/"
"deck.gl-data/master/website/sf-bike-parking.json")
df = pd.read_json(CPU_GRID_LAYER_DATA)
# Define a layer to display on a map
layer = pdk.Layer(
"GridLayer",
df,
pickable=True,
extruded=True,
cell_size=200,
elevation_scale=4,
get_position="COORDINATES",
)
view_state = pdk.ViewState(latitude=37.7749295,
longitude=-122.4194155,
zoom=11,
bearing=0,
pitch=45)
# Render
r = pdk.Deck(
layers=[layer],
initial_view_state=view_state,
ICON_URL = "https://upload.wikimedia.org/wikipedia/commons/c/c4/Projet_bi%C3%A8re_logo_v2.png"
icon_data = {
# Icon from Wikimedia, used the Creative Commons Attribution-Share Alike 3.0
# Unported, 2.5 Generic, 2.0 Generic and 1.0 Generic licenses
"url": ICON_URL,
"width": 242,
"height": 242,
"anchorY": 242,
}
data = pd.read_json(DATA_URL)
data["icon_data"] = None
for i in data.index:
data["icon_data"][i] = icon_data
view_state = pdk.data_utils.compute_view(data[["lon", "lat"]], 0.1)
icon_layer = pdk.Layer(
type="IconLayer",
data=data,
get_icon="icon_data",
get_size=4,
size_scale=15,
get_position=["lon", "lat"],
pickable=True,
)
r = pdk.Deck(layers=[icon_layer], initial_view_state=view_state, tooltip={"text": "{tags}"})
r.to_html("icon_layer.html")
mapbox_api_token = os.getenv("MAPBOX_ACCESS_TOKEN")
# 2014 locations of car accidents in the UK
UK_ACCIDENTS_DATA = (
"https://raw.githubusercontent.com/uber-common/"
"deck.gl-data/master/examples/3d-heatmap/heatmap-data.csv"
)
# Define a layer to display on a map
layer = pdk.Layer(
"HexagonLayer",
UK_ACCIDENTS_DATA,
get_position=["lng", "lat"],
auto_highlight=True,
elevation_scale=50,
pickable=True,
elevation_range=[0, 3000],
extruded=True,
coverage=1,
)
# Set the viewport location
view_state = pdk.ViewState(
longitude=-1.415,
latitude=52.2323,
zoom=6,
min_zoom=5,
max_zoom=15,
pitch=40.5,
bearing=-27.36,
df = df[df['LAT_DESTINO'] < -33]
st.write(df)
df = df[df['NUM_EST'] < 23]
num_est = st.slider("Cantidad de estudiantes traspasados entre colegios", 1,
30)
GREEN_RGB = [0, 255, 0, 40]
RED_RGB = [240, 100, 0, 40]
arc_layer = pydeck.Layer(
"ArcLayer",
data=df.query("NUM_EST >= @num_est"),
get_width="NUM_EST * 2",
get_source_position=["LON_ORIGEN", "LAT_ORIGEN"],
get_target_position=["LON_DESTINO", "LAT_DESTINO"],
get_tilt=15,
get_source_color=RED_RGB,
get_target_color=GREEN_RGB,
pickable=True,
auto_highlight=True,
)
view_state = pydeck.ViewState(
latitude=-33.4372,
longitude=-70.6506,
bearing=90,
pitch=85,
zoom=8,
)
TOOLTIP_TEXT = {
[204, 235, 197],
[168, 221, 181],
[123, 204, 196],
[67, 162, 202],
[8, 104, 172],
]
view = pdk.data_utils.compute_view(cattle_df[["lng", "lat"]])
view.zoom = 6
cattle = pdk.Layer(
"HeatmapLayer",
data=cattle_df,
opacity=0.9,
get_position=["lng", "lat"],
aggregation='"MEAN"',
color_range=COLOR_BREWER_BLUE_SCALE,
threshold=1,
get_weight="weight",
pickable=True,
)
poultry = pdk.Layer(
"HeatmapLayer",
data=poultry_df,
opacity=0.9,
get_position=["lng", "lat"],
threshold=0.75,
aggregation='"MEAN"',
get_weight="weight",
pickable=True,
def get_map_layers(df):
df_return = pd.DataFrame(df["living_state"].value_counts())
df_return = pd.DataFrame({
"estados": df_return.index,
"total": df_return.living_state
})
# coordenadas dos estados, fonte: https://gist.github.com/ricardobeat/674646
df_return['lat'] = df_return.estados.map({
"AC": -8.77,
"AL": -9.71,
"AM": -3.07,
"AP": 1.41,
"BA": -12.96,
"CE": -3.71,
"DF": -15.83,
"Espírito Santo (ES)": -19.19,
"GO": -16.64,
"MA": -2.55,
"MT": -12.64,
"MS": -20.51,
"Minas Gerais (MG)": -18.10,
"PA": -5.53,
"PB": -7.06,
"Paraná (PR)": -24.89,
"PE": -8.28,
"PI": -8.28,
"Rio de Janeiro (RJ)": -22.84,
"RN": -5.22,
"RO": -11.22,
"Rio Grande do Sul (RS)": -30.01,
"RR": 1.89,
"Santa Catarina (SC)": -27.33,
"SE": -10.90,
"São Paulo (SP)": -23.55,
"TO": -10.25
})
df_return['lon'] = df_return.estados.map({
"AC": -70.55,
"AL": -35.73,
"AM": -61.66,
"AP": -51.77,
"BA": -38.51,
"CE": -38.54,
"DF": -47.86,
"Espírito Santo (ES)": -40.34,
"GO": -49.31,
"MA": -44.30,
"MT": -55.42,
"MS": -54.54,
"Minas Gerais (MG)": -44.38,
"PA": -52.29,
"PB": -35.55,
"Paraná (PR)": -51.55,
"PE": -35.07,
"PI": -43.68,
"Rio de Janeiro (RJ)": -43.15,
"RN": -36.52,
"RO": -62.80,
"Rio Grande do Sul (RS)": -51.22,
"RR": -61.22,
"Santa Catarina (SC)": -49.44,
"SE": -37.07,
"São Paulo (SP)": -46.64,
"TO": -48.25
})
# layer = pdk.Layer(
# 'ScatterplotLayer',
# data=df_return,
# get_position=['lon', 'lat'],
# auto_highlight=True,
# get_radius="[Total]",
# radius_scale=1.00,
# get_fill_color='[180, 0, 200, 140]',
# pickable=True,
# )
layer = pdk.Layer(
"ScatterplotLayer",
data=df_return,
get_position=["lon", "lat"],
get_color=[200, 30, 0, 160],
get_radius="[total]",
pickable=True,
radius_scale=200,
)
return layer
import pydeck
import pandas as pd
DATA_URL = "https://raw.githubusercontent.com/ajduberstein/geo_datasets/master/housing.csv"
df = pd.read_csv(DATA_URL)
view = pydeck.data_utils.compute_view(df[["lng", "lat"]])
view.pitch = 75
view.bearing = 60
column_layer = pydeck.Layer(
"ColumnLayer",
data=df,
get_position=["lng", "lat"],
get_elevation="price_per_unit_area",
elevation_scale=100,
radius=50,
get_fill_color=["mrt_distance * 10", "mrt_distance", "mrt_distance * 10", 140],
pickable=True,
auto_highlight=True,
)
tooltip = {
"html": "<b>{mrt_distance}</b> meters away from an MRT station, costs <b>{price_per_unit_area}</b> NTD/sqm",
"style": {"background": "grey", "color": "white", "font-family": '"Helvetica Neue", Arial', "z-index": "10000"},
}
r = pydeck.Deck(
column_layer, initial_view_state=view, tooltip=tooltip, map_style="mapbox://styles/mapbox/satellite-v9",
)
st.write(
pdk.Deck(
map_style='mapbox://styles/mapbox/light-v9',
initial_view_state={
'latitude': midpoint[0],
'longitude': midpoint[1],
'zoom': 11,
'pitch': 50,
},
layers=[
pdk.Layer('HexagonLayer',
data=data[['date/time', 'latitude', 'longitude']],
get_position=['longitude', 'latitude'],
auto_highlight=True,
radius=100,
extruded=True,
pickable=True,
elevation_scale=4,
elevation_range=[0, 1000]),
],
))
st.subheader('Breakdown by minute between %i:00 and %i:00' % (hour,
(hour + 1) % 24))
filtered = data[(data['date/time'].dt.hour >= hour)
& (data['date/time'].dt.hour < (hour + 1))]
hist = np.histogram(filtered['date/time'].dt.minute, bins=60, range=(0, 60))[0]
chart_data = pd.DataFrame({'minute': range(60), 'crashes': hist})
fig = px.bar(chart_data,
x='minute',
def show_feeder_visual(feeder_visual_data):
feeder_visual_data = load_feeder_data()
feeder_visual_data["icon_data"] = None
for i in feeder_visual_data.index:
feeder_visual_data["icon_data"][i] = icon_data
COLOR_RANGE = [
[1, 152, 189],
[73, 227, 206],
[216, 254, 181],
[254, 237, 177],
[254, 173, 84],
[209, 55, 78]
];
LIGHT_SETTINGS = {
"lightsPosition": [-0.144528, 49.739968, 8000, -3.807751, 54.104682, 8000],
"ambientRatio": 0.4,
"diffuseRatio": 0.6,
"specularRatio": 0.2,
"lightsStrength": [0.8, 0.0, 0.8, 0.0],
"numberOfLights": 2
};
midpoint = (np.average(feeder_visual_data["LAT"]), np.average(feeder_visual_data["LON"]))
st.write(pdk.Deck(
map_style="mapbox://styles/mapbox/light-v10",
initial_view_state={
"latitude": midpoint[0],
"longitude": midpoint[1],
"zoom": 13,
"pitch": 60,
"bearing": -27.36,
"tooltip": True,
},
layers=[
# pdk.Layer(
# type="IconLayer",
# data=feeder_details,
# get_icon="icon_data",
# get_size=4,
# size_scale=15,
# get_position=["LON", "LAT"],
# pickable=True,
#),
pdk.Layer(
"HexagonLayer",
data=feeder_visual_data[['LAT', 'LON']],
get_position=["LON", "LAT"],
auto_highlight=True,
radius=100,
elevation_scale=200,
pickable=False,
# scrollZoom=False,
elevation_range=[0, 10],
extruded=True,
coverage=1,
lightSettings=LIGHT_SETTINGS,
colorRange=COLOR_RANGE,
opacity=1,
tooltip=True,
hoverinfo='text',
),
],
))
import pydeck as pdk
from pydeck.types import String
import pandas as pd
TEXT_LAYER_DATA = "https://raw.githubusercontent.com/visgl/deck.gl-data/master/website/bart-stations.json" # noqa
df = pd.read_json(TEXT_LAYER_DATA)
# Define a layer to display on a map
layer = pdk.Layer(
"TextLayer",
df,
pickable=True,
get_position="coordinates",
get_text="name",
get_size=16,
get_color=[0, 0, 0],
get_angle=0,
# Note that string constants in pydeck are explicitly passed as strings
# This distinguishes them from columns in a data set
get_text_anchor=String("middle"),
get_alignment_baseline=String("center"),
)
# Set the viewport location
view_state = pdk.ViewState(latitude=37.7749295, longitude=-122.4194155, zoom=10, bearing=0, pitch=45)
# Render
r = pdk.Deck(
layers=[layer],
initial_view_state=view_state,
tooltip={"text": "{name}\n{address}"},
view = pdk.ViewState(
latitude=0,
longitude=0,
zoom=0.2,
)
# Create the scatter plot layer
covidLayer = pdk.Layer(
"ScatterplotLayer",
data=df,
pickable=False,
opacity=0.3,
stroked=True,
filled=True,
radius_scale=10,
radius_min_pixels=5,
radius_max_pixels=60,
line_width_min_pixels=1,
get_position=["Longitude", "Latitude"],
get_radius=metric_to_show_in_covid_Layer,
get_fill_color=[252, 136, 3],
get_line_color=[255, 0, 0],
tooltip="test test",
)
# Create the deck.gl map
r = pdk.Deck(
layers=[covidLayer],
initial_view_state=view,
map_style="mapbox://styles/mapbox/light-v10",
)
return [10, 230, 120]
return [230, 158, 10]
df["color"] = df["primary_fuel"].apply(is_green)
view_state = pdk.ViewState(latitude=51.47, longitude=0.45, zoom=2, min_zoom=2)
# Set height and width variables
view = pdk.View(type="_GlobeView", controller=True, width=1000, height=700)
layers = [
pdk.Layer(
"GeoJsonLayer",
id="base-map",
data=COUNTRIES,
stroked=False,
filled=True,
get_fill_color=[200, 200, 200],
),
pdk.Layer(
"ColumnLayer",
id="power-plant",
data=df,
get_elevation="capacity_mw",
get_position=["longitude", "latitude"],
elevation_scale=100,
pickable=True,
auto_highlight=True,
radius=20000,
get_fill_color="color",
),
SCREEN_GRID_LAYER_DATA = (
"https://raw.githubusercontent.com/visgl/deck.gl-data/master/website/sf-bike-parking.json" # noqa
)
df = pd.read_json(SCREEN_GRID_LAYER_DATA)
# Define a layer to display on a map
layer = pdk.Layer(
"ScreenGridLayer",
df,
pickable=False,
opacity=0.8,
cell_size_pixels=50,
color_range=[
[0, 25, 0, 25],
[0, 85, 0, 85],
[0, 127, 0, 127],
[0, 170, 0, 170],
[0, 190, 0, 190],
[0, 255, 0, 255],
],
get_position="COORDINATES",
get_weight="SPACES",
)
# Set the viewport location
view_state = pdk.ViewState(latitude=37.7749295,
longitude=-122.4194155,
zoom=11,
bearing=0,
pitch=0)
i = '01-Sep'
elif(i == '10-19'):
i = 'Oct-19'
data = data[data['Number of Volunteers'].str.contains(i)]
# CHART LAYOUT
row2_1, row2_2 = st.beta_columns((2,2))
# Define a layer to display on a map
layer = pdk.Layer(
"HexagonLayer",
data[['lng', 'lat']],
get_position=["lng", "lat"],
auto_highlight=True,
elevation_scale=50,
pickable=True,
elevation_range=[100, 3000],
extruded=True,
coverage=1,
)
view_state = pdk.ViewState(longitude=-6.6564, latitude=53.6055, zoom=6, min_zoom=5, max_zoom=15, pitch=40.5, bearing=-27.36)
def map(data):
st.write(pdk.Deck(
map_style="mapbox://styles/mapbox/light-v9",
initial_view_state={"latitude": 53.6055, "longitude": -6.6564, "zoom": 6, "pitch": 50,},
layers=[
pdk.Layer(
"HexagonLayer",
"@@type": "LightingEffect",
"shadowColor": [0, 0, 0, 0.5],
"ambientLight": ambient_light,
"directionalLights": [sunlight],
}
view_state = pdk.ViewState(
**{"latitude": 49.254, "longitude": -123.13, "zoom": 11, "maxZoom": 16, "pitch": 45, "bearing": 0}
)
LAND_COVER = [[[-123.0, 49.196], [-123.0, 49.324], [-123.306, 49.324], [-123.306, 49.196]]]
polygon_layer = pdk.Layer(
"PolygonLayer",
LAND_COVER,
stroked=False,
# processes the data as a flat longitude-latitude pair
get_polygon="-",
get_fill_color=[0, 0, 0, 20],
)
polygon_layer = pdk.Layer(
"PolygonLayer",
df,
id="geojson",
opacity=0.8,
stroked=False,
get_polygon="coordinates",
filled=True,
extruded=True,
wireframe=True,
get_elevation="elevation",
# Severity of attacks
st.write(
pdk.Deck(
map_style="mapbox://styles/mapbox/light-v9",
layers=[
pdk.Layer(
"ScatterplotLayer",
data=map_data,
get_position=["longitude", "latitude"],
pickable=False,
opacity=0.4,
stroked=True,
filled=True,
radius_scale=100,
radius_min_pixels=4,
radius_max_pixels=40,
line_width_min_pixels=0.5,
get_radius='ncasualty',
get_fill_color=[252, 136, 3],
get_line_color=[255, 0, 0],
tooltip="test test",
),
],
))
st.subheader(f'Map of terrorist activities in {year}')
if st.checkbox('Show sample raw data'):
st.write(map_data[0:10])
# Key takeaways
midpoint = (np.average(data['latitude']), np.average(data['longitude']))
st.write(
pdk.Deck(
map_style="mapbox://styles/mapbox/light-v9",
initial_view_state={
"latitude": midpoint[0],
"longitude": midpoint[1],
"zoom": 11,
"pitch": 50,
},
layers=[
pdk.Layer(
"HexagonLayer",
data=data[["date/time", "latitude", "longitude"]],
get_position=['longitude', 'latitude'],
radius=100,
extruded=True,
pickable=True,
elevation_scale=4,
elevation_range=[0, 1000],
),
],
))
st.subheader("Breakdown by minute between %i:00 and %i:00" % (hour,
(hour + 1) % 24))
filtered = data[(data['date/time'].dt.hour >= hour)
& (data['date/time'].dt.hour < (hour + 1))]
hist = np.histogram(filtered['date/time'].dt.minute, bins=60, range=(0, 60))[0]
chart_data = pd.DataFrame({'minute': range(60), 'crashes': hist})
fig = px.bar(chart_data,
x='minute',
st.write(pdk.Deck(
map_style="mapbox://styles/mapbox/light-v10",
initial_view_state={
"latitude":midpoint[0],
"longitude":midpoint[1],
"zoom":11,
"pitch":30,
},
layers=[
pdk.Layer(
"HexagonLayer",
data=data[['time','latitude','longitude']],
get_position=["longitude","latitude"],
auto_highlight=True,
radius=100,
extruded=True,
pickable=True,
elevation_scale=4,
elevation_range=[0,1000],
),
],
))
data2=original_data
st.header("Number of crimes on a given day of the week")
def main():
st.sidebar.image(logo, use_column_width=True)
page = st.sidebar.selectbox("Escolha uma Análise", [
HOME, MODELS, DATA, PAGE_CASE_NUMBER_BR, CUM_DEATH_COUNT_BR,
PAGE_GLOBAL_CASES, MAPA, CREDITOS
])
if page == HOME:
st.header("Analizando a pandemia")
st.markdown(
"""Neste site buscamos trazer até você os números da epidemia, a medida que se revelam,
mas também um olhar analítico, capaz de desvelar a dinâmica do processo de transmissão do vírus SARS-Cov-2
por meio de modelos matemáticos, análises estatísticas e visualização de informação.
Pelo *painel à esquerda* você pode ***navegar entre nossas análises***, as quais estaremos atualizando constantemente
daqui para frente.
## Outros Recursos de Interesse
Vamos compilar aqui também outras fontes de informação de confiança para que você possa se manter atualizado
com os últimos resultados científicos sobre a Pandemia.
* Canal [A Matemática das Epidemias](https://www.youtube.com/channel/UCZFllLoI5kB4o_6w59YVzAA?view_as=subscriber).
* Grupo MAVE: [Métodos Analíticos em Vigilância Epidemiológica](https://covid-19.procc.fiocruz.br).
## Fontes de Dados
As sguintes fontes de dados foram usadas neste projeto:
* [Brasil.io](https://brasil.io): Dados de incidência e mortalidade no Brasil
* [Johns Hopkins CSSE](https://github.com/CSSEGISandData/COVID-19): Dados de incidência e mortalidade globais.
## Softwares opensource
Várias bibliotecas opensource foram utilizadas na construção deste dashboard:
* [Streamlit](streamlit.io): Web framework voltada para ciência de dados.
* [Epimodels](https://github.com/fccoelho/epimodels): Biblioteca de modelos matemáticos para simulação de epidemias.
""")
elif page == MODELS:
st.title("Explore a dinâmica da COVID-19")
st.sidebar.markdown("### Parâmetros do modelo")
chi = st.sidebar.slider('χ, Fração de quarentenados', 0.0, 1.0, 0.7)
phi = st.sidebar.slider('φ, Taxa de Hospitalização', 0.0, 0.5, 0.01)
beta = st.sidebar.slider('β, Taxa de transmissão', 0.0, 1.0, 0.5)
rho = st.sidebar.slider('ρ, Taxa de alta dos hospitalizados:', 0.0,
1.0, 0.02)
delta = st.sidebar.slider('δ, Taxa de recuperação:', 0.0, 1.0, 0.1)
alpha = st.sidebar.slider('α, Taxa de incubação', 0.0, 10.0, .33)
mu = st.sidebar.slider('μ, Taxa de mortalidade pela COVID-19', 0.0,
1.0, .03)
p = st.slider('Fração de assintomáticos:', 0.0, 1.0, 0.75)
q = st.slider('Dia de início da Quarentena:', 0, 120, 50)
r = st.slider('duração em dias da Quarentena:', 0, 200, 10)
N = st.number_input('População em Risco:',
value=97.3e6,
max_value=200e6,
step=1e6)
st.markdown(
f"$R_0={-(beta*chi-beta)/delta:.2f}$, durante a quarentena.")
st.markdown(
f"$R_0={-(beta * 0 - beta) / delta:.2f}$, fora da quarentena.")
params = {
'chi': chi,
'phi': phi,
'beta': beta,
'rho': rho,
'delta': delta,
'alpha': alpha,
'mu': mu,
'p': p,
'q': q,
'r': r
}
traces = pd.DataFrame(data=seqiahr_model(params=params)).rename(
columns=COLUMNS)
final_traces = dashboard_models.prepare_model_data(
traces, VARIABLES, COLUMNS, N)
dashboard_models.plot_model(final_traces, q, r)
st.markdown('### Formulação do modelo')
st.write(r"""
$\frac{dS}{dt}=-\lambda[(1-\chi) S]$
$\frac{dE}{dt}= \lambda [(1-\chi) S] -\alpha E$
$\frac{dI}{dt}= (1-p)\alpha E - \delta I$
$\frac{dA}{dt}= p\alpha E -\delta A$
$\frac{dH}{dt}= \phi \delta I -(\rho+\mu) H$
$\frac{dR}{dt}= (1-\phi)\delta I +\rho H + \delta A$
$\lambda=\beta(I+A)$
$R_0 = -\frac{\beta \chi -\beta}{\delta}$
""")
elif page == DATA:
st.title('Probabilidade de Epidemia por Município ao Longo do tempo')
@st.cache
def read_video():
with open('dashboard/video_prob.mp4', 'rb') as v:
video = v.read()
return video
st.video(read_video())
st.markdown(r'''## Descrição da modelagem:
Os municípios brasileiros são conectados por uma malha de transporte muito bem desenvolvida e através desta,
cidadãs e cidadãos viajam diariamente entre as cidades para trabalhar, estudar e realizar outras atividades.
Considerando o fluxo de indivíduos (infectados) que chega em um município em um determinado dia, caso este município
ainda não estejam em transmissão comunitária, podemos calcular a probabilidade de uma epidemia se estabelecer.
Esta probabilidade é dada por esta fórmula:
$$P_{epi}=1-\left(\frac{1}{R_0}\right)^{I_0}$$,
onde $I_0$ é o número de infectados chegando diáriamente no município. Neste cenário usamos um $R_0=2.5$.
''')
elif page == PAGE_CASE_NUMBER_BR:
st.title(PAGE_CASE_NUMBER_BR)
x_variable = "date"
y_variable = "Casos Confirmados"
data = dashboard_data.get_data()
ufs = sorted(list(data.state.drop_duplicates().values))
uf_option = st.multiselect("Selecione o Estado", ufs)
city_options = None
if uf_option:
cities = dashboard_data.get_city_list(data, uf_option)
city_options = st.multiselect("Selecione os Municípios", cities)
is_log = st.checkbox('Escala Logarítmica', value=False)
region_name, data_uf = dashboard_data.get_data_uf(
data, uf_option, city_options, y_variable)
dashboard_data.plot_series(data_uf, x_variable, y_variable,
region_name, is_log)
st.markdown(
"**Fonte**: [brasil.io](https://brasil.io/dataset/covid19/caso)")
elif page == CUM_DEATH_COUNT_BR:
st.title(CUM_DEATH_COUNT_BR)
x_variable = "date"
y_variable = "Mortes Acumuladas"
data = dashboard_data.get_data()
ufs = sorted(list(data.state.drop_duplicates().values))
uf_option = st.multiselect("Selecione o Estado", ufs)
city_options = None
if uf_option:
cities = dashboard_data.get_city_list(data, uf_option)
city_options = st.multiselect("Selecione os Municípios", cities)
is_log = st.checkbox('Escala Logarítmica', value=False)
region_name, data_uf = dashboard_data.get_data_uf(
data, uf_option, city_options, y_variable)
dashboard_data.plot_series(data_uf, x_variable, y_variable,
region_name, is_log)
st.markdown(
"**Fonte**: [brasil.io](https://brasil.io/dataset/covid19/caso)")
elif page == MAPA:
# Precisa refatorar
st.title("Distribuição Geográfica de Casos")
cases = dashboard_data.get_data()
estados = dashboard_data.load_lat_long()
estados['casos'] = 0
cases = cases[cases.place_type != 'state'].groupby(['date',
'state']).sum()
cases.reset_index(inplace=True)
for i, row in estados.iterrows():
if row.Estados in list(cases.state):
estados.loc[estados.Estados == row.Estados, 'casos'] += \
cases[(cases.state == row.Estados) & (cases.is_last)]['Casos Confirmados'].iloc[0]
midpoint = (np.average(estados["Latitude"]),
np.average(estados["Longitude"]))
geojson_url = "https://data.brasil.io/dataset/shapefiles-brasil/0.01/BR-UF.geojson"
layer = pdk.Layer("ColumnLayer",
data=estados,
get_position=["Longitude", "Latitude"],
get_elevation=['casos'],
auto_highlight=True,
radius=50000,
elevation_scale=300,
get_color=[100, 255, 100, 255],
pickable=True,
extruded=True,
coverage=1)
view_state = pdk.ViewState(
longitude=midpoint[1],
latitude=midpoint[0],
zoom=3,
pitch=20.,
)
mapbox_style = 'mapbox://styles/mapbox/light-v9'
mapbox_key = 'pk.eyJ1IjoiZmNjb2VsaG8iLCJhIjoiY2s4c293dzc3MGJodzNmcGEweTgxdGpudyJ9.UmSRs3e4EqTOte6jYWoaxg'
st.write(
pdk.Deck(
map_style=mapbox_style,
mapbox_key=mapbox_key,
initial_view_state=view_state,
layers=[layer],
tooltip={
"html":
"<b>Estado:</b> {Estados}<br><b>Número de casos:</b> {casos}",
"style": {
"color": "white"
}
},
))
st.markdown(
"**Fonte**: [brasil.io](https://brasil.io/dataset/covid19/caso)")
elif page == PAGE_GLOBAL_CASES:
st.title(PAGE_GLOBAL_CASES)
x_variable = "Data"
y_variable = "Casos"
global_cases = dashboard_data.get_global_cases()\
.drop(["Province/State", "Lat", "Long"], axis="columns")
melted_global_cases = pd.melt(global_cases,
id_vars=["País/Região"],
var_name=x_variable,
value_name=y_variable)
melted_global_cases["Data"] = pd.to_datetime(
melted_global_cases["Data"])
countries = dashboard_data.get_countries_list(melted_global_cases)
countries_options = st.multiselect("Selecione os Países", countries)
region_name, countries_data = dashboard_data.get_countries_data(
melted_global_cases, countries_options)
is_log = st.checkbox('Escala Logarítmica', value=False)
dashboard_data.plot_series(countries_data, x_variable, y_variable,
region_name, is_log)
st.markdown(
"**Fonte**: [Johns Hopkins CSSE](https://github.com/CSSEGISandData/COVID-19)"
)
elif page == CREDITOS:
st.markdown(open('dashboard/creditos.md', 'r').read())
def run_nlp_and_others(txt, selected_features):
text_similarity = 4 * (cos_nlp(txt))
cos_combined = cos_others(selected_features)
cos_combined['nlp_portion'] = text_similarity
cos_combined['mean_similarity'] = (cos_combined[329] +
cos_combined['nlp_portion']) / 2
top3hotels = cos_combined.nlargest(3, 'mean_similarity')
idx_numbers = list(top3hotels.index.values)
all_info = pd.read_csv('all_info_cleaned.csv')
top3df = all_info.iloc[idx_numbers, :]
tb_returned_cols = [
'name_x', 'rating_x', 'website', 'international_phone_number'
]
for i in selected_features:
if i == 'restaurants':
tb_returned_cols.append('top_3_restaurants')
if i == 'tourist_attractions':
tb_returned_cols.append('top_3_tourist_attract')
if i == 'art_gallery':
tb_returned_cols.append('top_3_art_galleries')
if i == 'gyms':
tb_returned_cols.append('top_3_gyms')
if i == 'shopping_malls':
tb_returned_cols.append('top_3_shopping')
if i == 'bars':
tb_returned_cols.append('top_3_bars')
if i == 'casinos':
tb_returned_cols.append('top_casinos')
if i == 'supermarkets':
tb_returned_cols.append('top_3_supermarkets')
tb_returned = top3df[tb_returned_cols]
top3df['lon'] = top3df['lng']
coords_df = top3df[['lat', 'lon', 'name_x']]
reindexed = tb_returned.reset_index(drop=True)
# name_removed = tb_returned_cols.remove('name_x')
idx_numbers = list(reindexed.index.values)
st.write('Your Top 3 Recommended Hotels Are:')
covidLayer = pdk.Layer(
"ScatterplotLayer",
data=coords_df,
pickable=False,
opacity=0.3,
stroked=True,
filled=True,
radius_scale=10,
radius_min_pixels=5,
radius_max_pixels=60,
line_width_min_pixels=1,
get_position=["lon", "lat"],
get_fill_color=[252, 136, 3],
get_line_color=[255, 0, 0],
)
text_layer = pdk.Layer(
"TextLayer",
data=coords_df,
get_position=['lon', 'lat'],
get_text='name_x',
get_color=[0, 0, 0, 200],
get_size=15,
get_alignment_baseline='bottom',
)
r = pdk.Deck(map_style='mapbox://styles/mapbox/light-v9',
initial_view_state=pdk.ViewState(latitude=20.6034,
longitude=-105.2253,
zoom=10),
layers=[covidLayer, text_layer])
st.pydeck_chart(r)
for i in idx_numbers:
st.write(f'**Hotel {i+1}:**', reindexed['name_x'].iloc[i])
for j in tb_returned_cols:
#if j == 'name_x':
#st.write('*Name:*',reindexed['name_x'].iloc[i])
if j == 'rating_x':
st.write('*Hotel Rating:*', reindexed['rating_x'].iloc[i])
elif j == 'website':
st.write('*Website:*', reindexed['website'].iloc[i])
elif j == 'international_phone_number':
st.write('*Phone Number:*',
reindexed['international_phone_number'].iloc[i])
elif j == 'top_3_restaurants':
st.write('*Top Rated Restaurants Nearby:*',
reindexed['top_3_restaurants'].iloc[i])
elif j == 'top_3_tourist_attract':
st.write('*Top Rated Tourist Attractions Nearby:*',
reindexed['top_3_tourist_attract'].iloc[i])
elif j == 'top_3_art_galleries':
st.write('*Top Rated Art Galleries Nearby:*',
reindexed['top_3_art_galleries'].iloc[i])
elif j == 'top_3_gyms':
st.write('*Top Rated Gyms Nearby:*',
reindexed['top_3_gyms'].iloc[i])
elif j == 'top_3_shopping':
st.write('*Top Rated Shopping Malls Nearby:*',
reindexed['top_3_shopping'].iloc[i])
elif j == 'top_3_bars':
st.write('*Top Rated Bars Nearby:*',
reindexed['top_3_bars'].iloc[i])
elif j == 'top_casinos':
st.write('*Casinos Nearby:*', reindexed['top_casinos'].iloc[i])
elif j == 'top_3_supermarkets':
st.write('*Supermarkets Nearby:*',
reindexed['top_3_supermarkets'].iloc[i])
st.write(' ')
# print(j)
# print('Hotel {i+1}:',
# df[j].iloc[i])
# hotel1 = st.write('Hotel 1:')
#hotel1name = st.write(reindexed['name_x'].iloc[0])
# hotel1_info = []
# for i in tb_returned_cols:
# hotel1_info.append(reindexed[i].iloc[0])
#tb_returned['name_x'].iloc[0],
#'Rating:',tb_returned['rating_x'].iloc[0])
return st.write('**Enjoy your customized stay in Puerto Vallarta!**')
# Set viewport for the deckgl map
view = pdk.ViewState(
latitude=0,
longitude=0,
zoom=0.2,
)
# Create the scatter plot layer
covidLayer = pdk.Layer("ScatterplotLayer",
data=mostrar[['Casos', 'lat', 'lon']],
pickable=False,
opacity=0.3,
stroked=True,
filled=True,
radius_scale=10,
radius_min_pixels=2,
radius_max_pixels=25,
line_width_min_pixels=1,
get_position=["lon", "lat"],
get_radius='Casos',
get_fill_color=[252, 136, 3],
get_line_color=[255, 0, 0],
tooltip="test test")
# Create the deck.gl map
r = pdk.Deck(
layers=[covidLayer],
initial_view_state=view,
map_style="mapbox://styles/mapbox/light-v10",
)
midpoint = (np.average(data['latitude']),np.average(data['longitude']))
st.write(pdk.Deck(
map_style="mapbox://style/mapbox/light-v9",
initial_view_state ={
"latitude" : midpoint[0],
"longitude" : midpoint[1],
"zoom" : 11,
"pitch" :50,
},
layers = [
pdk.Layer(
"HexagonLayer",
data=data[['date/time', 'latitude', 'longitude']],
get_position=['longitude','latitude'],
radius = 50,
extruded = True,##3d
pickable = True,
elevation_scale = 6,
elevation_range = [0,1000],
),
],
))
st.header("breakdown by minute between %i:00 and %i:00" %(hour,(hour+1) %24))
filtered = data[
H3_HEX_DATA = [
{"hex": "88283082b9fffff", "count": 10},
{"hex": "88283082d7fffff", "count": 50},
{"hex": "88283082a9fffff", "count": 100},
]
df = pd.DataFrame(H3_HEX_DATA)
st.pydeck_chart(
pdk.Deck(
map_style="mapbox://styles/mapbox/light-v9",
tooltip={"text": "Count: {count}"},
initial_view_state=pdk.ViewState(
latitude=37.7749295, longitude=-122.4194155, zoom=12, bearing=0, pitch=30
),
layers=[
pdk.Layer(
"H3HexagonLayer",
df,
pickable=True,
stroked=True,
filled=True,
get_hexagon="hex",
get_fill_color="[0, 255, 0]",
get_line_color=[255, 255, 255],
line_width_min_pixels=2,
),
],
)
)
