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" }, }, ))