def show_column_map(data):
data['lat'] = data['state'].apply(_get_coord, args=('lat', ))
data['lon'] = data['state'].apply(_get_coord, args=('lon', ))
st.pydeck_chart(
pdk.Deck(map_style='mapbox://styles/mapbox/light-v9',
initial_view_state=pdk.ViewState(latitude=-23.901,
longitude=-46.525,
zoom=5,
pitch=50),
layers=[
pdk.Layer('ColumnLayer',
data=data,
get_position='[lon, lat]',
get_elevation='[newCases+newDeaths]',
radius=20000,
auto_highlight=True,
elevation_scale=100,
elevation_range=[0, 5000],
pickable=True,
extruded=True,
get_color="[10 10 10 255]"),
pdk.Layer('ColumnLayer',
data=data,
get_position='[lon, lat]',
get_elevation='[newCases]',
radius=20000,
auto_highlight=True,
elevation_scale=100,
elevation_range=[0, 5000],
pickable=True,
extruded=True,
get_color="[128 10 10 255]")
]))
def show_speed_jam(df):
hour_selected = st.slider("Select hour", 0, 23)
data = speed_data_for_jam(df, hour_selected)
# Define a layer to display on a map
layer = pdk.Layer(
'HeatmapLayer',
data.sample(frac=0.05), #数据在此输入
get_position=['lon', 'lat'], #指定经纬度的列',
opacity=0.7,
radiusPixels=7,
threshold=0.08,
intensity=5,
)
# Set the viewport location
view_state = pdk.ViewState(longitude=114.027465,
latitude=22.632468,
zoom=10,
pitch=40,
bearing=-10)
# Render
r = pdk.Deck(layers=[layer],
initial_view_state=view_state,
api_keys=api_keys,
map_style='light')
st.pydeck_chart(r, True)
def map_graph():
# map graph of the tallest skyscrapers around the world using the lat and long of the buildings
st.subheader('Map of Tallest Structures Around the World')
# create df for map
df_map = pd.read_csv(FILENAME, usecols=['Name', 'Lat', 'Lon'])
# rename lat and lon columns to lower case so that st.map will work
df_map.columns = ['Name', 'lat', 'lon']
# map df
view_state = pdk.ViewState(
latitude=df_map["lat"].mean(),
longitude=df_map["lon"].mean(),
zoom=2,
pitch=0)
layer1 = pdk.Layer('ScatterplotLayer',
data=df_map,
get_position='[lon, lat]',
get_radius=100000,
get_color=[random.randint(0, 2555), random.randint(0, 255), random.randint(0, 255)],
pickable=True
)
# stylish tool tip
tool_tip = {"html": "{Name}</br>({lat}, {lon})",
"style": {"backgroundColor": "gray",
"color": "white"}
}
map2 = pdk.Deck(map_style='mapbox://styles/mapbox/light-v9',
initial_view_state=view_state,
layers=[layer1],
tooltip=tool_tip)
st.pydeck_chart(map2)
def overview():
@st.cache
def lay():
layers = []
for i in range(dfd['labels'].nunique()):
df=dfd.query(f"`labels`=={i}")
layer = pdk.Layer(
"ScatterplotLayer",
data=df,
pickable=True,
stroked=True,
filled=True,
opacity=0.2,
get_radius=3999,
radius_max_pixels=19,
get_position="coordinates",
get_fill_color=colors[i],
)
layers.append(layer)
srclayer = pdk.Layer(
"ScatterplotLayer",
data=dfs,
pickable=True,
stroked=True,
filled=True,
opacity=1,
get_radius=3999,
radius_max_pixels=7,
get_position="coordinates",
get_fill_color=[0,0,0],
)
layers.append(srclayer)
iconlayer = pdk.Layer(
type='IconLayer',
data=dfs,
billboard=True,
get_icon='icon_data',
get_size=89,
size_scale=1,
size_min_pixels=10,
opacity=0.6,
size_max_pixels=100,
get_position='coordinates',
pickable=True
)
layers.append(iconlayer)
return layers
st.pydeck_chart(pdk.Deck(
map_style="mapbox://styles/mapbox/light-v9",
initial_view_state={"latitude": 48.8566, "longitude": 2.3522, "zoom": 7, "pitch": 40},
layers=lay(),
))
def fullpath():
@st.cache
def lay():
layers = []
for i in range(df0['src'].nunique()):
df=df0.query(f"`src`=={i}")
layer = pdk.Layer(
type='PathLayer',
data=df,
rounded=True,
billboard=True,
pickable=True,
width_min_pixels=5,
auto_highlight=True,
get_color=colors[i],
get_path='path',
)
layers.append(layer)
return layers
st.pydeck_chart(pdk.Deck(
map_style="mapbox://styles/mapbox/light-v9",
initial_view_state={"latitude": 48.8566, "longitude": 2.3522, "zoom": 7, "pitch": 0},
layers=lay(),
))
def crimeProfile_Geographic(dataframe):
Latitude = dataframe['Lat'].to_list()
Longitude = dataframe['Long'].to_list()
crimeMap_dict = {Latitude[i]: Longitude[i] for i in range(len(Latitude))}
crimeMap = pd.DataFrame(crimeMap_dict, index=['lon']).transpose()
crimeMap.index.name = 'lat'
crimeMap.reset_index(level=0, inplace=True)
sl.write(crimeMap)
#sl.map(crimeMap)
sl.pydeck_chart(
pdk.Deck(
map_style="mapbox://styles/mapbox/bright-v8",
initial_view_state=pdk.ViewState(
latitude=42.32,
longitude=-71.06,
zoom=11.15,
pitch=35,
),
layers=[
pdk.Layer(
'ScatterplotLayer',
data=crimeMap,
get_position="[lon, lat]",
get_radius=50,
get_fill_color='[245, 66, 75]',
pickable=True,
opacity=0.5,
stroked=False,
filled=True,
wireframe=True,
),
],
))
def lat_long(non_filtered_df, filtered_df, not_drone_df, track_id):
st.pydeck_chart(
pdk.Deck(
map_style='mapbox://styles/mapbox/dark-v10',
initial_view_state=pdk.ViewState(
latitude=1.327768,
longitude=103.982339,
zoom=15,
pitch=0,
),
layers=[
pdk.Layer(
'ScatterplotLayer',
data=not_drone_df,
get_position='[lon, lat]',
get_color=yellow,
get_radius=15,
),
pdk.Layer(
'ScatterplotLayer',
data=non_filtered_df,
get_position='[lon, lat]',
get_color=lime_green,
get_radius=15,
),
pdk.Layer(
'ScatterplotLayer',
data=filtered_df,
get_position='[lon, lat]',
get_color=red,
get_radius=15,
),
],
))
def set_map(data, color):
data = set_score(data)
st.pydeck_chart(
pdk.Deck(
map_style="mapbox://styles/mapbox/light-v9",
initial_view_state=pdk.data_utils.compute_view(data[['lng',
'lat']]),
tooltip={"text": "{Vertex_ID}\n{name}"},
layers=[
pdk.Layer(
"ScatterplotLayer",
data=data,
pickable=True,
opacity=0.4,
stroked=True,
filled=True,
radius_scale=6,
get_radius=["score"],
radius_pixels=["score"],
radius_min_pixels=3,
radius_max_pixels=200,
# line_width_min_pixels=1,
get_position=['lng', 'lat'],
get_fill_color=color,
),
]))
def test_basic(self):
"""Test that pydeck object orks."""
st.pydeck_chart(
pdk.Deck(layers=[
pdk.Layer("ScatterplotLayer", data=df1),
]))
el = self.get_delta_from_queue().new_element
actual = json.loads(el.deck_gl_json_chart.json)
self.assertEqual(actual["layers"][0]["@@type"], "ScatterplotLayer")
self.assertEqual(
actual["layers"][0]["data"],
[
{
"lat": 1,
"lon": 10
},
{
"lat": 2,
"lon": 20
},
{
"lat": 3,
"lon": 30
},
{
"lat": 4,
"lon": 40
},
],
)
def map(df, filtered):
midpoint = (np.average(df['lat']), np.average(df['lon']))
layer = pdk.Layer(
'ScatterplotLayer',
data=filtered,
get_position='[lon, lat]',
auto_highlight=True,
pickable=True,
radiusScale=80,
radiusMinPixels=5,
getFillColor=[248, 24, 148],
)
view_state = pdk.ViewState(latitude=midpoint[0],
longitude=midpoint[1],
zoom=4)
r = pdk.Deck(
map_style='mapbox://styles/mapbox/light-v9',
layers=[layer],
initial_view_state=view_state,
tooltip={
'html':
'<b>ID:</b> {id} <br><b>Price:</b> {price} <br><b>Rooms:</b> {bedrooms}',
'style': {
'color': 'white'
}
},
)
st.pydeck_chart(r)
def visualization_streamlit(short_route, healthy_route):
df = pd.DataFrame({
'name': ['short', 'healthy'],
'color': [(255, 0, 0), (0, 255, 0)],
'path': [short_route, healthy_route]
})
st.pydeck_chart(
pdk.Deck(
map_style='mapbox://styles/mapbox/light-v9',
initial_view_state=pdk.ViewState(
latitude=41.38879,
longitude=2.15899,
zoom=13,
pitch=50,
),
layers=[
pdk.Layer(
type="PathLayer",
data=df,
pickable=True,
width_scale=20,
width_min_pixels=5,
get_path='path',
get_color='color',
),
],
))
def map(data):
view_state = pdk.ViewState(
longitude=-1.415,
latitude=52.2323,
zoom=6,
min_zoom=5,
max_zoom=15,
pitch=40.5,
bearing=-27.36,
)
layer = pdk.Layer(
"HexagonLayer",
data,
get_position=["lng", "lat"],
auto_highlight=True,
elevation_scale=height,
pickable=True,
elevation_range=[0, 3000],
extruded=True,
coverage=1,
radius=radius,
opacity=opacity
)
st.pydeck_chart(pdk.Deck(
layers=[layer],
initial_view_state=view_state,
tooltip=True
)
)
def display_map():
global min,sec,quartier,mapgps
#Display of the map
tooltip = {
"html": "The estimated arrival time is <b>{min}</b> min <b>{sec}</b> sec<br> for <b>{quartier}</b> area,<br> depending the information entered.",
"style": {"background": "grey", "color": "white", "font-family": '"Helvetica Neue", Arial', "z-index": "10000"},
}
st.pydeck_chart(pdk.Deck(
map_style='mapbox://styles/cedric60128/ckn0g3q6u13pz17pbnp9vmn6n',
tooltip = tooltip,
initial_view_state=pdk.ViewState(
latitude=51.450,
longitude=-0.070,
zoom=8.80,
pitch=50,
bearing=-10
),
layers=[
pdk.Layer(
'ColumnLayer',
data=mapgps,
get_position='[lon, lat]',
get_elevation='[temps/2]',
radius=450,
auto_highlight=True,
elevation_scale=50,
elevation_range=[0, 100],
get_fill_color=["temps * -100", "temps", "temps * 10", 300],
pickable=True,
extruded=True
)
]
))
def show_speed_map(df):
hour_selected = st.slider("Select hour", 0, 23)
minute_selected = st.slider("Select minute", 0, 60)
data = speed_data(df, hour_selected, minute_selected)
# Define a layer to display on a map
layer = pdk.Layer(
'HexagonLayer',
data, #数据在此输入
get_position=['lon', 'lat'], #指定经纬度的列
getColorWeight='speed', #指定集计数量的列
getElevationWeight='speed', #指定集计数量的列
elevation_scale=10,
radius=200, #Hexagon的大小
elevation_range=[0, 1000], #Hexagon的高低
extruded=True,
coverage=1)
# Set the viewport location
view_state = pdk.ViewState(longitude=114.027465,
latitude=22.632468,
zoom=10,
pitch=25,
bearing=-10)
# Render
r = pdk.Deck(layers=[layer],
initial_view_state=view_state,
api_keys=api_keys,
map_style='light')
st.pydeck_chart(r)
def mapp(data):
# Set the viewport location
view_state = pdk.ViewState(
longitude=2.415,
latitude=46,
zoom=5,
min_zoom=1,
max_zoom=20,
pitch=40.5,
bearing=-27.36,
)
# Define a layer to display on a map
ecoles = pdk.Layer(
"HexagonLayer",
data,
get_position=["longitude", "latitude"],
#get_position=["longitude", "latitude"],
auto_highlight=True,
elevation_scale=hauteur,
pickable=True,
elevation_range=[0, 2000],
extruded=extruded,
coverage=1,
radius=radius,
opacity=opacity)
st.pydeck_chart(
pdk.Deck(
layers=[ecoles],
initial_view_state=view_state,
tooltip={"text": "Number of schools: {elevationValue}"},
))
def listingMap(listings):
view_state = pdk.ViewState(latitude=42.3601,
longitude=-71.0589,
zoom=12,
pitch=0)
layer1 = pdk.Layer('ScatterplotLayer',
data=listings,
get_position='[longitude, latitude]',
get_radius=20,
get_color=[200, 20, 0],
pickable=True)
tool_tip = tool_tip = {
"html": "Listing Name:<br/> <b>{name}</b> ",
"style": {
"backgroundColor": "red",
"color": "white"
}
}
map = pdk.Deck(map_style='mapbox://styles/mapbox/light-v9',
initial_view_state=view_state,
mapbox_key=MAPKEY,
layers=[layer1],
tooltip=tool_tip)
st.pydeck_chart(map)
def mapa(lat,lon):
# creamos un dataframe para dibujar un mapa
df = pd.DataFrame(
np.random.randn(1000, 2) / [50, 50] + [37.76, -122.4],
# especificamos es que tipo de forma vamos a trabajar con las direcciones
columns=['lat', 'lon'])
# usando pydeck dibujamos un mapa segun su estilo y version de esta libreria
st.pydeck_chart(pdk.Deck(
map_style='mapbox://styles/mapbox/light-v9',
# inicializamos la la zona del mapa que queremos ver
# todo esto en base a latitud y longitud
initial_view_state=pdk.ViewState(
latitude=lat,
longitude=lon,
zoom=7,
# indicamos la altura desde la que visualizara el usuario
pitch=80,),
# por debajo del mapa se trabaja con una matriz por ende mediante layer
# especificamos la seccion de la matriz que se visualizara en el mapa
layers=[
pdk.Layer(
# formato de datos obtenidos de la matriz
'HexagonLayer',
data=df,get_position='[lon, lat]',
radius=200,elevation_scale=8,elevation_range=[0, 100],
pickable=True,extruded=True,
)
],
))
def county_map(locations):
map_df = pd.DataFrame(locations, columns=["school name", "X", "Y"])
view_location = pdk.ViewState(latitude=map_df["Y"].mean(),
longitude=map_df["X"].mean(),
zoom=9,
pitch=0)
location_data = {
"html":
"University Name:<br/> <b>{school name}</b></br> Latitude: <b>{Y}</b><br/> Longitude: <b>{X}</b><br/>",
"style": {
"backgroundColor": "steelblue",
"color": "lavender"
}
}
layer_county_map = pdk.Layer('ScatterplotLayer',
data=map_df,
get_position='[X, Y]',
get_radius=400,
radius_scale=2,
get_color=[200, 66, 245],
pickable=True)
county_map1 = pdk.Deck(map_style='mapbox://styles/mapbox/light-v9',
initial_view_state=view_location,
layers=[layer_county_map],
tooltip=location_data)
st.pydeck_chart(county_map1)
def showLoopDetectorMap():
df_loop_location = getLoopDetectorLocation()
st.pydeck_chart(pdk.Deck(
# map_style='mapbox://styles/mapbox/dark-v9',
map_style='mapbox://styles/mapbox/light-v9',
initial_view_state=pdk.ViewState(
latitude=47.59,
longitude=-122.24,
zoom=9,
pitch=50,
),
layers=[
# pdk.Layer(
# 'HexagonLayer',
# data=df_loop_location,
# get_position='[lon, lat]',
# radius=200,
# elevation_scale=4,
# elevation_range=[0, 1000],
# pickable=True,
# extruded=True,
# ),
pdk.Layer(
'ScatterplotLayer',
data=df_loop_location,
get_position='[lon, lat]',
get_color='[0, 160, 187, 160]',
get_radius=300,
),
],
))
def orders_on_world_map(self):
st.markdown('''
# Orders on World Map
''')
st.markdown('''
## By Geolocation
This tool allows seeing precise locations where orders were placed.
Coordinates are auto-generated and may contain errors in rare cases.
''')
orders_heatmap_layer = pdk.Layer(
"HeatmapLayer",
data=self.df.dropna(),
get_position=["LONG", "LAT"],
aggregation='"SUM"',
get_weight="SALES", # NOTE ME!!
pickable=True)
chart = pdk.Deck(layers=[orders_heatmap_layer],
map_provider="carto",
map_style=pdk.map_styles.CARTO_LIGHT)
st.pydeck_chart(chart)
st.header('Data Table')
st.dataframe(self.df)
def map(data, latitude, longitude):
st.pydeck_chart(
pdk.Deck(
map_style="mapbox://styles/johnzinz/ckihdfwni4slu1atbeqiucn34",
initial_view_state={
"latitude": latitude,
"longitude": longitude,
"zoom": 10,
"pitch": 50,
},
layers=[
pdk.Layer(
"GridLayer",
data=data,
opacity=0.2,
pickable=True,
extruded=True,
cell_size=100,
elevation_scale=2,
get_position=["longitude", "latitude"],
),
],
tooltip={"text": "{position}\nCount: {count}"},
mapbox_key=
'pk.eyJ1Ijoiam9obnppbnoiLCJhIjoiY2tmbWthazZ6MDNueDJxb2ZyZ2M3czU0dyJ9.Bl3T4kl14xan7glGxid_Rw'
))
def wirkungsorte():
#ranking und karte der meistverwendeten wirkungsorte aller personen in der gnd
df = pd.read_csv(f'{path}/wirkungsorte-top50.csv')
df.drop(columns=['id'], inplace=True)
df.rename(columns={'name': 'Name', 'count': 'Anzahl'}, inplace=True)
st.header('TOP Wirkungsorte von GND-Personen')
st.markdown(
'Von allen Personensätzen (Tp) weisen 782.682 Angaben zum Wirkungsort der jeweiligen Person auf.'
)
#Balkendiagramm
orte_filt = st.slider('Zeige Top …',
min_value=3,
max_value=len(df),
value=10,
step=1)
graph_count = alt.Chart(df.nlargest(
orte_filt, 'Anzahl',
keep='all')).mark_bar().encode(alt.X('Name:N', sort='y'),
alt.Y('Anzahl'),
alt.Color('Name:N',
legend=alt.Legend(columns=2)),
tooltip=[
alt.Tooltip('Name:N', title='Ort'),
alt.Tooltip('Anzahl:Q',
title='Anzahl')
])
st.altair_chart(graph_count, use_container_width=True)
#Karte
INITIAL_VIEW_STATE = pdk.ViewState(latitude=50.67877877706058,
longitude=8.129981238464392,
zoom=4.5,
max_zoom=16,
bearing=0)
scatterplotlayer = pdk.Layer("ScatterplotLayer",
df,
pickable=True,
opacity=0.5,
stroked=True,
filled=True,
radius_min_pixels=1,
radius_max_pixels=100,
line_width_min_pixels=1,
get_position='[lon, lat]',
get_radius="Anzahl",
get_fill_color=[255, 140, 0],
get_line_color=[0, 0, 0])
st.pydeck_chart(
pdk.Deck(scatterplotlayer,
initial_view_state=INITIAL_VIEW_STATE,
map_style=pdk.map_styles.LIGHT,
tooltip={
"html":
"<b>{Name}</b><br \>Wirkungsort von {Anzahl} Personen"
}))
def getpath(src, tp, veh):
@st.cache
def lay(src, tp, veh):
layers = []
df=df0.query(f"`src`=={src}").query(f"`type`=={tp}").query(f"`veh`=={veh}")
layer = pdk.Layer(
type='PathLayer',
data=df,
rounded=True,
billboard=True,
pickable=True,
width_min_pixels=3,
auto_highlight=True,
get_path='path',
)
layers.append(layer)
srclayer = pdk.Layer(
"ScatterplotLayer",
data=dfs[src:src+1],
pickable=True,
stroked=True,
filled=True,
opacity=1,
get_radius=3999,
radius_max_pixels=12,
get_position="coordinates",
get_fill_color=[0,0,0],
)
layers.append(srclayer)
iconlayer = pdk.Layer(
type='IconLayer',
data=dfs[src:src+1],
billboard=True,
get_icon='icon_data',
get_size=79,
get_color=[155,155,155],
size_scale=1,
size_min_pixels=10,
opacity=0.6,
size_max_pixels=100,
get_position='coordinates',
pickable=True
)
layers.append(iconlayer)
return layers
layers = lay(src, tp,veh)
st.pydeck_chart(pdk.Deck(
map_style="mapbox://styles/mapbox/light-v9",
initial_view_state={"latitude": dfs["coordinates"][src][1], "longitude": dfs["coordinates"][src][0], "zoom": 8, "pitch": 0},
layers=layers,
))
def make_main_body(rest_df, ngbr_df, neighborhood):
# intro and header
st.markdown("""
<h1>Best Halal food near {0}</h1>
Are you wondering what halal options are around NYC neighborhoods?
We provide a halal-reliability score based on reviews of the restaurants.
""".format(neighborhood),
unsafe_allow_html=True)
# generate a grid of image_cards
grid = Grid("1 1 1",
color=COLOR,
background_color=BACKGROUND_COLOR,
df=ngbr_df)
# generate grid cells from dataframe
with grid:
for i, row in zip(range(ngbr_df.shape[0]), rest_df.itertuples()):
grid.cell(chr(i + 97), 1, 2, i + 1,
i + 1).image_card(name='. '.join([str(i + 1), row.name]),
address=row.address,
score=str(row.score),
image_url=row.image_url,
url=row.url,
distance=str(round(row.distance, 1)))
# should be places in it's own function later
# generate the map
# Adding code so we can have map default to the center of the data
midpoint = ((rest_df['lat'].median()), (rest_df['lon'].median()))
st.pydeck_chart(
pdk.Deck(map_style='mapbox://styles/mapbox/light-v9',
initial_view_state=pdk.ViewState(
latitude=midpoint[0],
longitude=midpoint[1],
zoom=10,
pitch=10,
height=700,
),
tooltip={
'html': '<b>{name}</b>',
'style': {
'color': 'white'
}
},
layers=[
pdk.Layer('ScatterplotLayer',
data=rest_df,
get_position=['lon', 'lat'],
auto_highlight=True,
get_radius=250,
get_fill_color='[255 139 156]',
pickable=True)
]))
def test_no_args(self):
"""Test that it can be called with no args."""
st.pydeck_chart()
el = self.get_delta_from_queue().new_element
actual = json.loads(el.deck_gl_json_chart.json)
self.assertEqual(actual, deck_gl_json_chart.EMPTY_MAP)
def show_order_od(df):
st.header("Origin")
hour_selected1 = st.slider("Select hour for origin", 0, 23)
# Define a layer to display on a map
layer = pdk.Layer(
'HeatmapLayer',
df[(df['hour'] == hour_selected1)], #数据在此输入
get_position=['origin_lon', 'origin_lat'], #指定经纬度的列',
opacity=0.7,
radiusPixels=7,
threshold=0.08,
intensity=5,
colorRange=[[116, 169, 207], [54, 144, 192], [5, 112, 176],
[3, 78, 123]],
)
# Set the viewport location
view_state = pdk.ViewState(longitude=114.027465,
latitude=22.632468,
zoom=10,
pitch=40,
bearing=-10)
# Render
r = pdk.Deck(layers=[layer],
initial_view_state=view_state,
api_keys=api_keys,
map_style='light')
st.pydeck_chart(r, True)
st.header("Destination")
hour_selected2 = st.slider("Select hour for destination", 0, 23)
# Define a layer to display on a map
layer = pdk.Layer(
'HeatmapLayer',
df[(df['hour'] == hour_selected2)], #数据在此输入
get_position=['destination_lon', 'destination_lat'], #指定经纬度的列',
opacity=0.7,
radiusPixels=7,
threshold=0.08,
intensity=5,
colorRange=[[116, 169, 207], [54, 144, 192], [5, 112, 176],
[3, 78, 123]],
)
# Set the viewport location
view_state = pdk.ViewState(longitude=114.027465,
latitude=22.632468,
zoom=10,
pitch=40,
bearing=-10)
# Render
r = pdk.Deck(layers=[layer],
initial_view_state=view_state,
api_keys=api_keys,
map_style='light')
st.pydeck_chart(r, True)
def view(self):
self.view_state_component.edit_view() # Does not work
st.pydeck_chart(
pdk.Deck(
map_style="mapbox://styles/mapbox/light-v9",
initial_view_state=self.view_state_component.view_state,
layers=[self._scatter_plotter_layer()],
))
def wirkungsorte_musik():
#nach jahrzehnten zwischen 1400 und 2010 gefilterte auswertung der GND-Musikwerke, Musik-Personen und Wikrungsorte und daraus abgeleitete Zentren der Musikkultur, dargestellt auf einer Karte
musiker_orte = pd.read_csv(f'{path}/musiker_orte.csv',
sep='\t',
index_col='idn')
st.header('Wirkungszentren der Musik 1400–2010')
st.write(
'Eine Auswertung der veröffentlichten Titel von Musikern und deren Wirkungszeiten erlaubt Rückschlüsse auf die musikalischen Zentren, wie sie im Bestand der DNB repräsentiert sind.'
)
limiter = st.slider('Jahresfilter',
min_value=1400,
max_value=int(musiker_orte['jahrzehnt'].max()),
value=(1900),
step=10)
musik_filt = musiker_orte.loc[(musiker_orte['jahrzehnt'] == limiter)]
musik_filt['norm'] = (musik_filt['count'] - musik_filt['count'].min()) / (
musik_filt['count'].max() - musik_filt['count'].min())
#Karte
INITIAL_VIEW_STATE = pdk.ViewState(latitude=50.67877877706058,
longitude=8.129981238464392,
zoom=4.5,
max_zoom=16,
bearing=0)
musiker_scatter = pdk.Layer("ScatterplotLayer",
musik_filt,
opacity=0.8,
get_position='[lon, lat]',
pickable=True,
stroked=True,
filled=True,
radius_min_pixels=1,
radius_max_pixels=100,
radiusscale=100,
line_width_min_pixels=1,
get_radius="norm*50000",
get_fill_color=[50, 168, 92],
get_line_color=[39, 71, 51])
st.pydeck_chart(
pdk.Deck(musiker_scatter,
initial_view_state=INITIAL_VIEW_STATE,
map_style=pdk.map_styles.LIGHT,
tooltip={"html": "<b>{name}</b>"}))
st.subheader(f'TOP 10 Wirkungszentren der {limiter}er')
col1, col2 = st.beta_columns(2)
i = 1
for index, row in musik_filt.nlargest(10, 'norm').iterrows():
if i <= 5:
with col1:
st.write(f'{i}. {row["name"]}')
elif i > 5:
with col2:
st.write(f'{i}. {row["name"]}')
i += 1
def make_map(geo_df: pd.DataFrame, df: pd.DataFrame, map_feature: str):
temp = df.copy()
temp.reset_index(inplace=True)
# counties = temp['County Name'].to_list()
geojson = utils.convert_geom(geo_df, temp, [map_feature])
merged_df = pd.DataFrame(geojson)
geo_df["coordinates"] = merged_df["features"].apply(
lambda row: row["geometry"]["coordinates"])
geo_df["name"] = merged_df["features"].apply(
lambda row: row["properties"]["name"])
geo_df[map_feature] = merged_df["features"].apply(
lambda row: row["properties"][map_feature])
scaler = pre.MinMaxScaler()
norm_df = pd.DataFrame(geo_df[map_feature])
normalized_vals = scaler.fit_transform(norm_df)
colors = list(map(color_scale, normalized_vals))
geo_df['fill_color'] = colors
geo_df.drop(['geom', 'County Name'], axis=1, inplace=True)
view_state = pdk.ViewState(
**{
"latitude": 36,
"longitude": -95,
"zoom": 3,
"maxZoom": 16,
"pitch": 0,
"bearing": 0
})
geo_df = geo_df.astype({map_feature: 'float64'})
polygon_layer = pdk.Layer(
"PolygonLayer",
geo_df,
get_polygon="coordinates",
filled=True,
stroked=False,
opacity=0.5,
get_fill_color='fill_color',
auto_highlight=True,
pickable=True,
)
# The brackets here are expected for pdk, so string formatting is less friendly
tooltip = {
"html":
"<b>County:</b> {name} </br>" + "<b>" + str(map_feature) + ":</b> {" +
str(map_feature) + "}"
}
r = pdk.Deck(layers=[polygon_layer],
initial_view_state=view_state,
map_style=pdk.map_styles.LIGHT,
tooltip=tooltip)
st.pydeck_chart(r)
def run():
st.title("GTFS Viewer")
with st.spinner("Loading GTFS data..."):
gtfs_data = GTFSFile("data/gtfs.zip")
gtfs_data.extractall()
options = generate_sidebar(st.sidebar)
if options.uploaded_file is not None:
gtfs_data = GTFSFile(options.uploaded_file)
gtfs_data.extractall()
with st.spinner("Updating map..."):
map_layers = []
if options.display_stops:
map_layers.append(
pdk.Layer(
"ScatterplotLayer",
data=gtfs_data.stops,
get_position="[lon, lat]",
get_fill_color="[100, 30, 0, 160]",
get_radius=30,
pickable=True,
))
if options.display_routes:
map_layers.append(
pdk.Layer(
"PathLayer",
data=gtfs_data.shapes,
width_scale=20,
width_min_pixels=1,
get_path="path",
get_width=1,
get_color=(0, 0, 255, 255),
))
st.pydeck_chart(
pdk.Deck(
map_style="mapbox://styles/mapbox/light-v9",
initial_view_state=pdk.ViewState(latitude=37.76,
longitude=-122.4,
zoom=11,
bearing=0,
pitch=0),
layers=[map_layers],
tooltip={
"html": "<b>Stop:</b> {name} <br/>",
"style": {
"backgroundColor": "steelblue",
"color": "white"
},
},
))
