def build_renderers(self): """Yields all renderers that make up the BoxGlyph.""" self.calc_quartiles() outlier_values = self.values[((self.values < self.w0) | (self.values > self.w1))] self.whisker_glyph = GlyphRenderer( glyph=Segment(x0='x0s', y0='y0s', x1='x1s', y1='y1s', line_width=self.whisker_line_width, line_color=self.whisker_color)) if len(outlier_values) > 0 and self.outliers: self.outliers = PointGlyph(label=self.label, y=outlier_values, x=[self.get_dodge_label()] * len(outlier_values), line_color=self.outlier_line_color, fill_color=self.outlier_fill_color, size=self.outlier_size, marker=self.marker) for comp_glyph in self.composite_glyphs: for renderer in comp_glyph.renderers: yield renderer yield self.whisker_glyph
def test_Segment(): glyph = Segment() assert glyph.x0 is None assert glyph.y0 is None assert glyph.x1 is None assert glyph.y1 is None check_line_properties(glyph) check_properties_existence(glyph, ["x0", "y0", "x1", "y1"], LINE, GLYPH)
def test_Segment(): glyph = Segment() assert glyph.x0 is None assert glyph.y0 is None assert glyph.x1 is None assert glyph.y1 is None yield check_line, glyph yield (check_props, glyph, ["x0", "y0", "x1", "y1"], LINE)
def test_Segment() -> None: glyph = Segment() assert glyph.x0 == field("x0") assert glyph.y0 == field("y0") assert glyph.x1 == field("x1") assert glyph.y1 == field("y1") check_line_properties(glyph) check_properties_existence(glyph, ["x0", "y0", "x1", "y1"], LINE, GLYPH)
def test_Segment(): glyph = Segment() assert glyph.x0 == "x0" assert glyph.y0 == "y0" assert glyph.x1 == "x1" assert glyph.y1 == "y1" yield check_line, glyph yield (check_props, glyph, ["x0", "y0", "x1", "y1"], LINE)
def bokeh_glyph(self): return Segment( x0='x0', x1='x1', y0='y0', y1='y1', line_alpha=0, )
def add_trips_to_plot(p, trips): """Add trip glyphs to plot `p`.""" data_source = ColumnDataSource( pd.concat( [ trips, pd.DataFrame({ "marker_size": 8 * trips["n_passengers"], "marker_angle": marker_angle(trips), }), ], axis=1, )) p.add_glyph( data_source, Segment( x0="pick_lon", y0="pick_lat", x1="drop_lon", y1="drop_lat", line_color="black", line_width=1, ), ) p.add_glyph( data_source, Circle( x="pick_lon", y="pick_lat", size="marker_size", fill_color="blue", fill_alpha=0.6, ), ) p.add_glyph( data_source, Triangle( x="drop_lon", y="drop_lat", size="marker_size", angle="marker_angle", fill_color="red", fill_alpha=0.6, ), )
def build_renderers(self): if self.stem: yield GlyphRenderer(glyph=Segment( x0='x', y0=0, x1='x', y1='height', line_width=self.stem_line_width, line_color=self.stem_color, line_alpha='fill_alpha') ) glyph_type = self.get_glyph() glyph = glyph_type(x='x', y='height', line_color=self.line_color, fill_color=self.color, size=self.size, fill_alpha='fill_alpha', line_alpha='line_alpha' ) yield GlyphRenderer(glyph=glyph)
def segment(self, source, x0='segx0', x1='segx1', y0='segy0', y1='segy1', line_width=2, line_color='#1e90ff'): seg = Segment(x0=x0, x1=x1, y0=y0, y1=y1, line_width=line_width, line_color=line_color) self.plot.add_glyph(source, seg) self.plot.yaxis.ticker = FixedTicker(ticks=[0, 1]) self.plot.yaxis.major_label_overrides = {'0': 'bad', '1': 'good'} return self
def plot_choiceset_links(linkfile_df,cost="sim_cost",paths=False): linkfile_df["color"]= map(assignColorByMode, linkfile_df["mode"]) if paths: linkfile_df["annotation"]= map(createLinkPathAnnotation, linkfile_df["mode"], linkfile_df[cost], linkfile_df["route_id"], linkfile_df["trip_id"], linkfile_df["probability"]) else: linkfile_df["annotation"]=map(createLinkAnnotation, linkfile_df["mode"], linkfile_df[cost], linkfile_df["route_id"], linkfile_df["trip_id"]) linkfile_df["yloc"]= map(yloc, linkfile_df["pathnum"],linkfile_df["linknum"]) pathnums = list(set(list(linkfile_df["pathnum"]))) plots = {} for p in pathnums: data_df = linkfile_df[linkfile_df["pathnum"]==p] linksource = ColumnDataSource(data_df) xdr2 = DataRange1d() ydr2 = DataRange1d() plots[p] = Plot( title="Path Number: %d Probability: %4.2f Percent" % (p,100*data_df["probability"].max()), x_range=xdr2, y_range=ydr2, plot_width=800, plot_height=150, h_symmetry=False, v_symmetry=False, min_border=0, toolbar_location=None) glyph = Segment(y0="yloc", x0="new_A_time", y1="yloc", x1="new_B_time", line_color="color", line_width=cost) plots[p].add_glyph(linksource, glyph) choicexaxis = DatetimeAxis() plots[p].add_layout(choicexaxis, 'below') xaxis = DatetimeAxis() yaxis = LinearAxis() plots[p].add_layout(Grid(dimension=0, ticker=xaxis.ticker)) plots[p].add_layout(Grid(dimension=1, ticker=yaxis.ticker)) choice_labels = LabelSet(x="new_A_time", y="yloc", text="annotation", y_offset=-5,x_offset=10, text_font_size="8pt", text_color="#555555", source=linksource, text_align='left') plots[p].add_layout(choice_labels) return plots.values()
def plot_choice_links(linkfile_df,cost="sim_cost",paths=False): linkfile_df["color"]= map(assignColorByMode, linkfile_df["mode"]) if paths: linkfile_df["annotation"]= map(createLinkPathAnnotation, linkfile_df["mode"], linkfile_df[cost], linkfile_df["route_id"], linkfile_df["trip_id"], linkfile_df["probability"]) else: linkfile_df["annotation"]=map(createLinkAnnotation, linkfile_df["mode"], linkfile_df[cost], linkfile_df["route_id"], linkfile_df["trip_id"]) linkfile_df["yloc"]= map(yloc, linkfile_df["pathnum"],linkfile_df["linknum"]) linksource = ColumnDataSource(linkfile_df) #linkfile_df xdr2 = DataRange1d() ydr2 = DataRange1d() choiceplot = Plot( title=None, x_range=xdr2, y_range=ydr2, plot_width=800, plot_height=300, h_symmetry=False, v_symmetry=False, min_border=0, toolbar_location=None) glyph = Segment(y0="yloc", x0="new_A_time", y1="yloc", x1="new_B_time", line_color="color", line_width=cost) choiceplot.add_glyph(linksource, glyph) choicexaxis = DatetimeAxis() choiceplot.add_layout(choicexaxis, 'below') xaxis = DatetimeAxis() yaxis = LinearAxis() choiceplot.add_layout(Grid(dimension=0, ticker=xaxis.ticker)) choiceplot.add_layout(Grid(dimension=1, ticker=yaxis.ticker)) choice_labels = LabelSet(x="new_A_time", y="yloc", text="annotation", y_offset=-5,x_offset=10, text_font_size="8pt", text_color="#555555", source=linksource, text_align='left') choiceplot.add_layout(choice_labels) return choiceplot
def update_plot(self): today = Timestamp.today().strftime('%Y-%m-%d') today_date = to_datetime(today) df = self.counts_data weights = self.similarities_data.xs(self.school, level='school_name', axis=1) df_all = df[df['school_name'].eq(self.school)] present_academic_year = df['academic_year'].unique()[0] tooltips = ''' <div style="font-size: 12px;"> <span style="font-weight: bold;">@school_name</span> (@school_type, @school_age years old)<br> Grade @grade enrollment, as of @reference_date_string<br> <br> <span style="font-weight: bold;">Attrition</span>: @exit_count_present_cumm (@exit_percent_present_cumm{'0.0%'} change from October 1)<br> <span style="font-weight: bold;">Backfill</span>: @enter_count_present_cumm (@enter_percent_present_cumm{'0.0%'} change from October 1)<br> <span style="font-weight: bold;">Current total enrollment</span>: @total_enrollment </div> ''' ticker_ref = DataFrame({'month': date_range('2014-10-01', '2015-06-01', freq='MS')}) ticker_ref['marker'] = ticker_ref['month'] ticker_ref['month'] = ticker_ref['month'].apply(lambda x: x.strftime('%B')) ticker_ref = ticker_ref.set_index('marker')['month'].to_dict() x_range1d = Range1d(-0.05, 290.0) y_index = max( -df_all['exit_percent_present_cumm'].min(), df_all['enter_percent_present_cumm'].max(), -df_all['exit_percent_past_cumm'].min(), df_all['enter_percent_past_cumm'].max() ) y_range1d = Range1d(-y_index - 0.005, y_index + 0.005) plots = [] focus_cols = ['enter_percent_present_cumm', 'exit_percent_present_cumm'] unique_grades = sorted(df_all['grade'].unique().astype('int')) for grade in unique_grades: grade_weight = weights[grade] benchmark_df = DataFrame(columns=focus_cols) df_copy = df[df['academic_year'].eq(present_academic_year)].copy().set_index(['school_name', 'grade']) for rid, label in sorted(ticker_ref.items(), reverse=True): df_copy = df_copy[df_copy['reference_date'].le(rid)] df_ave = df_copy.groupby(level=['school_name', 'grade'])[focus_cols].tail(1).\ mul(grade_weight, axis=0).sum() / grade_weight.sum() df_ave.name = label benchmark_df = benchmark_df.append(df_ave) benchmark_df = benchmark_df.reset_index() benchmark_df['reference_date'] = benchmark_df['index'].map({y: x for x, y in ticker_ref.items()}) benchmark_df['reference_id'] = benchmark_df['reference_date'].apply(lambda x: x.toordinal()) - \ df_all['reference_date'].min().toordinal() source_df = df_all[df_all['grade'].eq(grade)] source_df_rev = source_df.sort_values('reference_id', ascending=False) source_df_trunc = source_df.loc[source_df['reference_date'].le(today_date), :] source = ColumnDataSource(source_df) source_trunc = ColumnDataSource(source_df_trunc) patch_source = ColumnDataSource(dict( x_past=source_df['reference_id'].tolist() + source_df_rev['reference_id'].tolist(), y_past=source_df['enter_percent_past_cumm'].tolist() + source_df_rev['exit_percent_past_cumm'].tolist() )) plot1 = Plot( x_range=x_range1d, y_range=y_range1d, min_border_bottom=5, min_border_top=10, min_border_right=10, plot_width=700, plot_height=150, title=None, title_text_font_size='0pt', title_text_color='grey', outline_line_alpha=0.0) plot1.add_layout( LinearAxis( axis_label='Grade ' + str(grade), axis_label_text_font_size='9pt', minor_tick_line_alpha=0.0, axis_label_text_color='grey', axis_line_alpha=0.1, major_tick_line_alpha=0.1, major_label_text_color='grey', major_label_text_font_size='7pt', formatter=NumeralTickFormatter(format='0%') ), 'left') patch = Patch(x='x_past', y='y_past', fill_color='#AFAFAD', fill_alpha=0.25, line_alpha=0.0) plot1.add_glyph(patch_source, patch) line1 = Line( x='reference_id', y='enter_percent_present_cumm', line_width=2, line_color='#f7910b', line_alpha=1.0) plot1.add_glyph(source_trunc, line1) line2 = Line( x='reference_id', y='exit_percent_present_cumm', line_width=2, line_color='#f7910b', line_alpha=1.0) plot1.add_glyph(source_trunc, line2) line_h = Line(x='reference_id', y=0, line_width=1, line_color='black', line_alpha=0.1) line_renderer = GlyphRenderer(data_source=source, glyph=line_h, name='line') plot1.add_glyph(source, line_h) for ind, series in benchmark_df.iterrows(): x = series['reference_id'] y_enter = series['enter_percent_present_cumm'] y_exit = series['exit_percent_present_cumm'] label = series['index'] line = Segment(x0=x, x1=x, y0=-y_index, y1=y_index, line_width=1, line_color='#165788', line_alpha=0.1) plot1.add_glyph(line) linec1 = Segment( x0=x - 3, x1=x + 3, y0=y_enter, y1=y_enter, line_width=1, line_color='#ed2939', line_alpha=1.0) plot1.add_glyph(linec1) linec2 = Segment( x0=x - 3, x1=x + 3, y0=y_exit, y1=y_exit, line_width=1, line_color='#ed2939', line_alpha=1.0) plot1.add_glyph(linec2) text = Text(x=x+3, y=-y_index, text=[label], text_font_size='8pt', text_color='grey', text_alpha=0.5) plot1.add_glyph(text) hover_tool = HoverTool( plot=plot1, renderers=[line_renderer], tooltips=tooltips, always_active=False, mode='vline', point_policy='follow_mouse', line_policy='prev') crosshair_tool = CrosshairTool(plot=plot1, dimensions=['height']) zoom_tool = BoxZoomTool(plot=plot1, dimensions=['width']) reset_tool = ResetTool(plot=plot1) save_tool = PreviewSaveTool(plot=plot1) pan_tool = PanTool(plot=plot1, dimensions=['width']) help_tool = HelpTool(plot=plot1, help_tooltip='App help page', redirect='http://data.successacademies.org/blog/') plot1.tools.extend([hover_tool, zoom_tool, pan_tool, reset_tool, save_tool, help_tool, crosshair_tool]) plot1.renderers.extend([line_renderer]) plots.append([plot1]) self.plot.children = plots
def radialplot(tree, node_color='node_color', node_size='node_size', node_alpha='node_alpha', edge_color='edge_color', edge_alpha='edge_alpha', edge_width='edge_width', hover_var='hover_var', figsize=(500, 500), **kwargs): """ Plots unrooted radial tree. Parameters ---------- tree : instance of skbio.TreeNode Input tree for plotting. node_color : str Name of variable in `tree` to color nodes. node_size : str Name of variable in `tree` that specifies the radius of nodes. node_alpha : str Name of variable in `tree` to specify node transparency. edge_color : str Name of variable in `tree` to color edges. edge_alpha : str Name of variable in `tree` to specify edge transparency. edge_width : str Name of variable in `tree` to specify edge width. hover_var : str Name of variable in `tree` to display in the hover menu. figsize : tuple, int Size of resulting figure. default: (500, 500) **kwargs: dict Plotting options to pass into bokeh.models.Plot Returns ------- bokeh.models.Plot Interactive plotting instance. Notes ----- This assumes that the tree is strictly bifurcating. See also -------- bifurcate """ warnings.warn("This visualization are deprecated.", DeprecationWarning) # This entire function was motivated by # http://chuckpr.github.io/blog/trees2.html t = UnrootedDendrogram.from_tree(tree.copy()) nodes = t.coords(figsize[0], figsize[1]) # fill in all of the node attributes def _retreive(tree, x, default): return pd.Series({n.name: getattr(n, x, default) for n in tree.levelorder()}) # default node color to light grey nodes[node_color] = _retreive(t, node_color, default='#D3D3D3') nodes[node_size] = _retreive(t, node_size, default=1) nodes[node_alpha] = _retreive(t, node_alpha, default=1) nodes[hover_var] = _retreive(t, hover_var, default=None) edges = nodes[['child0', 'child1']] edges = edges.dropna(subset=['child0', 'child1']) edges = edges.unstack() edges = pd.DataFrame({'src_node': edges.index.get_level_values(1), 'dest_node': edges.values}) edges['x0'] = [nodes.loc[n].x for n in edges.src_node] edges['x1'] = [nodes.loc[n].x for n in edges.dest_node] edges['y0'] = [nodes.loc[n].y for n in edges.src_node] edges['y1'] = [nodes.loc[n].y for n in edges.dest_node] ns = [n.name for n in t.levelorder(include_self=True)] attrs = pd.DataFrame(index=ns) # default edge color to black attrs[edge_color] = _retreive(t, edge_color, default='#000000') attrs[edge_width] = _retreive(t, edge_width, default=1) attrs[edge_alpha] = _retreive(t, edge_alpha, default=1) edges = pd.merge(edges, attrs, left_on='dest_node', right_index=True, how='outer') edges = edges.dropna(subset=['src_node']) node_glyph = Circle(x="x", y="y", radius=node_size, fill_color=node_color, fill_alpha=node_alpha) edge_glyph = Segment(x0="x0", y0="y0", x1="x1", y1="y1", line_color=edge_color, line_alpha=edge_alpha, line_width=edge_width) def df2ds(df): return ColumnDataSource(ColumnDataSource.from_df(df)) ydr = DataRange1d(range_padding=0.05) xdr = DataRange1d(range_padding=0.05) plot = Plot(x_range=xdr, y_range=ydr, **kwargs) plot.add_glyph(df2ds(edges), edge_glyph) ns = plot.add_glyph(df2ds(nodes), node_glyph) tooltip = [ ("Feature ID", "@index") ] if hover_var is not None: tooltip += [(hover_var, "@" + hover_var)] hover = HoverTool(renderers=[ns], tooltips=tooltip) plot.add_tools(hover, BoxZoomTool(), ResetTool(), WheelZoomTool(), SaveTool(), PanTool()) return plot
normalized_values = [(x * 1.0) / y for x, y in zip(values, max_values)] cm = np.array(["#C7E9B4", "#7FCDBB", "#41B6C4", "#1D91C0", "#225EA8", "#0C2C84"]) ix = [0, 1, 2] colorsd = cm[ix] # source = ColumnDataSource(data=dict(factor=factor, normalized_values=normalized_values)) source = ColumnDataSource(dict( x=[0.5, 1.5, 2.5], y=[0, 0, 0], xm01=[0.5, 1.5, 2.5], ym01=normalized_values, colors=["#C7E9B4", "#7FCDBB", "#41B6C4"] ) ) p = figure(x_range=factor, plot_height=700, plot_width=800, toolbar_location=None) r = Segment(x0='x', y0='y', x1='xm01', y1='ym01', line_width=150, line_color='colors') p.add_glyph(source, r) p.xgrid.grid_line_color = None p.y_range.start = 0 p.y_range.end = 2 p.title.text_font_size = "50px" priceCalculator = PriceCalculator('apple') priceCalculator.update_input(values[0], values[1], values[2]) priceCalculator.calculate_discount() priceCalculator.calculate_price() p.title.text = "The resulting price is ${0:.2f}".format(priceCalculator.price) p.legend.orientation = "horizontal" p.legend.location = "top_center" p.legend.label_text_font_size = "15pt" p.add_layout(Title(text="Normal price is $1.50.", text_font_size="50px"), 'above')
def add_path(self, source_label, links=None, edge_type='curved', tooltips=None, legend=None, **kwargs): """ Connect all points in the datasource in a path (to show order). `self.prepare_plot` must have been called previous to this. Parameters: source_label (str): string corresponding to a label previously called in `self.add_source` order_col: the column of a data source specifying the order of the records tooltips: string or list of tuples (passed to Bokeh HoverTool) legend (str): name to assign to this layer in the plot legend kwargs: options passed to the objected for `bokeh_model` This method allows two special kwargs: 'color' and 'alpha'. When used with a bokeh model that has 'fill_color' and 'line_color' and 'fill_alpha' and 'line_alpha' properties, calling the special kwarg will use the same value for both. """ self._validate_workflow('add_path') source = self.sources[source_label].copy() suffix = '_transform' if type(self.plot) != GMapPlot else '' x_point_label = 'x_coord_point{}'.format(suffix) y_point_label = 'y_coord_point{}'.format(suffix) if all(isinstance(x, (int, float)) for x in source[links].tolist()): x1 = source.sort_values(links)[x_point_label].values y1 = source.sort_values(links)[y_point_label].values x2 = x1[1:] y2 = y1[1:] x1 = x1[:-1] y1 = y1[:-1] x3 = (x1 + x2) / 2 y3 = (y1 + y2) / 2 xc = x3 + abs(y3 - y2) yc = y3 + abs(x3 - x2) new_source = { 'x1': x1, 'x2': x2, 'xc': xc, 'y1': y1, 'y2': y2, 'yc': yc } for c in source.columns: if (c not in self.omit_columns) and c not in new_source: new_source[c] = source[c].values[:-1] elif all( isinstance(x, (list, tuple, set)) for x in source[links].tolist()): if 'uid' not in source.columns: raise ValueError( 'Source must contain column `uid` when links is a list of iterables.' ) nodes = source['uid'].tolist() edges = source[links].tolist() node_x = source.set_index('uid')[x_point_label].to_dict() node_y = source.set_index('uid')[y_point_label].to_dict() a_vals, x1, x2, y1, y2 = zip(*[(a, node_x[a], node_x[b], node_y[a], node_y[b]) for a, bs in zip(nodes, edges) for b in bs]) x1, x2, y1, y2 = array(x1), array(x2), array(y1), array(y2) x3 = (x1 + x2) / 2 y3 = (y1 + y2) / 2 xc = x3 + abs(y3 - y2) yc = y3 + abs(x3 - x2) new_source = { 'x1': x1, 'x2': x2, 'xc': xc, 'y1': y1, 'y2': y2, 'yc': yc } for c in source.columns: if (c not in self.omit_columns) and c not in new_source: col_dict = source.set_index('uid', drop=False)[c].to_dict() new_source[c] = [col_dict[v] for v in a_vals] else: raise ValueError( 'Values of `links` field must be numeric or a list, set, or tuple of values from the `uid` field.' ) if 'color' in kwargs.keys(): color = kwargs.pop('color') for v in Quadratic.dataspecs(): if 'color' in v: kwargs[v] = color if 'alpha' in kwargs.keys(): alpha = kwargs.pop('alpha') for v in Quadratic.dataspecs(): if 'alpha' in v: kwargs[v] = alpha if edge_type == 'curved': model_object = Quadratic(x0='x1', y0='y1', x1="x2", y1="y2", cx="xc", cy="yc", name=source_label, **kwargs) elif edge_type == 'straight': model_object = Segment(x0='x1', y0='y1', x1="x2", y1="y2", name=source_label, **kwargs) else: raise ValueError( 'Keyword `edge_type` must be either "curved" or "straight".') source = ColumnDataSource(new_source, name=source_label) rend = self.plot.add_glyph(source, model_object) if legend is not None: li = LegendItem(label=legend, renderers=[rend]) self.legend.items.append(li) if tooltips is not None: self.plot.add_tools(HoverTool(tooltips=tooltips, renderers=[rend])) return self
y="y", length=45, angle=-0.7, line_color="#FB8072", line_width=2)), ("rect", Rect(x="x", y="y", width=screen(10), height=screen(20), angle=-0.7, fill_color="#CAB2D6")), ("segment", Segment(x0="x", y0="y", x1="xm01", y1="ym01", line_color="#F4A582", line_width=3)), ("text", Text(x="x", y="y", text=["hello"])), ("wedge", Wedge(x="x", y="y", radius=screen(15), start_angle=0.6, end_angle=4.1, fill_color="#B3DE69")), ] markers = [ ("circle", Circle(x="x", y="y", radius=0.1, fill_color="#3288BD")), ("circle_x",
# Start timer t0 = time.time() ################ x_range = Range1d(0, 1) y_range = Range1d(0, 1) plot = Plot(x_range=x_range, y_range=y_range, plot_width=plot_width, plot_height=plot_height, title=title) plot.add_tools(PanTool(), WheelZoomTool(), BoxZoomTool(), PreviewSaveTool(), ResetTool()) # edges seg = Segment(x0="ex0", y0="ey0", x1="ex1", y1="ey1", \ line_width="ewidth",) seg_glyph = plot.add_glyph(esource, seg) # circles circ = Circle(x="x", y="y", size='size', line_color=None) circ_glyph = plot.add_glyph(nsource, circ) ################ # End Timer print(bokeh.__version__) print("Time to plot with Bokeh:", time.time() - t0, "seconds") # save bk.output_file(htmlout, mode='cdn') ################
def plot_urls(self): """ Visualize crawler activity by showing the most recently crawled URLs and the fetch time. """ self.session.load_document(self.document) plot = self.document.context.children[0] # don't plot if no URLs available if not (self.open_urls or self.closed_urls): return # x0/x0, left and right boundaries of segments, correspond to fetch time x0 = [] x = [] # y-axis, name of URL being fetched urls = [] # maintain x and URL of circles in a separate list circles = [] circle_urls = [] current_time = np.datetime64(datetime.now()) # For open URLs (not completed fetching), draw a segment from start time to now for url, start_t in self.open_urls.items(): url = NutchUrlTrails.strip_url(url) x0.append(start_t) x.append(current_time) urls.append(url) # For closed URLs (completed fetching), draw a segment from start to end time, and a circle as well. for url, (start_t, end_t) in self.closed_urls.items(): url = NutchUrlTrails.strip_url(url) x0.append(start_t) x.append(end_t) circles.append(end_t) urls.append(url) circle_urls.append(url) x0 = np.asarray(x0) x = np.asarray(x) circles = np.asarray(circles) # sort segments sort_index = np.argsort(x0)[::-1] x0 = x0[sort_index] x = x[sort_index] urls = [urls[i] for i in sort_index] # sort circles if self.closed_urls: circle_sort_index = np.argsort(circles)[::-1] circles = circles[circle_sort_index] circle_urls = [circle_urls[i] for i in circle_sort_index] # Filter to latest num_url URLs (ascending order) # filter segments active_x0 = x0[:self.num_urls] active_x = x[:self.num_urls] active_urls = urls[:self.num_urls] min_x = min(active_x0) plot.x_range.start = min_x plot.x_range.end = np.datetime64(datetime.now()) plot.y_range.factors = active_urls # make sure these are turned back on! # turn y axis grid lines back on for r in plot.renderers: if type(r) == Grid: r.grid_line_color = 'black' break # turn tickers and their labels back on plot.right[0].minor_tick_line_color = 'black' plot.right[0].major_tick_line_color = 'black' plot.right[0].major_label_text_font_size = '12pt' plot.below[0].minor_tick_line_color = 'black' plot.below[0].major_tick_line_color = 'black' plot.below[0].major_label_text_font_size = '12pt' # TODO: Find a more correct way to remove old segment/circle glyphs if self.old_circles: plot.renderers.pop() self.old_circles = None if self.old_segments: plot.renderers.pop() self.old_segments = None segment_source = ColumnDataSource( dict(x0=active_x0, x1=active_x, urls=active_urls)) self.old_segments = Segment(x0="x0", y0="urls", x1="x1", y1="urls", line_color="orange", line_width=10) plot.add_glyph(segment_source, self.old_segments) if self.closed_urls and PLOT_CIRCLES: # filter circles (some of these might not be displayed) active_circles = circles[:self.num_urls] active_circle_urls = circle_urls[:self.num_urls] circle_source = ColumnDataSource( dict(x=active_circles, urls=active_circle_urls)) self.old_circles = Circle(x="x", y="urls", size=12, fill_color="green", line_color="orange", line_width=2) plot.add_glyph(circle_source, self.old_circles) self.session.store_document(self.document, dirty_only=False)
xdr = DataRange1d() ydr = DataRange1d() plot = Plot(title=None, x_range=xdr, y_range=ydr, plot_width=300, plot_height=300, h_symmetry=False, v_symmetry=False, min_border=0, toolbar_location=None) glyph = Segment(x0="x", y0="y", x1="xm01", y1="ym01", line_color="#f4a582", line_width=3) plot.add_glyph(source, glyph) xaxis = LinearAxis() plot.add_layout(xaxis, 'below') yaxis = LinearAxis() plot.add_layout(yaxis, 'left') plot.add_layout(Grid(dimension=0, ticker=xaxis.ticker)) plot.add_layout(Grid(dimension=1, ticker=yaxis.ticker)) doc = Document() doc.add_root(plot)
y_end=y - x**2 / 10 + 0.5, )) output_file("segments.html") p = figure(plot_width=400, plot_height=400, title="title_title", toolbar_location=None) p.add_glyph( segment_data, Segment(x0="x_start", y0="y_start", x1="x_end", y1="y_end", line_color="#f4a582", line_width=3, name="the_segments")) p.xaxis.name = "the_xaxis" p.xaxis.axis_label = "xaxis_label" p.yaxis.name = "the_yaxis" p.yaxis.axis_label = "yaxis_label" p.title.name = "the_title" if p.grid[0].dimension == 0: p.grid[0].name = "the_x_gridlines" p.grid[1].name = "the_y_gridlines" else: p.grid[0].name = "the_y_gridlines"
def draw_highlow_segment(): g0 = Segment(x0='T', y0='H', x1='T', y1='L', line_color='black') return g0
#alternate vol shock lists to get indices between two volume shocks x = 0 shocks1 = list() shocks2 = list() for i in range(len(vol_shock)): if vol_shock[i] == 1: x = x + 1 if x%2 == 1: shocks1.append(i) if x%2 == 0: shocks2.append(i) #coloring between shocks1[i] and shocks2[i] from bokeh.plotting import figure, show from bokeh.models.glyphs import Segment glyph = Segment(x0=0, y0=tcs_close[0], x1=1, y1=tcs_close[1], line_color="#f4a582", line_width=3) shock_col = figure() shock_col.line(range(0,len(tcs_close)), tcs_close, line_width = 2, color = 'blue') shock_col.add_glyph(glyph) show(shock_col) #4 #since data is of one year, 52 week moving average = data average from bokeh.plotting import figure, show avg = np.mean(tcs_close) from bokeh.models import ColumnDataSource, LinearColorMapper from bokeh.models import ColorBar from bokeh.transform import linear_cmap from bokeh.palettes import Spectral6