def test_get_provider(self, name): assert name in bt.Vendors enum_member = getattr(bt.Vendors, name) p1 = bt.get_provider(enum_member) p2 = bt.get_provider(name) p3 = bt.get_provider(name.lower()) assert isinstance(p1, WMTSTileSource) assert isinstance(p2, WMTSTileSource) assert isinstance(p3, WMTSTileSource) assert p1 is not p2 assert p2 is not p3 assert p1 is not p3 assert p1.url == p2.url == p3.url assert p1.attribution == p2.attribution == p3.attribution with pytest.deprecated_call(): # This will not return a WMTSTileSource in bokeh 2.0.0! default_instance = getattr(bt, name) new_instance = bt.get_provider(default_instance) assert default_instance is not new_instance assert default_instance.url == new_instance.url assert default_instance.attribution == new_instance.attribution
def test_attribution(self, name) -> None: p = bt.get_provider(getattr(bt, name)) assert p.attribution == xyz.CartoDB.Positron.html_attribution
# https://docs.bokeh.org/en/latest/docs/user_guide/geo.html from bokeh.plotting import figure, output_file, show from bokeh.tile_providers import CARTODBPOSITRON, get_provider output_file("tile.html") tile_provider = get_provider(CARTODBPOSITRON) # range bounds supplied in web mercator coordinates # p = figure(x_range=(-2000000, 6000000), y_range=(-1000000, 7000000), # x_axis_type="mercator", y_axis_type="mercator") # 3857 EPSG # Modify the bounding boxes with those of arctic points # Using that -86.1200000000000045,-31.2199999999999989 : 30.0,75.5499999999999972 p = figure(x_range=(-9587947, 0), y_range=(3503549, 13195489), x_axis_type="mercator", y_axis_type="mercator") p.add_tile(tile_provider) show(p)
def define_segment(local_time): f''' # Define Segment: {local_time.split()[0]} ''' ''' $contents ''' ''' ## Load Data Open a connection to the database and load the data for a ride containing the segment. ''' s = session('-v2') df = Statistics(s, activity_journal=local_time). \ by_name(SegmentReader, N.SPHERICAL_MERCATOR_X, N.SPHERICAL_MERCATOR_Y, N.DISTANCE, N.ELEVATION, N.LATITUDE, N.LONGITUDE).df df.dropna(inplace=True) df.describe() ''' ### Select Segment Use the sliders to isolate the segment. You may need to play with both sliders before the map displays correctly (todo - fix this, and also all the log messages). ''' TILE = tile_providers.get_provider(tile_providers.Vendors.STAMEN_TERRAIN) output_file(filename='/dev/null') width, height = 800, 800 def modify_doc(doc): t1 = PreText(height=20, width=200) t2 = PreText(height=20, width=200) t3 = PreText(height=20, width=100) s1 = Slider(start=0, end=len(df), value=0, title='Start') s2 = Slider(start=1, end=len(df) - 1, value=len(df), title='Length') map = figure(plot_width=width, plot_height=height, x_axis_type='mercator', y_axis_type='mercator', match_aspect=True) map.add_tile(TILE) map.circle(x=N.SPHERICAL_MERCATOR_X, y=N.SPHERICAL_MERCATOR_Y, source=df, name='map') elevation = figure(plot_width=width, plot_height=height // 10) elevation.line(x=N.DISTANCE, y=N.ELEVATION, source=df, name='elevation') c = column(row(s1, s2), row(t1, t2, t3), map, elevation) def mkplot(l1, l2): l2 = min(len(df) - 1, l1 + l2) t1.text = '%9.5f,%9.5f' % (df.iloc[l1]['Longitude'], df.iloc[l1]['Latitude']) t2.text = '%9.5f,%9.5f' % (df.iloc[l2]['Longitude'], df.iloc[l2]['Latitude']) t3.text = '%4.2fkm' % ( (df.iloc[l2]['Distance'] - df.iloc[l1]['Distance']) / 1000) get_renderer(map, 'map').data_source.data = df[l1:l2] get_renderer(elevation, 'elevation').data_source.data = df[l1:l2] s1.on_change('value', lambda attr, old, new: mkplot(s1.value, s2.value)) s2.on_change('value', lambda attr, old, new: mkplot(s1.value, s2.value)) doc.add_root(c) show(modify_doc) ''' ## Define Segment Replace the details below with your own from the plot above. The start and finish values are (lat, lon); the distance is in metres. Finally, uncomment the `s.add()` to add this to the database. ''' segment = Segment( start=(-70.61813, -33.41536), finish=(-70.63340, -33.42655), distance=4400, name='San Cristobal', description='Climb up San Cristobal in Parque Metropolitana')
height=50) #sfrom bokeh.tile_providers import CARTODBPOSITRON map_repr = 'mercator' # set up/draw the map p = figure( # x_range=(minlng,maxlng), # y_range=(minlat, maxlat), x_axis_type=map_repr, y_axis_type=map_repr, title='IDLE Vehicles Map', match_aspect=True) #ESRI_IMAGERY,OSM tile_provider = get_provider(CARTODBPOSITRON) p.add_tile(tile_provider) tiles = { 'Light': get_provider(CARTODBPOSITRON), 'Open Street': get_provider(OSM), 'Satellite': get_provider(ESRI_IMAGERY) } #select menu #callback def change_tiles_callback(attr, old, new): #removing the renderer corresponding to the tile layer p.renderers = [
from bokeh.io import output_file, show from bokeh.models import CustomJSHover, HoverTool from bokeh.plotting import figure from bokeh.tile_providers import CARTODBPOSITRON, get_provider output_file("customjs_hover.html") # range bounds supplied in web mercator coordinates p = figure(x_range=(-2000000, 6000000), y_range=(-1000000, 7000000), x_axis_type="mercator", y_axis_type="mercator") p.add_tile(get_provider(CARTODBPOSITRON)) p.circle(x=[0, 2000000, 4000000], y=[4000000, 2000000, 0], size=30) code = """ var projections = Bokeh.require("core/util/projections"); var x = special_vars.x var y = special_vars.y var coords = projections.wgs84_mercator.invert(x, y) return coords[%d].toFixed(2) """ p.add_tools( HoverTool(tooltips=[ ('lon', '$x{custom}'), ('lat', '$y{custom}'), ], formatters={ '$x': CustomJSHover(code=code % 0),
def ConfirmedMapPlot(self): # Get the tile provider tile_provider = get_provider(CARTODBPOSITRON) # Create the plot plot = figure(x_axis_type="mercator", y_axis_type="mercator", title=self.title, tools = 'pan, wheel_zoom, reset', active_drag = 'pan', active_scroll = 'wheel_zoom') # Add the tile streamer to the plot plot.add_tile(tile_provider) # Set the sizing mode plot.sizing_mode = 'stretch_both' # Transform from WGS83 to Web Mercator projection merc_geo_json_df = self.country_data.to_crs('EPSG:3857') # Add the transformed data to a GeoJSONDataSource geosource = GeoJSONDataSource(geojson = merc_geo_json_df.to_json()) # Set the palette and min/max range for the colour mapper palette = brewer[self.colour][8] palette = palette[::-1] min_range = self.country_data[self.column].min() max_range = self.country_data[self.column].max() # Create the colour mapper color_mapper = LogColorMapper(palette = palette, low = min_range, high = max_range) # Create a tick formatter format_tick = NumeralTickFormatter(format='0.0a') # Create a Log Ticker log_ticker = LogTicker() # Create the colour bar which will go on the right color_bar = ColorBar(color_mapper=color_mapper, label_standoff=18, formatter=format_tick, border_line_color=None, location = (0, 0), ticker=log_ticker) # Add the data to the circle plot plot.patches(xs='xs', ys='ys', source=geosource, line_color=self.line_colour, fill_alpha=0.8, fill_color={'field' : self.column, 'transform' : color_mapper}) # Add the colour bar plot.add_layout(color_bar, 'right') # Add the tooltip self.AddToolTip(plot, self.tooltips) curdoc().add_root(plot)
def test_unknown_vendor(self): with pytest.raises(ValueError): bt.get_provider("This is not a valid tile vendor")
def map_carbon_emission( bus_info_and_emission, color_coal="black", color_ng=be_purple, label_coal=u"Coal: CO\u2082", label_ng=u"Natural gas: CO\u2082", us_states_dat=None, size_factor=1, web=True, agg=True, type1="natural gas", type2="coal", ): """Makes map of carbon emissions, color code by fuel type. Size/area indicates emissions. :param pandas.DataFrame bus_info_and_emission: info and emission of buses as returned by :func:`combine_bus_info_and_emission`. :param str color_ng: color assigned for ng, default to BE purple :param str color_coal: color associated with coal, default to black/gray :param str label_coal: label for legend associated with coal. :param str label_ng: label for legend associated with ng. :param dict us_states_dat: dictionary of state border lats/lons. If None, get from :func:`postreise.plot.plot_states.get_state_borders`. :param float size_factor: scaling factor for size of emissions circles glyphs :param boolean web: if true, optimizes figure for web-based presentation :param boolean agg: if true, aggregates points by lat lon within a given radius :param str type1: label for hover over tool tips, first color/type (usual choices: natural gas or increase if making a diff map) :param str type2: label for hover over tool tips, second color/type (usual choices: coal or decrease if making diff map) """ # us states borders, prepare data if us_states_dat is None: us_states_dat = get_state_borders() a, b = project_borders(us_states_dat) # prepare data frame for emissions data bus_map = _prepare_busmap(bus_info_and_emission, color_ng, color_coal, agg=agg, type1=type1, type2=type2) bus_map = bus_map.sort_values(by=["color"]) bus_source = ColumnDataSource({ "x": bus_map["x"], "y": bus_map["y"], "size": (bus_map["amount"] / 10000 * size_factor)**0.5 + 2, "radius": (bus_map["amount"] * 1000 * size_factor)**0.5 + 10, "tons": bus_map["amount"], "color": bus_map["color"], "type": bus_map["type"], }) # Set up figure tools: str = "pan,wheel_zoom,reset,save" p = figure( tools=tools, x_axis_location=None, y_axis_location=None, plot_width=800, plot_height=800, output_backend="webgl", sizing_mode="stretch_both", match_aspect=True, ) p_legend = figure( x_axis_location=None, y_axis_location=None, toolbar_location=None, plot_width=200, plot_height=400, y_range=(0, 4), x_range=(0, 2), output_backend="webgl", ) # circle glyphs that exist only for the web legend, # these are plotted behind the tiles, not visible p.circle( -8.1e6, 5.2e6, fill_color=color_coal, color=color_coal, alpha=0.5, size=50, legend_label=label_coal, ) p.circle( -8.1e6, 5.2e6, fill_color=color_ng, color=color_ng, alpha=0.5, size=50, legend_label=label_ng, ) p.add_tile(get_provider(Vendors.CARTODBPOSITRON_RETINA)) # state borders p.patches(a, b, fill_alpha=0.0, line_color="gray", line_width=2) # emissions circles, web version if web: circle = p.circle( "x", "y", fill_color="color", color="color", alpha=0.25, radius="radius", source=bus_source, ) else: p.circle( "x", "y", fill_color="color", color="color", alpha=0.25, size="size", source=bus_source, ) # legend: white square background and bars per color code p_legend.square(1, [1, 3], fill_color="white", color="white", size=300) p_legend.square(1, [1, 3], fill_color="white", color="black", size=(2000000 / 100)**0.5) p_legend.circle( 1, y=np.repeat([1, 3], 3), fill_color=np.repeat([color_coal, color_ng], 3), color=np.repeat([color_coal, color_ng], 3), alpha=0.25, size=[ (10000000 / 10000 * size_factor)**0.5 + 2, (5000000 / 10000 * size_factor)**0.5 + 2, (1000000 / 10000 * size_factor)**0.5 + 2, ] * 2, ) source = ColumnDataSource(data=dict( x=[1, 1, 1, 0.3, 1, 1, 1, 0.3], y=[0.9, 1.1, 1.3, 1.55, 2.9, 3.1, 3.3, 3.55], text=["1M", "5M", "10M", label_coal, "1M", "5M", "10M", label_ng], )) labels = LabelSet( x="x", y="y", text="text", source=source, level="glyph", x_offset=0, y_offset=0, render_mode="css", ) p_legend.add_layout(labels) if web: p.legend.location = "bottom_right" p.legend.label_text_font_size = "12pt" hover = HoverTool( tooltips=[ ("Type", "@type"), (u"Tons CO\u2082", "@tons"), ], renderers=[circle], ) p.add_tools(hover) return_p = p else: p.legend.visible = False return_p = row(p_legend, p) return return_p
def test_attribution(self, name) -> None: p = bt.get_provider(getattr(bt, name)) assert p.attribution == ( '© <a href="http://downloads.esri.com/ArcGISOnline/docs/tou_summary.pdf">Esri</a>, ' 'Earthstar Geographics' )
def test_attribution(self, name) -> None: p = bt.get_provider(getattr(bt, name)) assert p.attribution == ( '© <a href="https://foundation.wikimedia.org/wiki/Maps_Terms_of_Use">Wikimedia Maps</a> contributors' )
def test_attribution(self, name) -> None: p = bt.get_provider(getattr(bt, name)) assert p.attribution == ( '© <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors' )
def SIF_Explorer_tab(): ################################# # Initialize all layers ################################# # Load from a save file if path.exists(LAYERS_FILE): with open(LAYERS_FILE, 'rb') as layers_file: us_county_layer, us_state_layer, world_grid_2_degree_layer = pickle.load(layers_file) # Load from scratch else: us_county_layer = US_County_Layer() us_state_layer = US_State_Layer() world_grid_2_degree_layer = US_World_Grid_2_Degree_Layer() # Save the layers to file with open(LAYERS_FILE, 'wb') as layers_file: layers = (us_county_layer, \ us_state_layer, world_grid_2_degree_layer) pickle.dump(layers, layers_file) # Want the custom layer to be new every time custom_shapes_layer = Custom_Shapes_Layer() world_grid_dynamic_layer = World_Grid_Dynamic_Layer() # Set the active layer to be the county layer active_layer = us_county_layer ################################# # Set up layer selector ################################# # Once a new layer is selected, use that layer to refresh the page # and all data def refresh_page(): # Get initial map details xs, ys, names = active_layer.get_map_details() if type(active_layer) != Custom_Shapes_Layer: # Obtain and update date boundaries start_date, end_date = active_layer.get_date_range() date_range_slider.start = start_date date_range_slider.end = end_date # Unpack the current range range_start, range_end = date_range_slider.value # Convert to SQL format range_start = utc_from_timestamp(range_start) range_end = utc_from_timestamp(range_end) # Get the initial sif values sifs = active_layer.get_data_for_date_range(range_start, range_end) # Dictionary to hold the data new_source_dict = dict( x= xs, y= ys, name= np.array(names), sifs= np.array(sifs)) # Update all source data values source.data = new_source_dict # Turn off custom layer custom_data_source.data = dict(x= np.array([]), y= np.array([]), name = np.array([])) else: # Turn off the other layers source.data = dict(x= np.array([]), y= np.array([]), name= np.array([]), sifs= np.array([])) # Safeguard - that at least one custom shape is drawn if (xs.size != 0): # Dictionary to hold the selected shape data new_source_dict = dict( x= xs, y= ys, name = np.array(names)) custom_data_source.data = new_source_dict # Trigger for when a new layer is selected def layer_selected(new): # We want to modify the overall active layer (not local to this func) nonlocal active_layer # Simple dictionary to switch out the active layer switcher = { 0 : custom_shapes_layer, 1 : us_state_layer, 2 : us_county_layer, 3 : world_grid_2_degree_layer, 4 : world_grid_dynamic_layer, } # Swap out the active layer active_layer = switcher.get(new, active_layer) # Fetch new dates, shapes, names, etc. and refresh the page refresh_page() # Define selection labels layer_selector = RadioButtonGroup( labels=["Custom", "US States", "US Counties", "World", "World (Dynamic)"], active=2) # Set up layer selection callback layer_selector.on_click(layer_selected) ################################# # Set up date range slider ################################# # Obtain date boundaries start_date, end_date = active_layer.get_date_range() # create a callback for when the date slider is changed def date_range_selected(attr, old, new): t0 = time.time() # Unpack the new range range_start, range_end = new # Convert to SQL format range_start = utc_from_timestamp(range_start) range_end = utc_from_timestamp(range_end) # Get the new day's data sifs = active_layer.get_data_for_date_range(range_start, range_end) # Update the sif values source.data["sifs"] = np.array(sifs) # Set the title of the map to reflect the selected date range p.title.text = "SIF Average: %s to %s" % (range_start, range_end) print("Took " + str(time.time() - t0) + " seconds to update") # Create the date slider date_range_slider = DateRangeSlider(title="Date Range: ", start=start_date, end=end_date, value=(START_DATE_INIT, END_DATE_INIT), step=1) # Assign the callback for when the date slider changes date_range_slider.callback_policy = "throttle" date_range_slider.callback_throttle = 200 date_range_slider.on_change('value_throttled', date_range_selected) ################################# # Set up the map and its source ################################# # Get initial map details xs, ys, names = active_layer.get_map_details() # Get the initial sif values sifs = active_layer.get_data_for_date_range(START_DATE_INIT, END_DATE_INIT) # Dictionary to hold the data source=ColumnDataSource(data = dict( x= np.array(xs), y= np.array(ys), name= np.array(names), sifs= np.array(sifs)) ) # Which tools should be available to the user TOOLS = "pan,wheel_zoom,reset,hover,save,tap" # Obtain map provider tile_provider = get_provider(Vendors.CARTODBPOSITRON_RETINA) # tile_options = {} # tile_options['url'] = 'https://mt1.google.com/vt/lyrs=m&x={x}&y={y}&z={z}' # tile_options['attribution'] = """ # Map tiles by <a href="http://stamen.com">Stamen Design</a>, under # <a href="http://creativecommons.org/licenses/by/3.0">CC BY 3.0</a>. # Data by <a href="http://openstreetmap.org">OpenStreetMap</a>, # under <a href="http://www.openstreetmap.org/copyright">ODbL</a>. # """ # mq_tile_source = WMTSTileSource(**tile_options) # Don't want the map to wrap around tile_provider.wrap_around = False # Configure the figure p = figure( title="SIF Average by County: %s" % end_date, tools=TOOLS, active_scroll = "wheel_zoom", x_axis_location=None, y_axis_location=None, tooltips=[ ("Name", "@name"), ("Average SIF", "@sifs") ], x_axis_type='mercator', y_axis_type='mercator', plot_height = 900, plot_width = 1100, output_backend="webgl", x_range=Range1d(-20000000, 20000000, bounds = 'auto')) # Add the map! p.add_tile(tile_provider) p.lod_threshold = None # No downsampling #p.lod_interval = 150 p.toolbar.logo = None # No logo p.grid.grid_line_color = None # No grid # Policy for hovering p.hover.point_policy = "follow_mouse" # Color mapper color_mapper = LinearColorMapper(palette=palette, low = SIF_MIN, high = SIF_MAX) color_transform = {'field': 'sifs', 'transform': color_mapper} # Patch all the information onto the map patch_renderer = p.patches('x', 'y', source=source, fill_color=color_transform, fill_alpha=0.9, line_color="white", line_width=0.1, selection_fill_alpha = 1.0, selection_fill_color = color_transform, nonselection_line_color="black", nonselection_fill_alpha=0.7, nonselection_fill_color= color_transform) p.title.text_font_size = '16pt' # Add a color bar ticker = FixedTicker(ticks=[-1,0,1,2]) color_bar = ColorBar(color_mapper=color_mapper, ticker = ticker, label_standoff=12, border_line_color=None, location=(0,0)) p.add_layout(color_bar, 'right') # Add zoom in / out tools zoom_in = ZoomInTool(factor=ZOOM_FACTOR) zoom_out = ZoomOutTool(factor=ZOOM_FACTOR) def range_changed(param, old, new): if (type(active_layer) == World_Grid_Dynamic_Layer): x1 = p.x_range.start x2 = p.x_range.end y1 = p.y_range.start y2 = p.y_range.end new_x1, new_y1 = to_lat_lon(y1, x1) new_x2, new_y2 = to_lat_lon(y2, x2) if (active_layer.range_changed(new_x1, new_y1, new_x2, new_y2)): refresh_page() #convert_shapes_to_mercator(np.array([[x1], [x2]]), #np.array([[y1], [y2]])) #print("(%s, %s) to (%s, %s)" % (x1, y1, x2, y2)) #40000000 # # p.callback_policy = "throttle" # p.callback_throttle = 200 p.x_range.on_change('end', range_changed) p.add_tools(zoom_in) p.add_tools(zoom_out) ################################# # Set up custom plot data ################################# # Data source for custom shapes custom_data_source = ColumnDataSource(data = \ dict(x= np.array([]), y= np.array([]), name=np.array([]))) # Patch the custom data onto the map p.patches('x', 'y', source=custom_data_source, line_color="darkslategray", line_width=1, fill_alpha=0.3, fill_color="lightgray") # On geometry selection # zoom = WheelZoomTool() # p.on_event() # p.add_tools(lasso) # p.on_event(SelectionGeometry, shape_drawn) ################################# # Set up time series ################################# def color_gen(): yield from itertools.cycle(time_pltt[10]) color = color_gen() def shape_drawn(event): # Check if more than one point # Otherwise a tap triggers this function if (type(event.geometry['x']) != float): # Notify the custom selection layer that this # shape was selected and obtain relevant info # custom_shapes_layer.patch_selected(event) # Change to the custom layer layer_selector.active = 0 layer_selected(0) # Notify the layer that this patch was created. active_layer.patch_created(event) # Clear all time series sif_series.renderers = [] # Update the title and get new data from the active layer sif_series.title.text, time_srs_src_list, names = \ active_layer.patch_clicked(source, None) # Plot each series returned for i in range(len(time_srs_src_list)): sif_series.scatter('date', 'sif', source=time_srs_src_list[i], color=time_pltt[10][i]) # Make sure the current shape is drawn refresh_page() def patch_clicked(event): """ When a patch is clicked, update the time series chart. """ # Clear all time series sif_series.renderers = [] # Update the title and get new data from the active layer sif_series.title.text, time_srs_src_list, names = \ active_layer.patch_clicked(source, event) # Plot each series returned for i in range(len(time_srs_src_list)): sif_series.scatter('date', 'sif', source=time_srs_src_list[i], color=time_pltt[10][i]) # Which tools should be available to the user for the timer series TOOLS = "pan,wheel_zoom,reset,hover,save" # Figure that holds the time-series sif_series = figure(plot_width=750, plot_height=400, x_axis_type='datetime', tools=TOOLS, title= "SIF Time-Series (Select a county...)", active_scroll = "wheel_zoom", tooltips=[ ("Day", "@date"), ("Average SIF", "@sif") ], x_axis_label = 'Date', y_axis_label = 'SIF Average', y_range = (SIF_MIN, SIF_MAX)) # Some font choices sif_series.title.text_font_size = '16pt' sif_series.xaxis.axis_label_text_font_size = "12pt" sif_series.yaxis.axis_label_text_font_size = "12pt" # Policy for hovering sif_series.hover.point_policy = "follow_mouse" # No logo sif_series.toolbar.logo = None # When a patch is selected, trigger the patch_time_series function p.on_event(Tap, patch_clicked) # On geometry selection lasso = LassoSelectTool(select_every_mousemove = False) p.add_tools(lasso) p.on_event(SelectionGeometry, shape_drawn) ################################# # TODO: Set up download area ################################# # def save_data(): # active_layer.save_data() # print("Button Clicked") # callback = active_layer.get_save_data_js_callback() button = Button(label="Save Data", button_type="success") # button.on_click(active_layer.save_data) #button.js_on_event(ButtonClick, callback) ################################# # Set up tab ################################# # The layout of the view layout = row(column(p, date_range_slider, layer_selector), column(sif_series, row(column(), button))) # Create tab using layout tab = Panel(child=layout, title = 'US Visualization') # Return the created tab return tab
data_2017_map['dot_size'].values[data_2017_map['dot_size']<0]=0.01 data_2017_map['dot_size'].values[data_2017_map['dot_size']>80]=80 #data_2017_map.sort_values(by='dot_size', ascending=False) output_file('map_of_personal_income.html') cds = ColumnDataSource(data_2017_map) hover = HoverTool(tooltips=[('City', '@City'), ('Zip Code', '@Zip_Code'), ('Avg AGI', '@Avg_AGI'), ('Avg Tax Liability', '@Avg_Tax_Liability')], mode='mouse') up = figure(title='Avg Personal Income in CA', plot_width=1000, plot_height=1000, x_axis_location=None, y_axis_location=None, tools=['pan', 'wheel_zoom', 'tap', 'reset', 'crosshair', hover]) tile_provider=get_provider(Vendors.CARTODBPOSITRON_RETINA) up.add_tile(tile_provider) mypalette=Category20b[20]+Category20c[20]+Spectral[4]+Plasma[256]+Viridis[256]+Inferno[256]+Magma[256] mapper = CategoricalColorMapper(factors=data_2017_map.County, palette=mypalette) scatter = up.circle('x', 'y', source=cds, size='dot_size', color={'field': 'City','transform': mapper}, alpha=.4, selection_color='black', nonselection_fill_alpha=.1, nonselection_fill_color='gray',) down = figure(title='Personal Income (Click bar below)', x_range=data_2017_map.County.unique(), plot_width=1000, plot_height=500, tools=['tap', 'reset'])
def create_us_map_tab(): "Factory for creating second tab of app: US Only Data" ## Data Sources source_df_confirmed, source_CDS = get_time_series_confirmed_US_data() source_CDS.data['number_per_capita'] = source_df_confirmed[ START_DATE_STRING] / source_df_confirmed['population'] ## Map color_mapper = log_cmap(field_name='number', palette=Spectral6, low=1, high=1e6) TOOLTIPS = [('County/Region', '@county'), ('State/Province', '@region'), ('Population', '@population'), ('Cases', '@number'), ('Cases Per Capita', '@number_per_capita')] map_figure = figure( title='Confirmed COVID-19 Cases in the United States', tooltips=TOOLTIPS, x_range=(-18367715, -6901808.43), y_range=(0, 13377019.78), x_axis_type='mercator', y_axis_type='mercator', active_scroll='wheel_zoom', ) tile_provider = get_provider(CARTODBPOSITRON) map_figure.add_tile(tile_provider) map_figure.circle(x='web_mercator_x', y='web_mercator_y', source=source_CDS, size='sizes', color=color_mapper) ## Colorbar color_bar = ColorBar(title='Num. Cases', title_standoff=20, color_mapper=color_mapper['transform'], label_standoff=20, width=8, location=(0, 0), ticker=LogTicker()) color_bar.formatter.use_scientific = False map_figure.add_layout(color_bar, 'right') ## Slider def slider_callback(attr, old, new): delta = datetime.timedelta(milliseconds=new) date = datetime.date(1970, 1, 1) + delta date_string = date.strftime('%Y-%m-%d') try: source_CDS.data['number'] = source_df_confirmed[date_string] source_CDS.data['sizes'] = source_df_confirmed[date_string].apply( scale) source_CDS.data['number_per_capita'] = source_df_confirmed[ date_string] / source_df_confirmed['population'] except KeyError: pass slider = DateSlider(title='Date', start=START_DATE, end=datetime.date.today(), step=1, value=START_DATE) slider.on_change('value', slider_callback) ## Data Table columns = [ TableColumn(field='county', title='County/Region'), TableColumn(field='region', title='State/Province'), TableColumn(field='population', title='Population'), TableColumn(field='number', title='Cases'), TableColumn(field='number_per_capita', title='Cases Per Capita'), ] data_table = DataTable( source=source_CDS, columns=columns, ) ## Cancel Selection Button def cancel_selection_callback(): source_CDS.selected.indices = [] cancel_selection_button = Button(label='Clear Selection', button_type='warning') cancel_selection_button.on_click(cancel_selection_callback) child = row([ column([slider, map_figure]), column([data_table, cancel_selection_button]) ]) return Panel(child=child, title='United States Map')
def test_attribution(self, name) -> None: p = bt.get_provider(getattr(bt, name)) assert p.attribution == xyz.OpenStreetMap.Mapnik.html_attribution
from bokeh.plotting import figure, show, output_file from bokeh.tile_providers import get_provider, Vendors output_file("tile_source.html") # create plot and add tools p = figure(x_range=(-2000000, 2000000), y_range=(1000000, 7000000), x_axis_type="mercator", y_axis_type="mercator") p.add_tile(get_provider(Vendors.CARTODBPOSITRON)) show(p)
def map_carbon_emission_bar( bus_info_and_emission, scenario_name, color_coal="black", color_ng="purple", us_states_dat=None, size_factor=1.0, ): """Makes map of carbon emissions, color code by fuel type. Size/area indicates emissions. :param dict us_states_dat: dictionary of state border lats/lons. If None, get from :func:`postreise.plot.plot_states.get_state_borders`. :param pandas.DataFrame bus_info_and_emission: info and emission of buses by :func:`combine_bus_info_and_emission`. :param str scenario_name: name of scenario for labeling. :param str color_coal: color assigned for coal :param str color_ng: color assigned for natural gas :param float size_factor: height scale for bars """ if us_states_dat is None: us_states_dat = get_state_borders() bus_map = project_bus(bus_info_and_emission) bus_map = group_zone(bus_map) a, b = project_borders(us_states_dat) # plotting adjustment constants ha = 85000 size_factor = size_factor * 0.02 bus_source = ColumnDataSource({ "x": bus_map["x"], "x2": bus_map["x"] + ha * 2, "y": bus_map["y"], "coaly": bus_map["y"] + bus_map["coal"] * size_factor, "ngy": bus_map["y"] + bus_map["ng"] * size_factor, }) # Set up figure tools: str = "pan,wheel_zoom,reset,hover,save" p = figure( title=scenario_name, tools=tools, x_axis_location=None, y_axis_location=None, plot_width=800, plot_height=800, ) p_legend = figure( x_axis_location=None, y_axis_location=None, toolbar_location=None, plot_width=200, plot_height=200, y_range=(0, 2), x_range=(0, 2), ) p.add_tile(get_provider(Vendors.CARTODBPOSITRON_RETINA)) # state borders p.patches(a, b, fill_alpha=0.0, line_color="black", line_width=2) # emissions bars width = 150000.0 alpha = 0.7 p.vbar( x="x2", bottom="y", top="coaly", width=width, color=color_coal, source=bus_source, alpha=alpha, ) p.vbar( x="x", bottom="y", top="ngy", width=width, color=color_ng, source=bus_source, alpha=alpha, ) bus_map = pd.DataFrame(bus_map) # citation fields cit_x = [] cit_y = [] cit_text = [] # constants for adjustments of text labels va = 1000 m = 1000000 # x values are offset so vbars are side by side. cit_x.append([i - ha * 1.5 for i in bus_map.x.values.tolist()]) cit_x.append([i + ha for i in bus_map.x.values.tolist()]) cit_y.append( np.add( [i + va * 2 for i in bus_map.y.values.tolist()], [i * size_factor for i in bus_map.ng.values.tolist()], )) cit_y.append( np.add( [i + va * 2 for i in bus_map.y.values.tolist()], [i * size_factor for i in bus_map.coal.values.tolist()], )) cit_text.append( [round(num, 1) for num in [i / m for i in bus_map.ng.values.tolist()]]) cit_text.append([ round(num, 1) for num in [i / m for i in bus_map.coal.values.tolist()] ]) for j in range(0, len(cit_x)): for i in range(0, len(cit_x[j])): citation = Label( x=cit_x[j][i], y=cit_y[j][i], x_units="data", y_units="data", text_font_size="20pt", text=str(cit_text[j][i]), render_mode="css", border_line_color="black", border_line_alpha=0, background_fill_color="white", background_fill_alpha=0.8, ) p.add_layout(citation) # custom legend p_legend.square(1, 1, fill_color="white", color="white", size=600) p_legend.square(1, 1, fill_color="white", color="black", size=400) p_legend.square(0.4, 0.8, fill_color="black", color="black", size=40, alpha=0.7) p_legend.square(0.4, 0.2, fill_color="purple", color="purple", size=40, alpha=0.7) source = ColumnDataSource(data=dict( x=[0.7, 0.7, 0.05], y=[0.6, 0.1, 1.5], text=["Coal", "Natural Gas", "Emissions (Million Tons)"], )) labels = LabelSet( x="x", y="y", text="text", source=source, level="glyph", x_offset=0, y_offset=0, render_mode="css", text_font_size="20pt", ) p_legend.add_layout(labels) return row(p_legend, p)
def show_data_visualization(source): """Show the data visualization in a webpage.""" # Set up the plot window # Another map tile option: Vendors.STAMEN_TERRAIN) tile_provider = get_provider(Vendors.CARTODBPOSITRON) sf_lat = (37.73, 37.81) sf_long = (-122.47, -122.359720) sf_xrange = [long_to_merc(long) for long in sf_long] sf_yrange = [lat_to_merc(lat) for lat in sf_lat] plot_options = dict(plot_width=1000, plot_height=800, title='Hourly Net Change in Bikes Docked') p = figure(x_range=sf_xrange, y_range=sf_yrange, x_axis_type="mercator", y_axis_type="mercator", tooltips=[("Net Change", "@net_change"), ("ID", "@id"), ("Station", "@name")], **plot_options) p.add_tile(tile_provider) # Add a color bar palette = RdBu[11] palette.reverse() color_mapper = LinearColorMapper(palette=palette, low=-30, high=30) color_bar = ColorBar(color_mapper=color_mapper, ticker=AdaptiveTicker(), label_standoff=12, border_line_color=None, location=(0,0)) p.add_layout(color_bar, 'right') # Add the station points as circles p.circle(x='x', y='y', size=15, fill_color={'field': 'net_change', 'transform': color_mapper}, fill_alpha=0.8, source=source, ) # add two sliders: one for date, one for hour start_date, end_date = datetime.date(2019,9,1), datetime.date(2019,9,30) date_fmt = '%Y%m%d' # Out of simplicity, setting the dates to ints to make the slider work here date_slider = Slider(start=int(start_date.strftime(date_fmt)), end=int(end_date.strftime(date_fmt)), step=1, value=int(start_date.strftime(date_fmt)), title='Date') hour_slider = Slider(start=0, end=23, value=9, step=1, title="Hour of Day") date_callback = CustomJS(args=dict(source=source), code=""" var data = source.data; var curr_date = cb_obj.value; data['net_change'] = data[curr_date + ' ' + data['curr_hr'][0]]; source.change.emit(); """) hour_callback = CustomJS(args=dict(source=source), code=""" var data = source.data; function pad(n, width, z) { z = z || '0'; n = n + ''; return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n; } var curr_hr = String(cb_obj.value).padStart(2, '0'); data['curr_hr'][0] = curr_hr; data['net_change'] = data[data['curr_date'][0] + ' ' + curr_hr]; source.change.emit(); """) output_file("net_bikes.html") date_slider.js_on_change('value', date_callback) hour_slider.js_on_change('value', hour_callback) # Display on the page show( column( row( widgetbox(date_slider), widgetbox(hour_slider), ), p ) )
def cluster_gui(doc): global s2, s1, old_indices old_indices = [] output_file("tile.html") tile_provider = get_provider(CARTODBPOSITRON) x = [] y = [] name = [] global fig03 fig03 = figure( plot_width=400, plot_height=400, tools=["box_zoom", "wheel_zoom", "reset", "save"], title="Waveforms from current selection", ) for i, st in enumerate(stations): xm, ym = merc(st.lat, st.lon) x.append(xm) y.append(ym) name.append(st.nsl_string()) # create first subplot plot_width = 400 plot_height = 400 d = num.ones_like(x) s1 = ColumnDataSource(data=dict(x=x, y=y, ind=d, name=name)) # range bounds supplied in web mercator coordinates fig01 = figure( x_axis_type="mercator", y_axis_type="mercator", plot_width=plot_width, plot_height=plot_height, tools=[ "lasso_select", "box_select", "reset", "save", "box_zoom", "wheel_zoom" ], title="Select", ) fig01.add_tile(tile_provider) fig01.scatter("x", "y", source=s1, alpha=0.6, size=8) # create second subplot s2 = ColumnDataSource(data=dict(x=[], y=[], ind=[], name=[])) color_mapper = LinearColorMapper(palette='Magma256', low=1, high=100) fig02 = figure( x_axis_type="mercator", y_axis_type="mercator", plot_width=plot_width, plot_height=plot_height, x_range=(num.min(x), num.max(x)), y_range=(num.min(y), num.max(y)), tools=["box_zoom", "wheel_zoom", "reset", "save"], title="Stations selected for Array", ) fig02.add_tile(tile_provider) fig02.scatter("x", "y", source=s2, alpha=1, color={ 'field': 'ind', 'transform': color_mapper }, size=8) x_event, y_event = merc(event.lat, event.lon) fig01.scatter(x_event, y_event, size=8, color="red") fig02.scatter(x_event, y_event, size=8, color="red") columns = [ TableColumn(field="x", title="X axis"), TableColumn(field="y", title="Y axis"), TableColumn(field="ind", title="indices"), TableColumn(field="name", title="name"), ] table = DataTable( source=s2, columns=columns, width=400, height=600, sortable=True, selectable=True, editable=True, ) source_count = 0 callback_slider = CustomJS(code=""" source_count = slider.value; """) global slider slider = Slider(start=1, end=100, value=1, step=1, title="Array number") slider.js_on_change('value', callback_slider) s1.selected.js_on_change( "indices", CustomJS(args=dict(s1=s1, s2=s2, s3=slider, table=table), code=""" var inds = cb_obj.indices; var d1 = s1.data; var d2 = s2.data; const A = s3.value; for (var i = 0; i < inds.length; i++) { d2['x'].push(d1['x'][inds[i]]) d2['y'].push(d1['y'][inds[i]]) d2['name'].push(d1['name'][inds[i]]) d2['ind'].push(A) } s2.change.emit(); table.change.emit(); s2.data = s2.data; var inds = source_data.selected.indices; var data = source_data.data; var out = "name, x, y, ind\\n"; for (i = 0; i < inds.length; i++) { out += data['name'][inds[i]] + "," + data['x'][inds[i]] + "," + data['y'][inds[i]] + "," + data['ind'][inds[i]] + "\\n"; } var file = new Blob([out], {type: 'text/plain'}); """), ), savebutton = Button(label="Save", button_type="success") savebutton.callback = CustomJS( args=dict(source_data=s1), code=""" var inds = source_data.selected.indices; var data = source_data.data; var out = "name, x, y, ind\\n"; for (i = 0; i < inds.length; i++) { out += data['name'][inds[i]] + "," + data['x'][inds[i]] + "," + data['y'][inds[i]] + "," + data['ind'][inds[i]] + "\\n"; } var file = new Blob([out], {type: 'text/plain'}); var elem = window.document.createElement('a'); elem.href = window.URL.createObjectURL(file); elem.download = 'arrays.txt'; document.body.appendChild(elem); elem.click(); document.body.removeChild(elem); """, ) tooltips = [ ("X:", "@x"), ("Y:", "@y"), ("Array:", "@ind"), ("Station:", "@name"), ] fig01.add_tools(HoverTool(tooltips=tooltips)) fig02.add_tools(HoverTool(tooltips=tooltips)) fig03.add_tools(HoverTool(tooltips=tooltips)) endbutton = Button(label="End and proceed", button_type="success") endbutton.on_click(button_callback) clearbutton = Button(label="Clear all", button_type="success") clearbutton.on_click(clearbuttonlast_callback) clearbuttonlast = Button(label="Clear last selection", button_type="success") clearbuttonlast.on_click(clearbuttonlast_callback) clearbuttonone = Button(label="Remove one from list", button_type="success") clearbuttonone.on_click(clearbuttonone_callback) b = Button(label="Reset all plots") b.js_on_click( CustomJS(code="""\ document.querySelectorAll('.bk-tool-icon-reset[title="Reset"]').forEach(d => d.click()) """)) #layout = grid([fig01, fig02, table, fig03, slider, clearbuttonlast, clearbutton, savebutton, endbutton], ncols=3, nrows=4) global text_input text_input = TextInput(value="1", title="Array number:") buttons = column(clearbuttonlast, clearbuttonone, clearbutton, savebutton, endbutton) inputs = column(text_input, slider) layout_grid = layout([fig01, fig02, buttons], [fig03, inputs, table]) #curdoc().add_root(layout) cluster_result = [] doc.add_root(layout_grid) #global session #session = push_session(curdoc()) #curdoc().add_periodic_callback(update, 100) #session.show(layout) doc.add_periodic_callback(update, 900) curdoc().title = "Array selection"
def map_plot(data, features_titles, output_choice_selection): full_source = ColumnDataSource(data) # a CDS version of the data obtained # a CDS version of the data to plot, modifiable by geo dropdowns, to be produced in the callback num_instances = len(data) # Split the columns with the values to plot to build their marks and title geo_columns = [ 'practice_code', 'practice', 'ccg', 'region', 'sub_region', 'longitudemerc', 'latitudemerc' ] value_columns = [h for h in data.columns if h not in geo_columns] # Assert gender-age as the second value (to be marked by size) if value_columns[0] in ['gender', 'age_groups', 'gender_age_groups']: value_columns = list(reversed(value_columns)) first_value = value_columns[0] features_marks = {first_value: 'Color'} hover_first_value = '@{fv}'.format(fv=first_value) # Normalized size values for the second feature if such exists if len(value_columns) == 2: second_value = value_columns[1] sv_column = np.array(data[second_value]) svinterp = np.interp(sv_column, (sv_column.min(), sv_column.max()), (0, 2000)) #was 10 for size if second_value == 'deprivation': svinterp = max(svinterp) - svinterp norm_header = second_value + '_norm' data[norm_header] = svinterp features_marks[second_value] = 'Size' source = ColumnDataSource(data) filter = IndexFilter(indices=list(data.index)) view = CDSView(source=source, filters=[filter]) plot = figure(x_axis_type="mercator", y_axis_type="mercator", plot_height=700, plot_width=700) plot.title.text_color = 'purple' tooltips = [('Practice', '@practice'), ('CCG', '@ccg'), (first_value.capitalize(), hover_first_value)] # Title title_parts = [] for feature, title in features_titles.items(): title_part = ' {m}: {t}'.format(m=features_marks[feature], t=title) title_parts.append(title_part) title_parts = list(reversed(title_parts)) for title_part in title_parts: plot.add_layout( Title(text=title_part, text_font_size="10pt", text_color='purple'), 'above') # Color mapper palette = list(reversed(brewer['YlOrRd'][9])) if first_value == 'deprivation': low_boundary, high_boundary = max(source.data[first_value]), min( source.data[first_value]) else: high_boundary, low_boundary = max(source.data[first_value]), min( source.data[first_value]) mapper = linear_cmap(field_name=first_value, palette=palette,\ low=low_boundary, high=high_boundary) #Spectral6 # add map tiles map_tile = get_provider(Vendors.CARTODBPOSITRON) plot.add_tile(map_tile) if len(value_columns) == 2: hover_second_value = '@{sv}'.format(sv=second_value) tooltips.append((second_value.capitalize(), hover_second_value)) plot.circle(source=source, x='latitudemerc',y='longitudemerc',\ hover_color='red', color=mapper,radius = norm_header, alpha=0.2,\ view = view) else: plot.circle(source=source, view=view, x='latitudemerc',y='longitudemerc',\ hover_color='red', color=mapper) hover = HoverTool(tooltips=tooltips) color_bar = ColorBar(color_mapper=mapper['transform'], width=8, location=(0, 0)) plot.add_layout(color_bar, 'right') plot.add_tools(hover) # Plot widgets selection callback callback = CustomJS(args=dict(source=source, filter=filter), code=''' var indices = [] var selected_value = cb_obj.value if (selected_value=='All') { indices = source.index console.log ('all ccgs selected') } else { console.log('The selected area is ' + selected_value) for (var i = 0; i < source.get_length(); i++) { // console.log(i, source.data['ccg'][i], cb_obj.value) if ((source.data['ccg'][i] == selected_value) || (source.data['region'][i] == selected_value)\ || (source.data['sub_region'][i] == selected_value)) { indices.push(i) } } } filter.indices = indices source.change.emit() ''') select_ccg = Select(title='CCG', value=ccgs[0], options=ccgs, width=120) select_ccg.js_on_change('value', callback) select_region = Select(title='Region', value=regions[0], options=regions, width=120) select_region.js_on_change('value', callback) select_sub_region = Select(title='Sub-Region', value=sub_regions[0], options=sub_regions, width=120) select_sub_region.js_on_change('value', callback) view = CDSView(source=source, filters=[filter]) if output_choice_selection == 'Notebook': output_notebook() elif output_choice_selection == 'HTML File': output_file('plot.html') show(row(column(select_region, select_sub_region, select_ccg), plot))
def test_unknown_vendor(self): with pytest.raises(ValueError): bt.get_provider("This is not a valid tile vendor")
def update_map(map_geodf): # filter map_geodf map_geodf_img = map_geodf.copy().dropna(subset=["img_sd"]) map_geodf_noimg = map_geodf.copy()[map_geodf["img_sd"].isna()] # create a geodatasource geosource_img = GeoJSONDataSource(geojson=map_geodf_img.to_json()) geosource_noimg = GeoJSONDataSource(geojson=map_geodf_noimg.to_json()) # Description from points TOOLTIPS1 = """ <div style="margin: 5px; width: 300px" > <img src="@img_sd" alt="@img_sd" height=200 style="margin: 0px;" border="2" ></img> <h3 style='font-size: 10px; font-weight: bold;'>@id</h3> <p style='font-size: 10px; font-weight: light; font-style: italic;'>@creator</p> </div> """ TOOLTIPS2 = """ <div style="margin: 5px; width: 300px" > <h3 style='font-size: 10px; font-weight: bold;'>@id</h3> <p style='font-size: 10px; font-weight: light; font-style: italic;'>@creator</p> </div> """ callback_tp = CustomJS(code=""" var tooltips = document.getElementsByClassName("bk-tooltip"); for (var i = 0, len = tooltips.length; i < len; i ++) { tooltips[i].style.top = ""; tooltips[i].style.right = ""; tooltips[i].style.bottom = "0px"; tooltips[i].style.left = "0px"; } """) # Base map maps = figure( x_axis_type="mercator", y_axis_type="mercator", plot_width=1400, plot_height=900, toolbar_location=None, ) tile_provider = get_provider(Vendors.CARTODBPOSITRON_RETINA) maps.add_tile(tile_provider) # construct points and wedges from hover viewcone1 = maps.patches( xs="xs", ys="ys", source=geosource_img, fill_color="white", fill_alpha=0, line_color=None, hover_alpha=0.7, hover_fill_color="grey", hover_line_color="grey", ) viewcone2 = maps.patches( xs="xs", ys="ys", source=geosource_noimg, fill_color="white", fill_alpha=0, line_color=None, hover_alpha=0.7, hover_fill_color="grey", hover_line_color="grey", ) point_noimg = maps.circle( x="lat2", y="lng2", source=geosource_noimg, size=7, fill_color="orange", fill_alpha=0.5, line_color="dimgray", ) point_img = maps.circle( x="lat2", y="lng2", source=geosource_img, size=7, fill_color="orange", fill_alpha=0.5, line_color="dimgray", ) # create a hovertool h1 = HoverTool( renderers=[point_img], tooltips=TOOLTIPS1, mode="mouse", show_arrow=False, callback=callback_tp, ) h2 = HoverTool( renderers=[point_noimg], tooltips=TOOLTIPS2, mode="mouse", show_arrow=False, callback=callback_tp, ) maps.add_tools(h1, h2) maps.toolbar.active_scroll = maps.select_one(WheelZoomTool) maps.xaxis.major_tick_line_color = None maps.xaxis.minor_tick_line_color = None maps.yaxis.major_tick_line_color = None maps.yaxis.minor_tick_line_color = None maps.xaxis.major_label_text_font_size = "0pt" maps.yaxis.major_label_text_font_size = "0pt" return maps
import pandas as pd import numpy as np from sklearn.cluster import KMeans from scipy.spatial.distance import cdist from sklearn.cluster import SpectralClustering import networkx as nx from sklearn.preprocessing import MinMaxScaler from sklearn.cluster import OPTICS #import des modules bokeh from bokeh.plotting import figure from bokeh.models import HoverTool, ColumnDataSource from bokeh.tile_providers import get_provider tuile = get_provider('CARTODBPOSITRON_RETINA') import warnings warnings.filterwarnings("ignore") # Lecture du dataframe nettoyé df_ville = pd.read_csv('df_paris_bokeh.csv', sep=';') #Conversion des données epsg:4326 en espg:3857 ##Conversion déjà faite dans le csv de départ. Pour un nv fichier, appliquer ##le code ci-dessous #k=6378137 #df_ville['X'] = df_ville['X'].apply(lambda x: x*(k * np.pi / 180.0)) #df_ville['Y'] = df_ville['Y'].apply(lambda x: np.log(np.tan((90 + x) * np.pi / 360.0)) * k) ####################################################################### # Sélection des paramètres utilisateur
def visualise(self, map, trajects, score_csv): """ method that creates a visual representation of the given trajects """ # load Station data and store the x-coordinates, y-coordinates and the station names in seperate lists. merc_y = [] merc_x = [] stations = [] for station in map.stations: stations.append(map.stations[station].name) new_coord = self.create_coordinates(float(map.stations[station].x), float(map.stations[station].y)) merc_y.append(float(new_coord[1])) merc_x.append(float(new_coord[0])) # convert x- and y-lists to numpy array so they can be used in bokeh longitude = np.array(merc_y) latitude = np.array(merc_x) N = 4000 # save data in a variable for later use source = ColumnDataSource(data=dict(latitude=latitude, longitude=longitude, stations=stations)) # output to html-file output_file("color_scatter.html", title="color_scatter.py example", mode="cdn") # retrieves a map which serves as a background for the plot tile_provider = get_provider(CARTODBPOSITRON) # create a new plot with the specified tools, and explicit ranges TOOLS = "pan,wheel_zoom,box_zoom,reset,box_select,lasso_select" p = figure(x_range=(400000, 500000), y_range=(6700000, 7000000), x_axis_type="mercator", y_axis_type="mercator") font = 1 # adds the background to the plot p.add_tile(tile_provider) # define colors for the different routes colors = ['red', 'yellow', 'green', 'black', 'blue', 'orange', 'purple', 'pink', 'lawngreen', 'teal', 'saddlebrown', 'gold', 'magenta', 'silver'] # creates a line, representing a traject for each of the given trajects for values in trajects.values(): x_list = [] y_list = [] for value in values: if value in map.stations: new_coord = self.create_coordinates(float(map.stations[value].x), float(map.stations[value].y)) x_list.append(float(new_coord[1])) y_list.append(float(new_coord[0])) color = colors.pop(0) colors.append(color) p.line(y_list, x_list, line_width=2, color=color, legend_label=f"{values[0]} || {values[-1]}") # legend settings p.legend.location = 'top_left' p.legend.click_policy="hide" # add a circle for each of the stations in the given map p.circle(latitude, longitude) # adds name-labels to the circles labels = LabelSet(x='latitude', y='longitude', text='stations', text_font_size='5pt', level='glyph', x_offset=5, y_offset=5, source=source, render_mode='canvas') p.add_layout(labels) # show the results show(p) # make histogram of the "..-scores.csv" self.histogram(score_csv)
'modified_buffalo_assessment_2020-2021.csv') df = load_data(uri) # Initial Data x_range = (df['x'].min(), df['x'].max()) y_range = (df['y'].min(), df['y'].max()) date_range = (df['DEED YEAR'].min(), df['DEED YEAR'].max()) initial_date = (2013, 2019) df_temp = df[(df['DEED YEAR'] >= initial_date[0]) & (df['DEED YEAR'] <= initial_date[1])] df_temp = df_temp[(df_temp['PROPERTY CLASS'] >= 200) & (df_temp['PROPERTY CLASS'] < 300)] source = ColumnDataSource(df_temp) # Initialize Figure tile_provider = get_provider(CARTODBPOSITRON_RETINA) # tile_provider = get_provider(ESRI_IMAGERY) p = figure( x_range=x_range, y_range=y_range, x_axis_type="mercator", y_axis_type="mercator", aspect_ratio=.9, sizing_mode='scale_both', align='center', output_backend="webgl", ) p.add_tile(tile_provider) p.add_tools( HoverTool(tooltips=[
import datetime as dt from math import sqrt import numpy as np import pandas as pd from bokeh import palettes, tile_providers from bokeh.layouts import column, row from bokeh.models import PanTool, ZoomInTool, ZoomOutTool, ResetTool, HoverTool, Range1d, LinearAxis, Title from bokeh.plotting import figure from .utils import tooltip, make_tools from ..frame import present from ...stoats.names import DISTANCE_KM, LOCAL_TIME, TIMESPAN_ID, TIME, CLIMB_DISTANCE, ELEVATION_M, CLIMB_ELEVATION, \ SPHERICAL_MERCATOR_X, SPHERICAL_MERCATOR_Y, LATITUDE, LONGITUDE, ACTIVE_DISTANCE, ACTIVE_TIME, TOTAL_CLIMB STAMEN_TERRAIN = tile_providers.get_provider( tile_providers.Vendors.STAMEN_TERRAIN) # todo - make selection of hover tool with name='with_hover' universal def subtract(a, c, key, col): cols = [key, col] limit = min(a[key].max(), c[key].max()) a = a.loc[a[key] <= limit, cols] c = c.loc[c[key] <= limit, cols] both = a.merge(c, how='outer', on=key, sort=True, suffixes=('_a', '_c')) both.interpolate(inplace=True, limit_direction='both') return pd.DataFrame({ col: both[col + '_a'] - both[col + '_c'], key: both[key] })
def test_attribution(self, name): p = bt.get_provider(getattr(bt, name)) assert p.attribution == ( '© <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors,' '© <a href="https://cartodb.com/attributions">CartoDB</a>')
df = df.set_index('created_at') # this map is initialized to include the whole earth plot = figure(plot_width=1000, plot_height=550, x_range=(-20000000, 20000000), y_range=(-7000000, 7000000), x_axis_type="mercator", y_axis_type="mercator", tools="hover, pan, box_zoom, wheel_zoom, reset", tooltips=[('user id', '@user_id'), ('game', '@game'), ('location', '@name'), ('followers', '@followers_count')]) # add the tile from CARTOBPOSITRON database CARTODBPOSITRON = get_provider(Vendors.CARTODBPOSITRON) plot.add_tile(CARTODBPOSITRON) # create a column data source source = ColumnDataSource( data={ 'x': df.merc_x, 'y': df.merc_y, 'size': df.circle_size, 'name': df.name, 'user_id': df.tweet_user_id, 'followers_count': df.followers_count, 'game': df.game, 'color': df.game_colors })
def test_url(self, name): p = bt.get_provider(getattr(bt, name)) assert p.url == _STAMEN_URLS[name]
def test_url(self, name) -> None: p = bt.get_provider(getattr(bt, name)) assert p.url == _OSM_URLS[name]
def sidebar(): selectDataSource = st.sidebar.selectbox('Choose your preferred DataSource', ('-', 'John Hopkins')) if selectDataSource == 'John Hopkins': # load csv with CCSE Data df_confirmed_cases = pd.read_csv( 'https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv', error_bad_lines=False) df_deaths = pd.read_csv( 'https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_deaths_global.csv', error_bad_lines=False) df_recovered = pd.read_csv( 'https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_recovered_global.csv', error_bad_lines=False) selectVisualization = st.sidebar.selectbox( 'Which visualization do you want to look at?', ('-', 'line chart', 'world map')) if selectVisualization == 'line chart': countryList = df_confirmed_cases['Country/Region'].tolist() countryList = list(set(countryList)) countryList.sort() selectCountry = st.sidebar.selectbox( 'Please choose your Country/Region', countryList) provinceList = df_confirmed_cases.loc[ df_confirmed_cases['Country/Region'] == selectCountry]['Province/State'].tolist() if provinceList != [np.nan]: province_available = True provinceList = df_confirmed_cases.loc[ df_confirmed_cases['Country/Region'] == selectCountry].fillna(0)['Province/State'].tolist() for i in range(len(provinceList)): if provinceList[i] == 0: provinceList[i] = selectCountry provinceList.sort() selectProvince = st.sidebar.selectbox( 'Please choose your Province/State', provinceList) else: province_available = False datestrList = list(df_confirmed_cases.loc[:, '1/22/20':]) x = [] for date in datestrList: datetime_obj = datetime.strptime(date, '%m/%d/%y') # datetime_obj = np.datetime64(datetime_obj) x.append(datetime_obj) p = figure( title='line chart', x_axis_label='Date', x_axis_type='datetime', # x_range = x, y_axis_label='Number of persons') ckb_cc = st.sidebar.checkbox('cofirmed cases', value=True) if ckb_cc: # st.write(df_confirmed_cases) # just printing df - later i want to produce a chart if province_available == False: y_cc = list(df_confirmed_cases.loc[ df_confirmed_cases['Country/Region'] == selectCountry].loc[:, '1/22/20':].iloc[0]) else: if selectCountry == selectProvince: df_country_cc = df_confirmed_cases.loc[( df_confirmed_cases['Country/Region'] == selectCountry)].fillna(selectCountry) y_cc = list(df_country_cc.loc[ (df_country_cc['Country/Region'] == selectCountry) & (df_country_cc['Province/State'] == selectProvince)].loc[:, '1/22/20':].iloc[0]) else: y_cc = list(df_confirmed_cases.loc[ (df_confirmed_cases['Country/Region'] == selectCountry) & (df_confirmed_cases['Province/State'] == selectProvince)].loc[:, '1/22/20':].iloc[0]) p.line(x, y_cc, legend='confirmed cases', line_width=2) ckb_d = st.sidebar.checkbox('deaths', value=True) if ckb_d: # st.write(df_deaths) if province_available == False: y_d = list( df_deaths.loc[df_deaths['Country/Region'] == selectCountry].loc[:, '1/22/20':].iloc[0]) else: if selectCountry == selectProvince: df_country_d = df_deaths.loc[( df_deaths['Country/Region'] == selectCountry )].fillna(selectCountry) y_d = list(df_country_d.loc[ (df_country_d['Country/Region'] == selectCountry) & (df_country_d['Province/State'] == selectProvince )].loc[:, '1/22/20':].iloc[0]) else: y_d = list(df_deaths.loc[ (df_deaths['Country/Region'] == selectCountry) & (df_deaths['Province/State'] == selectProvince)]. loc[:, '1/22/20':].iloc[0]) p.line(x, y_d, legend='deaths', line_width=2, color='red') if selectCountry != 'Canada': ckb_r = st.sidebar.checkbox('recovered', value=True) if ckb_r: if province_available == False: y_r = list(df_recovered.loc[ df_recovered['Country/Region'] == selectCountry].loc[:, '1/22/20':].iloc[0]) else: if selectCountry == selectProvince: df_country_r = df_recovered.loc[( df_recovered['Country/Region'] == selectCountry )].fillna(selectCountry) y_r = list(df_country_r.loc[( df_country_r['Country/Region'] == selectCountry ) & (df_country_r['Province/State'] == selectProvince)].loc[:, '1/22/20':].iloc[0]) else: y_r = list(df_recovered.loc[( df_recovered['Country/Region'] == selectCountry ) & (df_recovered['Province/State'] == selectProvince)].loc[:, '1/22/20':].iloc[0]) p.line(x, y_r, legend='recovered', line_width=2, color='green') # st.write(df_recovered) st.bokeh_chart(p) if selectVisualization == 'world map': # implemet world map visualization with circles to hover over selectDate = st.sidebar.date_input( 'On which day would you like to see the map?', datetime.today() - timedelta(days=1)) tile_provider = get_provider(Vendors.CARTODBPOSITRON) p = figure(x_range=(-17000000, 17000000), y_range=(-6000000, 8000000), x_axis_type="mercator", y_axis_type="mercator", plot_width=800, plot_height=400) p.add_tile(tile_provider) for i in range(len(df_confirmed_cases)): lat = df_confirmed_cases.at[i, 'Lat'] lon = df_confirmed_cases.at[i, 'Long'] x_merc, y_merc = latlong2merc(lat, lon) p.circle(x=x_merc, y=y_merc, size=10, color='blue') st.bokeh_chart(p)
def test_copies(self, name) -> None: p1 = bt.get_provider(getattr(bt, name)) p2 = bt.get_provider(getattr(bt, name)) assert p1 is not p2
from bokeh.layouts import column from bokeh.plotting import figure, show, output_file from bokeh.tile_providers import get_provider, Vendors output_file("tile_smoothing.html") # range bounds supplied in web mercator coordinates p1 = figure(x_range=(-2000000, 6000000), y_range=(-1000000, 7000000), x_axis_type="mercator", y_axis_type="mercator", title='Smoothed') p2 = figure(x_axis_type="mercator", y_axis_type="mercator", title='Non-smoothed') # Link axes p2.x_range = p1.x_range p2.y_range = p1.y_range # Add smoothed tiles (the default) tile_provider = get_provider(Vendors.CARTODBPOSITRON) r1 = p1.add_tile(tile_provider) # Add non-smoothed tile r2 = p2.add_tile(tile_provider, smoothing=False) show(column(p1, p2))