def plot_curve( func: Callable[[np.ndarray], np.ndarray] = lambda x: 1 + (x - 2) ** 2, x_min: int = 0, x_max: int = 5, renderer: hv.renderer = hv.renderer("bokeh"), ): xs = np.linspace(x_min, x_max, 100) ys = [func(x) for x in xs] curve = hv.Curve((xs, ys), "x", hv.Dimension("f(x)"), label="Graph of f") curve.opts(opts.Curve(height=600, width=900, line_width=2.50, tools=["hover"])) # Create plot and save it as html file. We create the plot depending on the input # parameter renderer either via bokeh or via plotly. if renderer == "bokeh": renderer = hv.renderer("bokeh") # Using renderer save renderer.save(curve, "bokeh") elif renderer == "plotly": renderer = hv.renderer("plotly").get_plot(curve).state plotly.offline.plot(renderer, filename="plotly.html") elif renderer == "online": hv.save(curve, 'browse_me.html', )
def hv_bokeh(): import holoviews as hv hv.renderer('bokeh') prev_backend = hv.Store.current_backend hv.Store.current_backend = 'bokeh' yield hv.Store.current_backend = prev_backend
def hv_mpl(): import holoviews as hv hv.renderer('matplotlib') prev_backend = hv.Store.current_backend hv.Store.current_backend = 'matplotlib' yield hv.Store.current_backend = prev_backend
def explicitPathHoloviewsGraph(): hv.extension('bokeh') #%opts Graph [width=400 height=400] N = 8 node_indices = np.arange(N) #using index as indicator of the node number #source reveals the point of departure a1 source = np.zeros( N ) #every edge starts from node 0 - numpy array of zeros : [0. 0. 0. 0. 0. 0. 0. 0.] #target reveals the point of arrival a2 target = node_indices #numpy array of range : [0 1 2 3 4 5 6 7] padding = dict(x=(-1.2, 1.2), y=(-1.2, 1.2)) #X and Y showed scale on the cartesian table simple_graph = hv.Graph(((source, target), )).redim.range(**padding) def bezier(start, end, control, steps=np.linspace(0, 1, 100)): return (1 - steps)**2 * start + 2 * ( 1 - steps) * steps * control + steps**2 * end x, y = simple_graph.nodes.array([0, 1]).T paths = [] for node_index in node_indices: ex, ey = x[node_index], y[node_index] paths.append( np.column_stack([bezier(x[0], ex, 0), bezier(y[0], ey, 0)])) bezier_graph = hv.Graph( ((source, target), (x, y, node_indices), paths)).redim.range(**padding) hv.renderer('bokeh').save(bezier_graph, 'out')
def update_hist(self): hv.extension("matplotlib") dcrop = (self.da_masked * self.da_zone.sel(id=self.id_i)).isel(step=self.step) dcrop.name = self.da.name var_name = self.da.name if self.levels: hv_img = hv.Image(hv.Dataset(dcrop), kdims=["longitude", "latitude" ]).opts(colorbar=True, color_levels=self.levels, cmap=self.colors) html_map = hv.renderer("matplotlib").html(hv_img) else: hv_img = hv.Image(hv.Dataset(dcrop), kdims=["longitude", "latitude"]).opts(colorbar=True, color_levels=30) html_map = hv.renderer("matplotlib").html(hv_img) # Si besoin de specifier le range : hv_img.redim.__getattribute__("range")(**{var_name:(self.vmin,self.vmax)})) dstack = dcrop.stack(z=("latitude", "longitude")).reset_index("z") dstack["z"] = range(len(dstack.z)) dstack.name = self.da.name hv_dst = hv.Dataset(dstack) k = histogram(hv_dst, dynamic=True, name="Test") html = ''' <h4> Histogramme sur {} </h4> de {}'''.format( self.hist_name, self.variable) self.html2.value = html + hv.renderer("matplotlib").html(k) + html_map
def get_url(obj, path_): """Saves obj in path and returns an object with the url.""" uuid_plot = path_ + str(uuid.uuid4()) try: hv.renderer('bokeh').save(obj, uuid_plot) plot_path = '/geppetto/{}.html'.format( uuid_plot.split('webapp/')[1]) return {'url': plot_path} except Exception as e: e.args = ["Error saving plot"] + list(e.args) raise e
def render_graphs(input_df, layer): padding = dict(x=(-1.2, 1.2), y=(-1.2, 1.2)) purchase_row = my_data.loc[my_data['Etype'] == 5].iloc[0] title_graph = '{} Layer {}'.format(purchase_row['Source_Names'], layer) simple_graph = hv.Graph( ((input_df['Source_Names'], input_df['Destination_Names']), ), label=title_graph).redim.range(**padding) simple_graph() simple_graph.options(inspection_policy='edges', show_title=True) #hv.Layout([simple_graph.relabel(label=title)]) hv.renderer('bokeh').server_doc(simple_graph)
def save(self, savedData): """Saves a savedData object as pickle file. Also saves a picture of the plot to be used as a thumbnail. Typically the input is the output from the savegen function. Args: savedData: savedData object containing data and metadata information """ save_name = savedData.name with open('%s.p' % (save_name,), 'wb') as file: pickle.dump(savedData, file) hv.renderer('bokeh').save(savedData.plot.options(toolbar=None), './DataThumbnails/%s' % (save_name,), fmt='png')
def myGraphTest(): graphData = pd.read_csv('./myGraph.tsv', sep='\t') source = graphData['jobTitleNodeIndex'].values sourceLabels = graphData['jobTitleName'].values target = graphData['skillNodeIndex'].values targetLabels = graphData['skillName'].values padding = dict(x=(-1.2, 1.2), y=(-1.2, 1.2)) #X and Y showed scale on the cartesian table myGraph = hv.Graph(((source, target), )).redim.range(**padding) hv.renderer('bokeh').save(myGraph, 'out')
def write_histogram_for_annotation_worktime_by_user(self, df: pandas.DataFrame) -> None: """ 教師付者ごとに教師付時間のヒストグラムを出力する。 Args: df: タスク一覧のDataFrame """ if len(df) == 0: logger.info("タスク一覧が0件のため出力しません。") return output_file_worktime = f"{self.histogram_outdir}/ヒストグラム-1回目の教師付者ごと-教師付時間" logger.debug(f"{output_file_worktime}.html を出力します。") output_file_first_worktime = f"{self.histogram_outdir}/ヒストグラム-1回目の教師付者ごと-1回目の教師付時間" logger.debug(f"{output_file_first_worktime}.html を出力します。") first_annotation_user_id_list = df["first_annotation_user_id"].dropna().unique().tolist() if len(first_annotation_user_id_list) == 0: logger.info("教師付したタスクが1つもないので、出力しません。") return histograms_worktime = [] histograms_first_worktime = [] for user_id in first_annotation_user_id_list: filtered_df = df[df["first_annotation_user_id"] == user_id] username = filtered_df.iloc[0]["first_annotation_username"] histograms_worktime.append( self._create_histogram_by_user( filtered_df, "annotation_worktime_hour", "教師付時間[hour]", user_id=user_id, username=username ) ) histograms_first_worktime.append( self._create_histogram_by_user( filtered_df, "first_annotation_worktime_hour", "1回目の教師付時間[hour]", user_id=user_id, username=username ) ) layout_worktime = ( hv.Layout(histograms_worktime).cols(3).opts(hv.opts.Histogram(width=500), hv.opts.Layout(shared_axes=True)) ) hv.renderer("bokeh").save(layout_worktime, output_file_worktime) layout_first_worktime = ( hv.Layout(histograms_first_worktime) .cols(3) .opts(hv.opts.Histogram(width=500), hv.opts.Layout(shared_axes=True)) ) hv.renderer("bokeh").save(layout_first_worktime, output_file_first_worktime)
def _render(self, doc, comm, root): from holoviews import Store, renderer if not Store.renderers: loaded_backend = (self.backend or 'bokeh') renderer(loaded_backend) Store.current_backend = loaded_backend backend = self.backend or Store.current_backend renderer = Store.renderers[backend] if backend == 'bokeh': renderer = renderer.instance(mode='server' if comm is None else 'default') kwargs = {'doc': doc, 'root': root} if backend == 'bokeh' else {} if comm: kwargs['comm'] = comm return renderer.get_plot(self.object, **kwargs)
def quicksave(plot_object: Any, outfile_basename: str, renderer: str = 'matplotlib', fmt: Optional[str] = None) -> None: """Quicksave function for a holoviews plot to a standalone html file. Parameters ---------- plot_object - a holoviews layout object outfile_basename - The base name of the output file. renderer - name of a holoviews renderer, e.g 'bokeh', 'matplotlib', or 'plotly' """ hv.renderer(renderer).save(plot_object, outfile_basename, fmt=fmt) return
def testHoloviews(): '''''' hv.extension('bokeh') hv.renderer('matplotlib') station_info = pd.read_csv('./assets/station_info.csv') #station_info.head() scatter = hv.Scatter(station_info, 'services', 'ridership') #htmlOutput #render(scatter, './output.html', {'html':htmlOutput}) #BOKEH RENDERER #http://holoviews.org/user_guide/Deploying_Bokeh_Apps.html hv.renderer('bokeh').save(scatter, 'out') #IPYTHON RENDERER (works with dynamic maps by making a widget) #http://holoviews.org/user_guide/Plots_and_Renderers.html #html = renderer.html(scatter) display_html(html, raw=True) return
def cpu_boxplot(): renderer = hv.renderer('bokeh') def datafunc_down(data): algo1_data = data['algo-1'] algo2_data = data['algo-2'] return hv.BoxWhisker(algo1_data, vdims='algo-1') + hv.BoxWhisker( algo2_data, vdims='algo-2') # def datafunc_up(data): # return hv.BoxWhisker(data, vdims='cpu usage algo2') def cb(): down_stream.send(get_cpu_boxplot_data()) down_stream = hv.streams.Buffer(get_cpu_boxplot_data(), length=100, index=False) mem_dmap = hv.DynamicMap(datafunc_down, streams=[down_stream]) # Render plot and attach periodic callback cb_attacher = PeriodicCallback(cb, 100) cb_attacher.start() return mem_dmap, cb_attacher
def plot_holoviews_i(G, filename="graph.html"): import holoviews as hv extension = hv.extension('bokeh') renderer = hv.renderer('bokeh') graph_plot = hv.Graph.from_networkx(G, nx.layout.spring_layout) renderer.save(graph_plot, 'graph.html')
def fermi_surface_slices(arr: xr.DataArray, n_slices=9, ev_per_slice=0.02, bin=0.01, out=None, **kwargs): import holoviews as hv # pylint: disable=import-error slices = [] for i in range(n_slices): high = -ev_per_slice * i low = high - bin image = hv.Image(arr.sum([ d for d in arr.dims if d not in ['theta', 'beta', 'phi', 'eV', 'kp', 'kx', 'ky'] ]).sel(eV=slice(low, high)).sum('eV'), label='%g eV' % high) slices.append(image) layout = hv.Layout(slices).cols(3) if out is not None: renderer = hv.renderer('matplotlib').instance(fig='svg', holomap='gif') filename = path_for_plot(out) renderer.save(layout, path_for_holoviews(filename)) return filename else: return layout
def plot_direction(self, avg_df, selected_bin_1, selected_bin_2, selected_bin_3): """ Create a HTML plot of the Magnitude Velocity data from the CSV file. :param avg_df: Dataframe of the csv file :param selected_bin_1: Selected Bin 1. :param selected_bin_2: Selected Bin 2. :param selected_bin_3: Selected Bin 3. :return: """ # Title title = "Water Direction" bin_1 = self.get_plot_earth_vel(avg_df, "Direction", 0, selected_bin_1, 'Bin ' + str(selected_bin_1), "Direction", "Degrees") bin_2 = self.get_plot_earth_vel(avg_df, "Direction", 0, selected_bin_2, 'Bin ' + str(selected_bin_2), "Direction", "Degrees") bin_3 = self.get_plot_earth_vel(avg_df, "Direction", 0, selected_bin_3, 'Bin ' + str(selected_bin_3), "Direction", "Degrees") plots = (bin_1 * bin_2 * bin_3).relabel("Water Direction") plots.opts(legend_position='top_left') # Save the plot to a file renderer = hv.renderer('bokeh') bk_plot = renderer.get_plot(plots).state output_file(self.html_file, title=title) save(bk_plot) # Refresh the web view self.refresh_web_view_sig.emit()
def MakeHVGraph(G): # Set plot options print "Setting plot options" options = { 'Graph': dict(node_size=5, edge_line_width=.2, height=1000, width=1000, xaxis=None, yaxis=None, inspection_policy='nodes') } padding = dict(x=(-1.2, 1.2), y=(-1.2, 1.2)) # Make a holoviews graph print "Making the Interactive graph" Graph = hv.Graph.from_networkx(G, nx.spring_layout).redim.range(**padding) del G # This makes the html graph renderer = hv.renderer('bokeh') renderer.save(Graph, 'hvplot.html') plot = renderer.get_plot(Graph.options(options)).state from bokeh.io import output_file, save, show save(plot, 'hvplot.html') # Open the plot show(plot)
def figsave(hvobj, filename, **args): """Saves a plot to an image file. Args: hvobj (holoviews object): Plot to be saved. filename (string): Filename (without extension). Kwargs: fmt (string): Image format (default: 'png'). Use 'gif' when saving animations. size (int): Figure size in percent (default: 100). dpi (int): Figure resolution in dots per inch. fps (int): Frames per second for animations. """ fmt = args.pop('fmt', 'png') hv.renderer('matplotlib').instance(**args).save(hvobj, filename, fmt=fmt)
def set_plotting_defaults(): try: import holoviews as hv from bokeh.themes.theme import Theme except ImportError: return theme = Theme(json={"attrs": {"Axis": { "minor_tick_line_color": None, "major_tick_in": 0 }}}) hv.renderer("bokeh").theme = theme # once this issue https://github.com/pyviz/holoviews/issues/3319 is resolved, # then we can do this in a less hacky way for toolbar=None. For tools=["hover"], # though, we might still need this loop; try once the issue is resolved. elements = [] for element in dir(hv.opts): # this filters out most things we don't want if not element[0].isupper(): continue # still have issues with a few layout-like elements that don't use tools directly try: elements.append(getattr(hv.opts, element)(tools=["hover"], toolbar=None)) except ValueError: elements.append(getattr(hv.opts, element)(toolbar=None)) hv.opts.defaults(*elements)
def generateHoloview(self, df, SSC, FSC, type, counter_max=50): renderer = hv.renderer('bokeh') body_points = hv.Scatter(df, SSC, FSC).opts(color='r', title='SSC vs FSC Default Gating') body_hist = body_points.hist(num_bins=50, dimension=[SSC, FSC]) body = body_hist counter = 0 for index in range(len(df.columns)): for index2 in range(index+1, len(df.columns)): col = df.columns[index] col2 = df.columns[index2] if col2 != col and col not in (SSC, FSC) and col2 not in (SSC, FSC) and counter < counter_max: points = hv.Scatter(df, col, col2) hist = points.hist(num_bins=50, dimension=[col, col2]) body += hist counter += 1 print(counter) try: body = body.opts( opts.Scatter(tools=['box_select', 'lasso_select']), opts.Layout(shared_axes=True, shared_datasource=True)).cols(2) except: body = body.opts( opts.Scatter(tools=['box_select', 'lasso_select']), opts.Layout(shared_axes=True, shared_datasource=True)) renderer.save(body, os.path.join(self.directory, str(type)+"gating"))
def plot_overlay_mpl(): renderer = hv.renderer('matplotlib') a = ts.affpop_hand(region='D2d') obj = plot(region='D2d') * plot(a)['PC'] obj = (plot(region='D2d') * plot(a)['SA1']) +\ (plot(region='D2d') * plot(a)['RA']) +\ (plot(region='D2d') * plot(a)['PC'])
def write_histogram_for_annotation_count_by_label(self, df: pandas.DataFrame) -> None: """ アノテーションラベルごとのアノテーション数をヒストグラムで出力する。 """ if len(df) == 0: logger.info("タスク一覧が0件のため出力しない") return renderer = hv.renderer("bokeh") output_file = f"{self.histogram_outdir}/ヒストグラム-ラベルごとのアノテーション数" logger.debug(f"{output_file}.html を出力します。") histograms = [] label_columns = [e for e in df.columns if e.startswith("label_")] for column in label_columns: label_name = column[len("label_") :] histogram_name = HistogramName( column=column, x_axis_label=f"'{label_name}'のアノテーション数", title=f"{label_name}" ) hist = self._create_histogram(df, histogram_name=histogram_name) histograms.append(hist) # 軸範囲が同期しないようにする layout = hv.Layout(histograms).options(shared_axes=False).cols(3) renderer.save(layout, output_file)
def network_util_graph(): renderer = hv.renderer('bokeh') # Define DynamicMap callbacks returning Elements def network_map(data): plot = hv.Curve(data).options(title="Network utilization (algo1)", width=800, padding=0.1) return plot network_stream = hv.streams.Buffer(get_network_data(), length=500, index=False) def cb(): network_stream.send(get_network_data()) # Define DynamicMaps and display plot network_dmap = hv.DynamicMap(network_map, streams=[network_stream]) # Render plot and attach periodic callback cb_attacher = PeriodicCallback(cb, 100) cb_attacher.start() return network_dmap, cb_attacher
def serve_embedding(data): from .huddinge_browser import HuddingBrowser import holoviews as hv import traceback renderer = hv.renderer('bokeh') hb = HuddingBrowser(data) p = hb.holoview_plot() app = renderer.app(p) from tornado.ioloop import IOLoop from bokeh.server.server import Server loop = IOLoop.current() server = Server({'/': app}, port=0, io_loop=loop) def show_callback(): server.show('/') loop.add_callback(show_callback) server.start() try: log.info("Starting loop") loop.start() except Exception as e: traceback.print_exc() server.stop()
def node_bundle_tab(filename): G = scripts.MakeNetworkxGraph.__makegraph__(sep_type='semicolon', nodes_df_link=filename) """ Make HV network """ hv_graph = hv.Graph.from_networkx(G, nx.spring_layout, k=1).relabel('Force-Directed Spring') hv_graph.opts(width=650, height=650, xaxis=None, yaxis=None, padding=0.1, node_size=hv.dim('size'), node_color=hv.dim('node_type'), cmap='YlOrBr', edge_color=hv.dim('weight'), edge_cmap='YlGnBu', edge_line_width=hv.dim('weight')) bundle_graph_plot = bundle_graph(hv_graph) """ END HERE """ # Output files to Flask renderer = hv.renderer('bokeh') # plot = renderer.get_plot(hv_graph, show=True).state bundle_plot = renderer.get_plot(bundle_graph_plot, show=True).state return bundle_plot
def display_server(dmap_in): ### This is to render the chart in a web server to display as a dashboard!! renderer = hv.renderer('bokeh') #### You must have a Dynamic Map dmap to render these Bokeh objects on Servers app = renderer.app(dmap_in) server = renderer.app(dmap_in, show=True, new_window=True) display(server)
def plot_phase_diagrams(filenames,fileout): for i in range(len(filenames)): print 'i: ',i ds = yt.load(filenames[i]) center_guess = initial_center_guess(ds,track_name) halo_center = get_halo_center(ds,center_guess) rb = sym_refine_box(ds,halo_center) args = filenames[i].split('/') sim_label = args[-3] dens = np.log10(rb['H_nuclei_density']) temp = np.log10(rb['Temperature']) df = pd.DataFrame({'temp':temp, 'dens':dens}) phase_scatter = hv.Scatter(df,kdims=['dens'],vdims=['temp'],label=sim_label) #phase_data = np.zeros((len(rb['H_nuclei_density']),2)) #phase_data[:,0] = np.log10(rb['H_nuclei_density']) #phase_data[:,1] = np.log10(rb['Temperature']) #points = hv.Points(phase_data,kdims=['nH','temp'],label=sim_label) hv.opts({'Histogram': {'style': {'alpha':0.3, 'fill_color':'k'}}}) xhist = (histogram(phase_scatter, bin_range=(-7.5, 1), dimension='dens',normed=True)) #,alpha=0.3, fill_color='k')) yhist = (histogram(phase_scatter, bin_range=(3, 8.5), dimension='temp',normed=True)) #,alpha=0.3, fill_color='k')) if i == 0: phase_plot = (datashade(phase_scatter,cmap=cm.plasma, dynamic=False,x_range=(-7.5,1),y_range=(3,8.5))) << yhist(plot=dict(width=125)) << xhist(plot=dict(height=125)) else: plot2 = (datashade(phase_scatter,cmap=cm.plasma, dynamic=False,x_range=(-7.5,1),y_range=(3,8.5))) << yhist(plot=dict(width=125)) << xhist(plot=dict(height=125)) phase_plot = phase_plot + plot2 renderer = hv.renderer('bokeh').instance(fig='html') renderer.save(phase_plot, fileout) return
def holoviews_extra_resources() -> Dict[str, List[str]]: import holoviews as hv renderer = hv.renderer("bokeh") js_html, css_html = renderer.html_assets() def _split_html_assets(js_html: str, css_html: str) -> Dict[str, List[str]]: resources = _split_js_html_assets(js_html) resources.update(_split_css_html_assets(css_html)) return resources def _split_js_html_assets(js_html: str) -> Dict[str, List[str]]: pattern = r'<script src="(.*?)" type="text/javascript"></script>' extra_javascript = re.findall(pattern, js_html) pattern = r'(<script type="text/javascript">.*?</script>)' extra_raw_javascript = re.findall(pattern, js_html, re.DOTALL) return { "extra_javascript": extra_javascript, "extra_raw_javascript": extra_raw_javascript, } def _split_css_html_assets(css_html: str) -> Dict[str, List[str]]: pattern = r'<link rel="stylesheet" href="(.*?)">' extra_css = re.findall(pattern, css_html) pattern = r"(<style>.*?</style>)" extra_raw_css = re.findall(pattern, css_html, re.DOTALL) return {"extra_css": extra_css, "extra_raw_css": extra_raw_css} return _split_html_assets(js_html, css_html)
def myGraphTestSpringLayout(): #EXAMPLE GRAPH EDGE LIST path = "/u/alfonsda/Documents/DOCTORAT_TAL/004projetOntologie/holoviews-examples/myGraphEdgeList.tsv" #100 000 PROFILES GRAPH EDGE LIST #path = "/u/alfonsda/Documents/DOCTORAT_TAL/004projetOntologie/002data/candidats/2016-09-15/fr/anglophone/sample100milFunctions/edgeListNoWeight.tsv" g = nx.read_edgelist( path, delimiter='\t', nodetype=str, data=(('weight', float), ('color', str))) #the bigger the edgelist weight appears shorter padding = dict(x=(-1.2, 1.2), y=(-1.2, 1.2)) #X and Y showed scale on the cartesian table renderer = hv.renderer('bokeh') myGraph = hv.Graph.from_networkx( g, nx.spring_layout, nodes=None, weight='weight', iterations=100, scale=2, center=(0, 0) ) #the spring layout uses Fruchterman-Reingold force-directed algorithm to lay out the graph #myGraph.redim.range(**padding).opts(plot=dict(color_index='Type', edge_color_index='Weight'), # style=dict(cmap=['blue', 'red'])) myGraph = myGraph.redim.range(**padding).opts( plot=dict(height=800, width=1000, node_fill_color='color', edge_color_index='Weight'), style=dict(node_fill_color='red', cmap=['green', 'red'])) renderer.save(myGraph, 'out')
def plot_and_save_process_graph(holoviews_table, filename): '''plot and save process graph from output file made by loop.py ''' process = hv.Scatter(holoviews_table, 'ms', 'process') renderer = hv.renderer('matplotlib') renderer.save(process, 'process_' + filename)
def setUp(self): try: import scipy # noqa except: raise SkipTest('SciPy not available') try: import matplotlib # noqa except: raise SkipTest('SciPy not available') self.renderer = hv.renderer('matplotlib') np.random.seed(42) super(StatisticalCompositorTest, self).setUp()
def collect(self, blocks, figure_key="", subfig=0): '''collect holoview output. ''' map_figure2text = {} extension = "svg" rst_text = '''.. figure:: /{absfn} ''' for block in blocks: if not hasattr(block, "hv"): continue if self.engine == "mpl": renderer = hv.Store.renderers['matplotlib'].instance(fig='svg') plot = renderer.get_plot(block.hv) rendered = renderer(plot, fmt="auto") (data, info) = rendered # remove special characters from filename. I think the docutils # system removes these from links which later causes problems # as the link does not point to the correct location of the # file. outname = Utils.quote_filename( "%s_%s" % (self.template_name, block.title)) outputpath = os.path.join( self.outdir, '%s.%s' % (outname, extension)) # save to file with open(outputpath, "w") as outf: outf.write(data) # use absolute path absfn = os.path.abspath(outputpath) map_figure2text["#$hv %s$#" % block.title] = rst_text.format( absfn=absfn) elif self.engine == "bokeh": renderer = hv.renderer("bokeh") html = renderer.static_html(block.hv) lines = [".. only:: html\n"] +\ [" .. raw:: html\n"] +\ [" " + x for x in html.splitlines()] lines = "\n".join(lines) map_figure2text["#$hv %s$#" % block.title] = lines return map_figure2text
how to connnect a simple HoloViews plot with custom widgets and combine them into a bokeh layout. The app can be served using: bokeh serve --show player.py """ import numpy as np import holoviews as hv from bokeh.io import curdoc from bokeh.layouts import layout from bokeh.models import Slider, Button renderer = hv.renderer('bokeh') # Declare the HoloViews object start = 0 end = 10 hmap = hv.HoloMap({i: hv.Image(np.random.rand(10,10)) for i in range(start, end+1)}) # Convert the HoloViews object into a plot plot = renderer.get_plot(hmap) def animate_update(): year = slider.value + 1 if year > end: year = start slider.value = year
def setUp(self): self.renderer = holoviews.renderer('matplotlib') np.random.seed(42)
from unittest import SkipTest import numpy as np from holoviews import renderer from holoviews.core import Dimension, NdMapping, DynamicMap, HoloMap from holoviews.element import Curve from holoviews.element.comparison import ComparisonTestCase try: from holoviews.plotting.bokeh.widgets import BokehServerWidgets from bokeh.models.widgets import Select, Slider, AutocompleteInput, TextInput, Div bokeh_renderer = renderer('bokeh') except: BokehServerWidgets = None class TestBokehServerWidgets(ComparisonTestCase): def setUp(self): if not BokehServerWidgets: raise SkipTest("Bokeh required to test BokehServerWidgets") def test_bokeh_widgets_server_mode(self): dmap = DynamicMap(lambda X: Curve([]), kdims=['X']).redim.range(X=(0, 5)) widgets = bokeh_renderer.instance(mode='server').get_widget(dmap, None) div, widget = widgets.widgets['X'] self.assertIsInstance(widget, Slider) self.assertEqual(widget.value, 0) self.assertEqual(widget.start, 0) self.assertEqual(widget.end, 5)
import dask.dataframe as dd import holoviews as hv import geoviews as gv from bokeh.models import Slider, Button from bokeh.layouts import layout from bokeh.io import curdoc from bokeh.models import WMTSTileSource from holoviews.operation.datashader import datashade, aggregate, shade from holoviews.plotting.util import fire shade.cmap = fire hv.extension('bokeh') renderer = hv.renderer('bokeh').instance(mode='server') # Load data usecols = ['tpep_pickup_datetime', 'dropoff_x', 'dropoff_y'] ddf = dd.read_csv('../data/nyc_taxi.csv', parse_dates=['tpep_pickup_datetime'], usecols=usecols) ddf['hour'] = ddf.tpep_pickup_datetime.dt.hour ddf = ddf.persist() from bokeh.models import WMTSTileSource url = 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{Z}/{Y}/{X}.jpg' wmts = gv.WMTS(WMTSTileSource(url=url)) stream = hv.streams.Stream.define('HourSelect', hour=0)() points = hv.Points(ddf, kdims=['dropoff_x', 'dropoff_y']) dmap = hv.util.Dynamic(points, operation=lambda obj, hour: obj.select(hour=hour), streams=[stream])