def get_empty_triangle_canvas(title): p = figure(title=title) # draw the axes f0 = (0, 0, 1) f1 = (0, 1, 0) f2 = (1, 0, 0) p.add_layout( Arrow(end=NormalHead(fill_color="gray"), x_start=triangle_transform(*f0)[0], y_start=triangle_transform(*f0)[1], x_end=triangle_transform(*f1)[0], y_end=triangle_transform(*f1)[1])) # F0 p.add_layout( Arrow(end=NormalHead(fill_color="gray"), x_start=triangle_transform(*f1)[0], y_start=triangle_transform(*f1)[1], x_end=triangle_transform(*f2)[0], y_end=triangle_transform(*f2)[1])) # F1 p.add_layout( Arrow(end=NormalHead(fill_color="gray"), x_start=triangle_transform(*f2)[0], y_start=triangle_transform(*f2)[1], x_end=triangle_transform(*f0)[0], y_end=triangle_transform(*f0)[1])) # F2 return p
def test_arrow(output_file_url, selenium, screenshot): # Have to specify x/y range as labels aren't included in the plot area solver plot = figure(height=HEIGHT, width=WIDTH, x_range=(0,10), y_range=(0,10), tools='') arrow1 = Arrow(x_start=1, y_start=3, x_end=6, y_end=8, line_color='green', line_alpha=0.7, line_dash='8 4', line_width=5, end=OpenHead() ) arrow1.end.line_width=8 arrow2 = Arrow(x_start=2, y_start=2, x_end=7, y_end=7, start=NormalHead(), end=VeeHead() ) arrow2.start.fill_color = 'indigo' arrow2.end.fill_color = 'orange' arrow2.end.size = 50 plot.add_layout(arrow1) plot.add_layout(arrow2) # Save the plot and start the test save(plot) selenium.get(output_file_url) # Take screenshot assert screenshot.is_valid()
def generate(data, incoming_arrow_data, outgoing_arrow_data): plot = figure(title="", x_axis_label='', y_axis_label='', sizing_mode="scale_height") plot.xgrid.grid_line_color = None plot.ygrid.grid_line_color = None plot.xaxis.major_tick_line_color = None plot.xaxis.minor_tick_line_color = None plot.xaxis.major_label_text_color = '#ffffff' plot.xaxis.major_label_text_font_size = '0px' plot.xaxis.axis_line_color = "#ffffff" plot.yaxis.major_tick_line_color = None plot.yaxis.minor_tick_line_color = None plot.yaxis.major_label_text_color = '#ffffff' plot.yaxis.major_label_text_font_size = '0px' plot.yaxis.axis_line_color = "#ffffff" plot.toolbar.logo = None plot.toolbar_location = None source = ColumnDataSource(data) mapper = LinearColorMapper(palette=colors_hex, low=0, high=len(colors_hex)) labels = LabelSet(x="x", y="y", text="value", text_align="center", text_font="helvetica", text_font_size="16pt", x_offset=0, y_offset=-12, source=source, render_mode='canvas') plot.rect(x="x", y="y", width=1, height=1, source=source, fill_color={'field': 'value', 'transform': mapper}, line_color="#000000", line_alpha=0) plot.add_layout(labels) if incoming_arrow_data: incoming_arrow_source = ColumnDataSource(incoming_arrow_data) incoming_arrows = Arrow(end=VeeHead(fill_color="gray"), source=incoming_arrow_source, x_start='x_start', y_start='y_start', x_end='x_end', y_end='y_end', line_color="gray") plot.add_layout(incoming_arrows) if outgoing_arrow_data: outgoing_arrow_source = ColumnDataSource(outgoing_arrow_data) outgoing_arrows = Arrow(end=VeeHead(fill_color="black"), source=outgoing_arrow_source, x_start='x_start', y_start='y_start', x_end='x_end', y_end='y_end', line_color="black") plot.add_layout(outgoing_arrows) return plot
def __init__(self): self.StrCapabilityPlot = figure(plot_width=580, plot_height=595, tools='', title="Storage capability curve") self.StrCapabilityPlot.xaxis.axis_label = 'Q [p.u]' self.StrCapabilityPlot.yaxis.axis_label = 'P [p.u]' self.StrCapabilityPlot.toolbar.logo = None self.StrCapabilityPlot.toolbar_location = None self.StrCapabilityPlot.y_range = Range1d(*(-1.15, 1.15)) self.StrCapabilityPlot.x_range = Range1d(*(-1.15, 1.15)) self.StrCapabilityPlot.circle(x=[0], y=[0], radius=1.00, line_color ="navy", fill_color=None, size= 1) self.StrCapabilityPlot.add_layout(Arrow(end=VeeHead(size=10), line_color="black", x_start=0.0, y_start=-1.1, x_end=0, y_end=1.1)) self.StrCapabilityPlot.add_layout(Arrow(end=VeeHead(size=10), line_color="black", x_start=-1.1, y_start=0, x_end=1.1, y_end=0)) self.StoragecurveDatasource = ColumnDataSource(data=dict(x0=[], x1=[], x2=[], y0=[], y1=[], y2=[])) self.StrCapabilityPlot.line('x0', 'y0', source=self.StoragecurveDatasource, line_width=1, line_alpha=1.0, line_color="red") self.StrCapabilityPlot.line('x1', 'y1', source=self.StoragecurveDatasource, line_width=1, line_alpha=1.0, line_color="red") self.StrCapabilityPlot.line('x2', 'y2', source=self.StoragecurveDatasource, line_width=1, line_alpha=1.0, line_color="red") Storagewidgetbox = self.createStoragewidgetbox() PVsettingsLayout = column(self.StrCapabilityPlot, Storagewidgetbox, width=800) self.final_layout = PVsettingsLayout for w in [self.kWratingSlider, self.PFslider]: w.on_change('value', self.updateStoragecurves) return
def plot_label(self, fig): # only plot once! # use ColumnDataSource updates to change the plot # no re-plotting necessary! # plot point load point_load_glyph = Arrow(end=OpenHead(line_color=color_arrow,line_width=2, size=5), x_start='xS', x_end='xE', y_start='yS', y_end='yE', line_width='lW', line_color='lC', source=self.point_load_source) fig.add_layout(point_load_glyph) # plot loads that use patches fig.patch(x='x', y='y', fill_alpha=0.5, source=self.constant_load_source) fig.patch(x='x', y='y', fill_alpha=0.5, source=self.triangular_load_source) fig.patches(xs='x', ys='y', color='c', fill_alpha=0.5, source=self.temperature_load_source) # plot the labels for the corresponding load labels = LabelSet(x='x', y='y', text='name', level='glyph', render_mode='canvas', source=self.load_labels) fig.add_layout(labels) # add force arrows into the patches arrow_glyphs = Arrow(end=OpenHead(line_color=color_arrow,line_width=2, size=5), x_start='xS', x_end='xE', y_start='yS', y_end='yE', line_width='lW', line_color='lC', source=self.arrow_source) fig.add_layout(arrow_glyphs)
def update() -> None: if toggles['pause'].active: return ds_now = data_sources['now'].data ds_history = data_sources['history'].data if ds_now['epoch'][0] + 1 > sliders['max_epoch'].value: return batches_x, batches_y = create_batches() for batch_x, batch_y in zip(batches_x, batches_y): weight_previous = tensors['weight_model'] weight_updated = gradient_descent(batch_y, batch_x, weight_previous) arrow_head = VeeHead(size=5, fill_color='darkgrey', line_color='darkgrey') arrow = Arrow(end=arrow_head, line_color='darkgrey', x_start=ds_history['weight_0'][-1], y_start=ds_history['weight_1'][-1], x_end=weight_updated.numpy()[0, 0], y_end=weight_updated.numpy()[1, 0]) fig.add_layout(arrow) loss = loss_function(tensors['y_true'], pass_neuron(tensors['X'], weight_updated)).numpy()[0] ds_history['weight_0'] += [weight_updated.numpy()[0, 0]] ds_history['weight_1'] += [weight_updated.numpy()[1, 0]] ds_now['loss'] = [loss] ds_now['weight_0'] = [weight_updated.numpy()[0, 0]] ds_now['weight_1'] = [weight_updated.numpy()[1, 0]] tensors['weight_model'] = weight_updated ds_now['epoch'] = [ds_now['epoch'][0] + 1] for arrow in fig.center[2:-sliders['num_samples'].value]: arrow.line_color = 'lightgrey' arrow.end.fill_color = 'lightgrey' arrow.end.line_color = 'lightgrey' return
def get_empirical_figure(x, y, data): fig = figure( height=600, sizing_mode='stretch_width', x_axis_label='X', y_axis_label='F(x)' ) x.append(x[len(x)-1]+1) y.append(y[len(y)-1]) fig.circle(x=x, y=y, fill_alpha=0) for i in range(0, len(data)): x = data[i+1].get('x') if i != len(data)-1 else data[i].get('x')+1 fig.add_layout(Arrow( end=NormalHead(size=10, fill_color="blue"), line_color="blue", line_width=2, x_start=x, y_start=data[i].get('w_nak'), x_end=data[i].get('x'), y_end=data[i].get('w_nak') )) fig.add_layout(Span( location=data[i].get('x'), dimension='height', line_color='black', line_dash='dashed', line_width=1 )) fig.yaxis.fixed_location = 0 return fig
def _init_glyph(self, plot, mapping, properties, key): """ Returns a Bokeh glyph object. """ properties = {k: v for k, v in properties.items() if 'legend' not in k} if key == 'arrow_1': source = properties.pop('source') arrow_end = mapping.pop('arrow_end') arrow_start = mapping.pop('arrow_start') for p in ('alpha', 'color'): v = properties.pop(p, None) for t in ('line', 'fill'): if v is None: continue key = '_'.join([t, p]) if key not in properties: properties[key] = v start = arrow_start(**properties) if arrow_start else None end = arrow_end(**properties) if arrow_end else None line_props = {p: v for p, v in properties.items() if p.startswith('line_')} renderer = Arrow(start=start, end=end, source=source, **dict(line_props, **mapping)) glyph = renderer else: properties = {p if p == 'source' else 'text_'+p: v for p, v in properties.items()} renderer, glyph = super(ArrowPlot, self)._init_glyph( plot, mapping, properties, key) plot.renderers.append(renderer) return renderer, glyph
def add_path(self, path, shock=False, thin=False): path["X_1"] = path["X"] + path["dX"] path["Y_1"] = path["Y"] + path["dY"] if shock: path["X_1"] = path["X_1"] / 10 if thin: width = 1 / self.proportion else: width = 2 / self.proportion self.p.line( x=path.iloc[:-1, 0], y=path.iloc[:-1, 1], line_color="white", line_width=width, ) last = path.iloc[-2, :] self.p.add_layout( Arrow( end=NormalHead( line_color=None, fill_color="white", size=4 / self.proportion ), x_start=last["X"], y_start=last["Y"], x_end=last["X_1"], y_end=last["Y_1"], line_width=width, line_color="#FFFFFF", ) )
def map_demand(demand, network): demand_xy_df, agg_demand_df, agg_od_df, taz_df = prepare_demand( network, demand) o_trip_count_df = demand_xy_df.groupby( ['o_taz']).size().reset_index(name='o_trips') d_trip_count_df = demand_xy_df.groupby( ['d_taz']).size().reset_index(name='d_trips') p_map = figure(x_axis_type="mercator", y_axis_type="mercator", title="Origin and Destinations for Transit Trips", width=800) p_map.grid.visible = False p_map.add_tile(STAMEN_TONER) source = ColumnDataSource( data=dict(x=list(agg_demand_df['taz-lon']), y=list(agg_demand_df['taz-lat']), origins=list(agg_demand_df['origins']), destinations=list(agg_demand_df['destinations']))) p_map.circle(x='x', y='y', source=source, size="origins", legend="origin", fill_color="green", line_color="green", fill_alpha=0.15, line_alpha=0.15) p_map.circle(x='x', y='y', source=source, size="destinations", legend="destination", fill_color="navy", line_color="blue", line_width=4, fill_alpha=0.01, line_alpha=0.2) for index, row in agg_od_df.iterrows(): x1 = row['o-lon'] x2 = row['d-lon'] y1 = row['o-lat'] y2 = row['d-lat'] p_map.line([x1, x2], [y1, y2], line_width=row['trips'], line_alpha=0.2) p_map.add_layout( Arrow(end=OpenHead(size=row['trips']), line_color="navy", line_alpha=0.2, x_start=x1, y_start=y1, x_end=x2, y_end=y2)) return p_map
def arrows(pos_i=None, pos_f=None, p=None, names=None, color='black'): if pos_i is None: pos_i = np.zeros_like(pos_f) for i, (x0, y0, xf, yf) in enumerate(np.hstack((pos_i, pos_f))): p.add_layout( Arrow(end=VeeHead(fill_color=color, line_color=color, size=10), x_start=x0, y_start=y0, x_end=xf, y_end=yf)) if names is not None: vec_norm = np.sqrt((xf - x0)**2 + (yf - y0)**2) labels = Label(x=xf, y=yf, text=names[i], text_color=color, x_offset=vec_norm * 0.2, y_offset=vec_norm * 0.2) p.add_layout(labels) return p
def test_Arrow() -> None: arrow = Arrow() assert arrow.x_start == field("x_start") assert arrow.y_start == field("y_start") assert arrow.start_units == 'data' assert arrow.start is None assert arrow.x_end == field("x_end") assert arrow.y_end == field("y_end") assert arrow.end_units == 'data' assert isinstance(arrow.end, ArrowHead) assert isinstance(arrow.source, ColumnDataSource) assert arrow.x_range_name == "default" assert arrow.y_range_name == "default" check_line_properties(arrow) check_properties_existence( arrow, ANNOTATION + [ "x_start", "y_start", "start_units", "start", "x_end", "y_end", "end_units", "end", "source", ], LINE)
def render_graph(self, vert_size): display_graph = GraphRenderer(kwargs) display_graph.node_renderer.data_src.add( list(self.graph.vertices.keys()), "index") display_graph.node_renderer.data_src.add(self.get_colors(), "color") display_graph.node_renderer.glyph = Circle(size=vert_size, fill_color="color") display_graph.node__renderer.data_src.data = self.get_edges() self.randomize() for i in range(len( display_graph.edge_renderer.data_src.data["start"])): self.plot.add_layout( Arrow( end=NormalHead(fill_color="blue"), x_start=self.pos[display_graph.edge_renderer.ddata.src. data["start"][i]][0], x_end=self.pos[display_graph.edge_renderer.ddata.src. data["end"][i]][0], y_start=self.pos[display_graph.edge_renderer.ddata.src. data["start"][i]][1], y_end=self.pos[display_graph.edge_renderer.ddata.src. data["end"][i]][1], ))
def notebook_bokeh(stcs): patch_xs = parse_s_region(stcs)['ra'] patch_ys = parse_s_region(stcs)['dec'] p = figure(plot_width=700, x_axis_label="RA (deg)", y_axis_label="Dec (deg)") data = {'x': [patch_xs], 'y': [patch_ys]} p.patches('x', 'y', source=data, fill_alpha=0.1, line_color="black", line_width=0.5) p.add_layout( Arrow(end=VeeHead(line_color="black", line_width=1), line_width=2, x_start=patch_xs[0], y_start=patch_ys[0], x_end=patch_xs[1], y_end=patch_ys[1])) p.y_range.flipped = True output_notebook() show(p)
def _setup_graph_renderer(self, circle_size): graph_renderer = GraphRenderer() graph_renderer.node_renderer.data_source.add( list(self.graph.vertices.keys()), "index") graph_renderer.node_renderer.data_source.add(self._get_random_colors(), "color") graph_renderer.node_renderer.glyph = Circle(size=circle_size, fill_color="color") graph_renderer.edge_renderer.data_source.data = self._get_edge_indexes( ) self.randomize() for i in range( len(graph_renderer.edge_renderer.data_source.data["start"])): self.plot.add_layout( Arrow( end=VeeHead(size=20, fill_color="black"), x_start=self.pos[graph_renderer.edge_renderer.data_source. data["start"][i]][0], y_start=self.pos[graph_renderer.edge_renderer.data_source. data["start"][i]][1], x_end=self.pos[graph_renderer.edge_renderer.data_source. data["end"][i]][0], y_end=self.pos[graph_renderer.edge_renderer.data_source. data["end"][i]][1], )) graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=self.pos) self.plot.renderers.append(graph_renderer) self._get_labels()
def complex_notations_plot(*args): zs = np.array(args) m = max(np.max(np.real(np.abs(zs))), np.max(np.imag(np.abs(zs)))) + 1 fig1 = figure(title="Complex Plane (Rectangular)", plot_height=400, plot_width=400, x_range=[-m, m], y_range=[-m, m], toolbar_location=None) bokeh_central_axis(fig1, axis='both') bokeh_major_ticks(fig1) bokeh_hide_border(fig1) fig2 = figure(title="Complex Plane (Polar)", plot_height=400, plot_width=400, x_range=[-m, m], y_range=[-m, m], toolbar_location=None) bokeh_central_axis(fig2, axis='both') bokeh_no_ticks(fig2) bokeh_hide_border(fig2) bokeh_hide_grid(fig2) for z in zs: c = 'green' z1_arrow = Arrow(x_start=0, y_start=0, x_end=np.real(z), y_end=np.imag(z), end=OpenHead(size=9, line_color=c), line_color=c) z2_arrow = Arrow(x_start=0, y_start=0, x_end=np.real(z), y_end=np.imag(z), end=OpenHead(size=9, line_color=c), line_color=c) fig1.add_layout(z1_arrow) fig2.add_layout(z2_arrow) show(row(fig1, fig2))
def getWindCircle(circle_radius, dirList): radial_fig = figure(title="Wind Direction", plot_width=500, plot_height=500, x_range=(-40, 40), y_range=(-40, 40)) radial_fig.circle(0, 0, radius=circle_radius, fill_color='#F4F6F6', line_color='black') # add the smaller circles x_cir_ang, y_cir_ang = getAngularPoints( np.array(np.zeros(len(dirList), )) + circle_radius, dirList) radial_fig.circle(x=x_cir_ang, y=y_cir_ang, size=4, fill_color='black') # add wind annotations disp_wind = np.array([0, 60, 120, 180, 240, 300]) x_cir_label_ang, y_cir_label_ang = getAngularPoints( np.array(np.zeros(len(disp_wind), )) + circle_radius + 1, disp_wind) cir_label_source = ColumnDataSource( data=dict(x=x_cir_label_ang, y=y_cir_label_ang, text=disp_wind)) circle_labels = LabelSet(x='x', y='y', text='text', level='glyph', x_offset=0, y_offset=0, render_mode='canvas', text_font_size='10pt', source=cir_label_source) circle_title = Label(x=-6, y=-1, text='Wind Direction', render_mode='canvas', text_font_size='10pt', text_font='helvetica', text_font_style='bold') radial_fig.add_layout(circle_labels) true_north = Label(x=-0.5, y=8, text='N', render_mode='canvas', text_font_size='10pt', text_font='helvetica', text_font_style='bold') radial_fig.add_layout( Arrow(end=OpenHead(line_color="navy", line_width=2, size=10), x_start=0, y_start=-7.5, x_end=0, y_end=7.5, line_color='navy', line_width=2)) radial_fig.add_layout(true_north) radial_fig.add_layout(circle_title) radial_fig.axis.visible = False return radial_fig
def setup_timeline_backend_parts(plot: figure, desc_label_source: ColumnDataSource) -> None: """ :param plot: :param desc_label_source: :return: """ start_date, end_date = plot.x_range.start, plot.x_range.end arrow_x = start_date + datetime.timedelta(days=180) # 補助線を引く plot.line([start_date, end_date], [1, 1], line_width=3, line_color='pink') plot.line([start_date, end_date], [0.5, 0.5], line_width=3, line_dash='dotted', line_color='pink') plot.line([start_date, end_date], [1.5, 1.5], line_width=3, line_dash='dotted', line_color='pink') # 矢印を表示する plot.add_layout( Arrow(end=VeeHead(size=15), line_color='black', x_start=arrow_x, y_start=1.4, x_end=arrow_x, y_end=1.1)) plot.add_layout( Arrow(end=VeeHead(size=15), line_color='black', x_start=arrow_x, y_start=0.9, x_end=arrow_x, y_end=0.6)) plot.text(source=desc_label_source, x='x', y='y', text='text', text_font_size='size', text_alpha=0.8)
def strut_pressure_plot(layers, net, brace_elev): axis_size = max([max(net[0]), -1 * min(net[0])]) p = figure( x_range=[-axis_size-1000, axis_size*2.5], y_range=[net[1][-1]-3, net[1][0]+3], title="Strut Pressure Diagram", plot_width=800, plot_height=1200 ) p.xaxis.bounds = (0, 0) p.yaxis.bounds = (0, 0) p.line(net[0], net[1], line_width=2, color='black') p.line([0, 0], [layers[0][0], layers[-1][0]], color='black') p.add_layout(Label(x=1.5*axis_size, y=net[1][0] + 2, text="Pressure")) for i in range(len(layers)): p.line([-axis_size-1000, axis_size*2.5], [layers[i][0], layers[i][0]], color='dimgray', alpha=0.7) work_point_label = Label(x=-axis_size-1000, y=layers[i][0], text=str(layers[i][0]), text_font_size='12pt') p.add_layout(work_point_label) x, y = 0, 0 for k in range(len(net[0])): i = net[0][k] j = net[1][k] if j == y and i != x: pressure_label = Label(x=axis_size*1.5, y=j-0.5, text=str(i), text_font_size='12pt') else: pressure_label = Label(x=axis_size*1.5, y=j, text=str(i), text_font_size='12pt') x, y = i, j p.add_layout(pressure_label) p.add_layout(Arrow(end=NormalHead(size=10), x_start=-0.25*axis_size, y_start=brace_elev[0], x_end=00, y_end=brace_elev[0])) p.add_layout(Arrow(end=NormalHead(size=10), x_start=-0.25 * axis_size, y_start=brace_elev[1], x_end=00, y_end=brace_elev[1])) top_waler_label = Label(x=-0.4*axis_size, y=brace_elev[0]-0.5, text='T1') bot_waler_label = Label(x=-0.4*axis_size, y=brace_elev[1]-0.5, text='T2') p.add_layout(top_waler_label) p.add_layout(bot_waler_label) if len(brace_elev) == 3: t3_waler_label = Label(x=-0.4*axis_size, y=brace_elev[2]-0.5, text='T3') p.add_layout(t3_waler_label) p.add_layout(Arrow(end=NormalHead(size=10), x_start=-0.25 * axis_size, y_start=brace_elev[2], x_end=00, y_end=brace_elev[2])) return p
def biplot(score, coeff, expl_var, decomp='PCA', meta=None, fig_dir=None): coeff /= (np.abs(coeff).max() - np.abs(coeff).min()) * 1.5 score /= (score.max() - score.min()) coeff['norm'] = coeff.x**2 + coeff.y**2 coeff = coeff.sort_values(by='norm', ascending=False).iloc[:8] labels = meta.unique() if len(labels) < 11: colors = Category10[len(labels)] else: colors = inferno(len(labels)) color_map = {label: colors[i] for i, label in enumerate(labels)} score[meta.name] = meta.values score['color'] = [color_map[label] for label in meta.values] p = figure(plot_width=800, plot_height=800, x_range=(-1, 1), y_range=(-1, 1), title='Covariate contribution to the first 2 components') p.circle(x=score.columns[0], y=score.columns[1], color='color', alpha=0.25, size=5, legend_group=meta.name, source=score) for (x, y, _) in coeff.values: p.add_layout( Arrow(end=NormalHead(fill_color="orange", size=12, line_width=1), x_start=0, y_start=0, x_end=x, y_end=y)) labels = LabelSet(x='x', y='y', text='index', level='glyph', x_offset=5, y_offset=5, render_mode='canvas', source=ColumnDataSource(coeff.reset_index())) p.add_layout(labels) p.xaxis.axis_label = 'Component 1 ({:.1%})'.format(expl_var[0]) p.yaxis.axis_label = 'Component 2 ({:.1%})'.format(expl_var[1]) output_file(f"{fig_dir}/biplot_{decomp}.html") save(p)
def __init__(self): # save original shape of car in a shape (to make displacement easy) self.carshape = SD_Shape( [-3, 0, 0, -0.05, -0.5, -1, -2, -2, -3], [0.25, 0.25, 0.7, 0.75, 0.75, 1.25, 1.25, 0.75, 0.75]) # create column data sources for the car and its acceleration self.car = ColumnDataSource( data=dict(x=self.carshape.x, y=self.carshape.y)) self.wheels = ColumnDataSource(data=dict( x=[-2.25, -0.75], y=[0.25, 0.25], w=[0.5, 0.5], h=[0.5, 0.5])) self.arrow = ColumnDataSource(data=dict(xS=[], yS=[], xE=[], yE=[])) self.v_label = ColumnDataSource(data=dict(x=[], y=[], S=[])) # create the figure self.fig = figure(tools="", x_range=(-4, 31), y_range=(0, 4), height=100) # remove graph lines self.fig.yaxis.visible = False self.fig.grid.visible = False self.fig.toolbar.logo = None self.fig.outline_line_color = None # draw the house self.fig.line([30.0, 30.0, 29.5, 30.5], [0, 3.0, 3.0, 4.0], line_color="black", line_width=4) # add the car chassis to the image self.fig.patch(x='x', y='y', color="#0065BD", source=self.car) # add the car wheels to the image self.fig.ellipse(x='x', y='y', width='w', height='h', source=self.wheels, color="#0065BD") # create and add the arrow representing the velocity to the diagram arrow_glyph = Arrow(end=OpenHead(line_color="#003359", line_width=2, size=10), x_start='xS', y_start='yS', x_end='xE', y_end='yE', source=self.arrow, line_color="#003359", line_width=2) self.fig.add_layout(arrow_glyph) # create the label for the velocity and add it to the diagram v_glyph = LabelSet(x='x', y='y', text='S', text_color='#003359', level='glyph', source=self.v_label) self.fig.add_layout(v_glyph)
def st_RHS_plotting(self): """ Plot the drag factors on a sharp cornered rectanglar exposed member """ plot = Plot(title=None, match_aspect=True) glyph = Rect(x=0, y=0, width=self.d, height=self.b, fill_color="#cab2d6") plot.add_glyph(glyph) plot.add_layout( Arrow(end=NormalHead(fill_color="orange"), x_start=0, y_start=self.b / 4, x_end=0, y_end=self.b / 2)) plot.add_layout( Arrow(end=NormalHead(fill_color="orange"), x_start=-self.d / 2, y_start=0, x_end=-self.d / 4, y_end=0)) plot.add_layout(LinearAxis(), 'below') plot.add_layout(LinearAxis(), 'left') plot.add_glyph( Text( x=0, y=self.b / 2, text=[ f"Cf_y = {self.Cf_y:.2f}\nsigma_wind = {self.sigma_wind_vert/1000:.2f} kPa" ], text_align="left")) plot.add_glyph( Text( x=-self.d / 4, y=0, text=[ f"Cf_x = {self.Cf_x:.2f}\nsigma_wind = {self.sigma_wind_horiz/1000:.2f} kPa" ], text_align="left")) return plot
def bokeh_scatter_plot_xy_words(df_words, title='', xlabel='', ylabel='', line_data=False, filename=None, default_color='blue', plot_width=700, plot_height=600): plot = bp.figure(plot_width=plot_width, plot_height=plot_height, title=title, tools=TOOLS, toolbar_location="above" ) #, x_axis_type=None, y_axis_type=None, min_border=1) color = 'color' if 'color' in df_words.columns else default_color plot.scatter(x='x', y='y', size=8, source=df_words, alpha=0.5, color=color) plot.xaxis[0].axis_label = xlabel plot.yaxis[0].axis_label = ylabel source = ColumnDataSource(df_words) labels = LabelSet(x='x', y='y', text='words', level='glyph', text_font_size="9pt", x_offset=5, y_offset=5, source=source, render_mode='canvas') hover = plot.select(dict(type=HoverTool)) hover.tooltips = {"word": "@words"} if line_data is True: end_arrow = OpenHead(line_color="firebrick", line_width=1, size=10) for i in range(1, len(df_words.index), 2): x_start, y_start = df_words.iloc[i - 1]['x'], df_words.iloc[i - 1]['y'] x_end, y_end = df_words.iloc[i]['x'], df_words.iloc[i]['y'] plot.add_layout( Arrow(end=end_arrow, x_start=x_start, y_start=y_start, x_end=x_end, y_end=y_end)) plot.add_layout(labels) return plot
def plot_stream_arrow(plot, line_color, stream_arrow_temp, temp_label_font_size, x_start, x_end, y_start, y_end, stream_name=None): """Plot a stream arrow for the heat exchanger network diagram. Args: plot: bokeh.plotting.plotting.figure instance. line_color: color of arrow (defaults to white). stream_arrow_temp: Tempreature of the stream to be plotted. temp_label_font_size: font-size of the temperature label to be added. x_start: x-axis coordinate of arrow base. x_end: x-axis coordinate of arrow head. y_start: y-axis coordinate of arrow base. y_end: y-axis coordinate of arrow head. stream_name: Name of the stream to add as a label to arrow (defaults to None). Returns: modified bokeh.plotting.plotting.figure instance with stream arrow added. Raises: None """ plot.add_layout( Arrow(line_color=line_color, end=OpenHead(line_color=line_color, line_width=2, size=10), x_start=x_start, y_start=y_start, x_end=x_end, y_end=y_end)) temp_end_label = Label(x=x_end, y=y_end, x_offset=-20, y_offset=8, text_font_size=temp_label_font_size, text=str(stream_arrow_temp)) plot.add_layout(temp_end_label) if stream_name: stream_name_label = Label(x=x_end, y=y_end, x_offset=-10, y_offset=-12, text_font_size=temp_label_font_size, text=stream_name) plot.add_layout(stream_name_label) return plot
def add_arrows(canvas, branch, color, pf_threshold=0, dist_threshold=0, n=1): """Add addorws for powerflow to figure. :param bokeh.plotting.figure.Figure canvas: canvas to plot arrows onto. :param pandas.DataFrame branch: data frame containing: 'pf', 'dist', 'arrow_size', 'from_x', 'from_y', 'to_x', 'to_y'. x/y coordinates for to/from can be obtained from lat/lon coordinates using :func:`postreise.plot.projection_helpers.project_branch`. :param str color: arrow line color. :param int/float pf_threshold: minimum power flow for a branch to get arrow(s). :param int/float pf_threshold: minimum distance for a branch to get arrow(s). :param int n: number of arrows to plot along each branch. """ positive_arrows = branch.loc[(branch.pf > pf_threshold) & (branch.dist > dist_threshold)] negative_arrows = branch.loc[(branch.pf < -1 * pf_threshold) & (branch.dist > dist_threshold)] # Swap direction of negative arrows negative_arrows = negative_arrows.rename(columns={ "from_x": "to_x", "to_x": "from_x", "to_y": "from_y", "from_y": "to_y" }) # Finally, plot arrows arrows = pd.concat([positive_arrows, negative_arrows]) for i in range(n): start_fraction = i / n end_fraction = (i + 1) / n arrows.apply( lambda a: canvas.add_layout( Arrow( end=VeeHead( line_color="black", fill_color="gray", line_width=2, fill_alpha=0.5, line_alpha=0.5, size=a["arrow_size"], ), x_start=(a["from_x"] + (a["to_x"] - a["from_x"]) * start_fraction), y_start=(a["from_y"] + (a["to_y"] - a["from_y"]) * start_fraction), x_end=(a["from_x"] + (a["to_x"] - a["from_x"]) * end_fraction), y_end=(a["from_y"] + (a["to_y"] - a["from_y"]) * end_fraction), line_color=color, line_alpha=0.7, )), axis=1, )
def plot_ortho(plot, X_n, neg=1, color_choice='blue'): X_n_list = X_n.tolist() for i in X_n_list: new_point = [i[0] + neg * 1 / (5**0.5), i[1] + neg * 4 / (5**0.5)] plot.add_layout( Arrow(end=NormalHead(fill_color=color_choice, size=10), x_start=i[0], y_start=i[1], x_end=new_point[0], y_end=new_point[1], line_color=color_choice, line_alpha=0.8)) return plot
def _add_forward(fig, ftype, e, match): color = _get_team_color(e, match) fig.diamond(x=[e['start']['x'] / 100], y=[e['start']['y'] / 100], size=10, color=color, line_width=2) if ftype == 'goals_attempts': line_dash = 'dashed' else: line_dash = 'solid' arrow = Arrow(end=NormalHead(fill_color=color, line_color=color), line_color=color, line_width=2, line_dash=line_dash, x_start=e['start']['x'] / 100, y_start=e['start']['y'] / 100, x_end=e['end']['x'] / 100, y_end=e['end']['y'] / 100) fig.add_layout(arrow)
def bokeh_scatter_plot_xy_words2(df_words, title='', xlabel='', ylabel='', line_data=False): plot = bp.figure(plot_width=700, plot_height=600, title=title, tools="pan,wheel_zoom,box_zoom,reset,hover,previewsave", toolbar_location="above" ) #, x_axis_type=None, y_axis_type=None, min_border=1) # plotting. the corresponding word appears when you hover on the data point. plot.scatter(x='x', y='y', size=8, source=df_words, alpha=0.5) plot.xaxis[0].axis_label = xlabel plot.yaxis[0].axis_label = ylabel source = ColumnDataSource(df_words) labels = LabelSet(x='x', y='y', text='words', level='glyph', text_font_size="9pt", x_offset=5, y_offset=5, source=source, render_mode='canvas') hover = plot.select(dict(type=HoverTool)) hover.tooltips = {"word": "@words"} # df.transform(lambda x: list(zip(x, df[2]))) if line_data is True: end_arrow = OpenHead(line_color="firebrick", line_width=1, size=10) for i in range(1, len(df_words.index), 2): x_start, y_start = df_words.iloc[i - 1]['x'], df_words.iloc[i - 1]['y'] x_end, y_end = df_words.iloc[i]['x'], df_words.iloc[i]['y'] plot.add_layout( Arrow(end=end_arrow, x_start=x_start, y_start=y_start, x_end=x_end, y_end=y_end)) plot.add_layout(labels) show(plot, notebook_handle=True)
def create_plot(self): super().create_plot() self.plot.renderers[0].edge_renderer.data_source.data[ 'edge_data'] = self.y G = nx.convert_node_labels_to_integers(self.G) layout_coords = pd.DataFrame( [[ self.layout[x1][0], self.layout[x1][1], self.layout[x2][0], self.layout[x2][1] ] for (x1, x2) in G.edges()], columns=['x_start', 'y_start', 'x_end', 'y_end']) layout_coords['x_end'] = ( layout_coords['x_end'] - layout_coords['x_start']) / 2 + layout_coords['x_start'] layout_coords['y_end'] = ( layout_coords['y_end'] - layout_coords['y_start']) / 2 + layout_coords['y_start'] self.plot.renderers[0].edge_renderer.data_source.data[ 'x_start'] = layout_coords['x_start'] self.plot.renderers[0].edge_renderer.data_source.data[ 'y_start'] = layout_coords['y_start'] self.plot.renderers[0].edge_renderer.data_source.data[ 'x_end'] = layout_coords['x_end'] self.plot.renderers[0].edge_renderer.data_source.data[ 'y_end'] = layout_coords['y_end'] self.plot.renderers[0].edge_renderer.glyph = MultiLine( line_color=linear_cmap('edge_data', self.palette, self.lo, self.hi), line_width=5) if self.show_bar: cbar = ColorBar(color_mapper=LinearColorMapper( palette=self.palette, low=self.lo, high=self.hi), ticker=BasicTicker(), title=self.desc) self.plot.add_layout(cbar, 'right') arrows = Arrow(end=VeeHead(size=8), x_start='x_start', y_start='y_start', x_end='x_end', y_end='y_end', line_width=0, source=self.plot.renderers[0].edge_renderer.data_source) self.plot.add_layout(arrows) # self.plot.tooltips.append((self.desc, '@edge_data')) return self.plot
def _init_glyph(self, plot, mapping, properties, key): """ Returns a Bokeh glyph object. """ properties.pop('legend') if key == 'arrow': properties.pop('source') arrow_end = mapping.pop('arrow_end') arrow_start = mapping.pop('arrow_start') start = arrow_start(**properties) if arrow_start else None end = arrow_end(**properties) if arrow_end else None glyph = Arrow(start=start, end=end, **dict(**mapping)) else: properties = {p if p == 'source' else 'text_'+p: v for p, v in properties.items()} glyph, _ = super(ArrowPlot, self)._init_glyph(plot, mapping, properties, 'text') plot.renderers.append(glyph) return None, glyph