def _create_plot_component(): # Create a random scattering of XY pairs x = random.uniform(0.0, 10.0, 50) y = random.uniform(0.0, 5.0, 50) pd = ArrayPlotData(x=x, y=y) plot = Plot(pd, border_visible=True, overlay_border=True) scatter = plot.plot(("x", "y"), type="scatter", color="lightblue")[0] # Tweak some of the plot properties plot.set(title="Scatter Inspector Demo", padding=50) # Attach some tools to the plot plot.tools.append(PanTool(plot)) plot.overlays.append(ZoomTool(plot)) # Attach the inspector and its overlay scatter.tools.append(ScatterInspector(scatter)) overlay = ScatterInspectorOverlay(scatter, hover_color="red", hover_marker_size=6, selection_marker_size=6, selection_color="yellow", selection_outline_color="purple", selection_line_width=3) scatter.overlays.append(overlay) return plot
def _create_plot_component(): # Create a random scattering of XY pairs x = random.uniform(0.0, 10.0, 50) y = random.uniform(0.0, 5.0, 50) pd = ArrayPlotData(x = x, y = y) plot = Plot(pd, border_visible=True, overlay_border=True) scatter = plot.plot(("x", "y"), type="scatter", color="lightblue")[0] # Tweak some of the plot properties plot.set(title="Scatter Inspector Demo", padding=50) # Attach some tools to the plot plot.tools.append(PanTool(plot)) plot.overlays.append(ZoomTool(plot)) # Attach the inspector and its overlay inspector = ScatterInspector(scatter) scatter.tools.append(inspector) overlay = ScatterInspectorOverlay(scatter, hover_color="red", hover_marker_size=6, selection_marker_size=6, selection_color="yellow", selection_outline_color="purple", selection_line_width=3) scatter.overlays.append(overlay) # Optional: add a listener on inspector events: def echo(new): print("{} event on element {}".format(new.event_type, new.event_index)) inspector.on_trait_change(echo, "inspector_event") return plot
def _create_plot_component(): # Create a fake dataset from which 2 dimensions will be displayed in a # scatter plot: x = np.random.uniform(0.0, 10.0, 50) y = np.random.uniform(0.0, 5.0, 50) data = pd.DataFrame({ "x": x, "y": y, "dataset": np.random.choice(list("abcdefg"), 50) }) plot_data = ArrayPlotData(x=x, y=y) plot = Plot(plot_data) scatter = plot.plot(("x", "y"), type="scatter")[0] # Attach the inspector and its overlays inspector = DataframeScatterInspector(component=scatter, data=data) scatter.tools.append(inspector) text_overlay = DataframeScatterOverlay(component=plot, inspector=inspector, bgcolor="black", alpha=0.6, text_color="white", border_color='none') plot.overlays.append(text_overlay) # Optional: add an overlay on the point to confirm what is hovered over # Note that this overlay magically knows about hovered points by # listening to renderer events rather than inspector events: point_overlay = ScatterInspectorOverlay(component=scatter, hover_color="red", hover_marker_size=6) scatter.overlays.append(point_overlay) return plot
def _create_plot_component(): # Create some data npts = 100 x = sort(random(npts)) y = random(npts) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("index", x) pd.set_data("value", y) pd.set_data("value2", y * 2) # Create the plot plot = Plot(pd) plot.plot(("index", "value"), type="scatter", name="my_plot", marker="circle", index_sort="ascending", color="slategray", marker_size=6, bgcolor="white") plot.plot(("index", "value2"), type="scatter", name="my_plot", marker="circle", index_sort="ascending", color="red", marker_size=6, bgcolor="white") # Tweak some of the plot properties plot.title = "Scatter Plot With Selection" plot.line_width = 1 plot.padding = 50 # Right now, some of the tools are a little invasive, and we need the # actual ScatterPlot object to give to them my_plot = plot.plots["my_plot"][0] # Attach some tools to the plot my_plot.tools.append( ScatterInspector(my_plot, selection_mode="toggle", persistent_hover=False)) my_plot.overlays.append( ScatterInspectorOverlay(my_plot, hover_color="transparent", hover_marker_size=10, hover_outline_color="purple", hover_line_width=2, selection_marker_size=8, selection_color="lawngreen")) my_plot.tools.append(PanTool(my_plot)) my_plot.overlays.append(ZoomTool(my_plot, drag_button="right")) return plot
def _create_plot_component(self): """ Creates the plot component of the to be used in the FeatureScatter instance. """ x = np.zeros(len(self.data)) y = np.zeros(len(self.data)) c = np.zeros(len(self.data)) for i, (coord, count) in enumerate(self.data.items()): x[i], y[i] = coord c[i] = count c = np.log2(c) pd = ArrayPlotData() pd.set_data("x", x) pd.set_data("y", y) pd.set_data("color", c) cm = Map(DataRange1D(low=-c.max() / 2, high=c.max())) plot = Plot(pd) plot.plot(("x", "y", "color"), type="cmap_scatter", name="my_plot", marker="dot", index_sort="ascending", color_mapper=cm, marker_size=2, bgcolor=0xF7F7F7, ) plot.title = "Scatter Plot With Lasso Selection" plot.line_width = 1 plot.padding = 50 my_plot = plot.plots["my_plot"][0] my_plot.data = self.data my_plot.out_file = self.out_file my_plot.label = self.label lasso_selection = FeatureLasso(component=my_plot, selection_datasource=my_plot.index, drag_button="left") my_plot.tools.append(lasso_selection) my_plot.tools.append(BetterZoom(my_plot, zoom_factor=1.2)) my_plot.tools.append(PanTool(my_plot, drag_button="right")) my_plot.tools.append(ScatterInspector(my_plot)) lasso_overlay = LassoOverlay(lasso_selection=lasso_selection, component=my_plot, selection_fill_color=0xEF8A62) my_plot.overlays.append(lasso_overlay) my_plot.overlays.append(ScatterInspectorOverlay(my_plot, hover_marker_size=4)) return plot
def _create_plot_component(): # Create some data npts = 200 x = sort(random(npts)) y = random(npts) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("index", x) pd.set_data("value", y) # Create the plot plot = Plot(pd) plot.plot(("index", "value"), type="scatter", name="my_plot", marker="circle", index_sort="ascending", color="red", marker_size=4, bgcolor="white") # Tweak some of the plot properties plot.title = "Scatter Plot With Rectangular Selection" plot.line_width = 1 plot.padding = 50 # Right now, some of the tools are a little invasive, and we need the # actual ScatterPlot object to give to them my_plot = plot.plots["my_plot"][0] # Attach some tools to the plot rect_selection = RectangularSelection( component=my_plot, selection_datasource=my_plot.index, drag_button="left", metadata_name='selections', ) my_plot.tools.append(rect_selection) my_plot.tools.append(ScatterInspector(my_plot, selection_mode='toggle')) my_plot.active_tool = rect_selection lasso_overlay = LassoOverlay(lasso_selection=rect_selection, component=my_plot) my_plot.overlays.append(lasso_overlay) scatter_overlay = ScatterInspectorOverlay( component=my_plot, selection_color='cornflowerblue', selection_marker_size=int(my_plot.marker_size) + 3, selection_marker='circle') my_plot.overlays.append(scatter_overlay) return plot
def _update_corr_symbols(self): plot = self.corr_plot if self.corr_renderer is not None: # Remove the old one plot.remove(self.corr_renderer) self.corr_renderer = None self.corr_renderer = plot.plot( (self.sym1, self.sym2), type="scatter", color="blue")[0] self.corr_renderer.overlays.append( ScatterInspectorOverlay( self.corr_renderer, selection_color="lightgreen")) plot.request_redraw()
def _plot_default(self): container = DisableTrackingPlot( self.model.plot_data, live_plot=self, ) container.padding_left = 100 container.plot(('x', 'y'), type='line') scatter = container.plot( ('x', 'y'), type='scatter', marker_size=1, show_selection=False, color='lightskyblue', ) self.scatter = scatter[0] inspector = ScatterInspector( self.scatter, selection_mode='single', ) self.scatter.tools.append(inspector) overlay = ScatterInspectorOverlay(self.scatter, hover_color="lightskyblue", hover_marker_size=2, selection_marker_size=3, selection_color="lightskyblue", selection_outline_color="black", selection_line_width=1) self.scatter.overlays.append(overlay) self.scatter.index.on_trait_change( self._metadata_changed, "metadata_changed") self.zoom_tool = ZoomTool( container, ) container.underlays.append(self.zoom_tool) container.tools.append(self.zoom_tool) self.pan_tool = PanTool( container, ) container.tools.append(self.pan_tool) return container
def add_click_selector_tool(self, plot): """ Add scatter point click tool to select points. """ for i, renderer in enumerate(plot.components): marker_size = self.plot_style.renderer_styles[i].marker_size marker = self.plot_style.renderer_styles[i].marker inspector_tool = DataframeScatterInspector( renderer, selection_metadata_name=SELECTION_METADATA_NAME, selection_mode="toggle", persistent_hover=False) renderer.tools.append(inspector_tool) inspector_overlay = ScatterInspectorOverlay( renderer, selection_marker=marker, selection_marker_size=marker_size, selection_color=self.inspector_selection_color) renderer.overlays.append(inspector_overlay) # FIXME: This overwrite itself when multiple renderers are drawn... self.inspector = (inspector_tool, inspector_overlay)
def _add_scatter_inspector_overlay(self, scatter_plot): inspector = ScatterInspector( scatter_plot, threshold=10, multiselect_modifier=KeySpec(None, "shift"), selection_mode="multi", ) overlay = ScatterInspectorOverlay( scatter_plot, hover_color=(0, 0, 1, 1), hover_marker_size=6, selection_marker_size=20, selection_color=(0, 0, 1, 0.5), selection_outline_color=(0, 0, 0, 0.8), selection_line_width=3, ) scatter_plot.tools.append(inspector) scatter_plot.overlays.append(overlay)
def _plot_default(self): """ This creates the default value for the plot. """ # create the main plot object plot = Plot(self.plot_data) renderer = plot.plot(('index', 'value', 'color'), \ type="cmap_scatter", \ color_mapper=jet, \ marker='triangle' )[0] self.renderer = renderer # inspector tool for showing data about points #renderer.tools.append(ScatterInspector(renderer)) # overlay for highlighting selected points overlay = ScatterInspectorOverlay(renderer, hover_color="red", hover_marker_size=6, selection_marker_size=6, selection_color="yellow", selection_outline_color="black", selection_line_width=3) renderer.overlays.append(overlay) # add the additional information plot.title = 'Parameters Data' plot.x_axis.title = '' plot.y_axis.title = '' # tools for basic interactivity plot.tools.append(PanTool(plot)) plot.tools.append(ZoomTool(plot)) plot.tools.append(DragZoom(plot, drag_button="right")) return plot
def _create_plot_component(self): """ Creates the plot component of the to be used in the FeatureScatter instance. """ feature_types = self.features.keys() print(feature_types) x = np.array(self.features["BORDER"]["x"] + self.features["ADDITIONAL_BORDER"]["x"]) y = np.array(self.features["BORDER"]["y"] + self.features["ADDITIONAL_BORDER"]["y"]) pd = ArrayPlotData() pd.set_data("x", x) pd.set_data("y", y) plot = Plot(pd) plot.plot(("x", "y"), type="scatter", name="my_plot", color="red", index_sort="ascending", marker_size=2.0, bgcolor="black", line_width=0, ) my_plot = plot.plots["my_plot"][0] my_plot.tools.append(BetterZoom(my_plot, zoom_factor=1.2)) my_plot.tools.append(PanTool(my_plot, drag_button="right")) my_plot.tools.append(ScatterInspector(my_plot)) my_plot.overlays.append(ScatterInspectorOverlay(my_plot, hover_marker_size=4)) return plot
def _create_plot_component(self, recalc=False): container = VPlotContainer() ### Assemble the scatter plot of the Efficient Frontier x, y = self.get_stock_data() if not hasattr(self, "efx") or recalc: efx, efy, allocations = self.get_ef_data() else: efx = self.efx efy = self.efy p = self.portfolio symbs = p.symbols pd = ArrayPlotData(x=x, y=y, efx=efx, efy=efy, mp_x=[self.model_portfolio_x], mp_y=[self.model_portfolio_y]) # Create some plots of the data plot = Plot(pd, title="Efficient Frontier") # Create a scatter plot (and keep a handle on it) stockplt = plot.plot(("x", "y"), color="transparent", type="scatter", marker="dot", marker_line_color="transparent", marker_color="transparent", marker_size=1)[0] efplt = plot.plot(("efx", "efy"), color=(0.0,0.5,0.0,0.25), type="scatter", marker="circle", marker_size=6)[0] efpltline = plot.plot(("efx", "efy"), color=(0.1,0.4,0.1,0.7), type="line")[0] # Create another one-point scatter for a model portfolio mp_plot = plot.plot(("mp_x", "mp_y"), color=(1.0, 0.5, 0.5, 0.25), type="scatter", market="triangle", market_size=7)[0] for i in range(len(p.stocks)): label = DataPointLabel(component=plot, data_point=(x[i], y[i]), label_position="bottom right", padding=4, bgcolor="transparent", border_visible=False, text=self.symbols[i], marker="circle", marker_color=(0.0,0.0,0.5,0.25), marker_line_color="lightgray", marker_size=6, arrow_size=8.0, arrow_min_length=7.0, font_size=14) plot.overlays.append(label) tool = DataLabelTool(label, drag_button="left", auto_arrow_root=True) label.tools.append(tool) stockplt.tools.append(ScatterInspector(stockplt, selection_mode="toggle", persistent_hover=False)) scatinsp = ScatterInspectorOverlay(stockplt, hover_color = "red", hover_marker_size = 8, hover_outline_color = (0.7, 0.7, 0.7, 0.5), hover_line_width = 1) stockplt.overlays.append(scatinsp) # Tweak some of the plot properties plot.padding = 50 stockplt.value_range.low=0.0 stockplt.value_range.high=0.1 stockplt.index_range.low=0.0 stockplt.index_range.high=0.1 # Attach some tools to the plot plot.tools.append(PanTool(plot, drag_button="right")) plot.overlays.append(ZoomTool(plot)) #### Assemble the "stacked area" plot if not hasattr(self, "efx") or recalc: a = self.get_ef_data()[2] else: a = self.allocations rts = a.keys() rts.sort() rts = np.array(rts) symbs = a[rts[0]].keys() symbs.sort() # "Transpose" symbols' weights to get vectors of weights for each symbol symb_data = np.array([[a[rt][symb] for rt in rts] for symb in symbs]) self.symbols2 = [Symbol(symbol=symbs[i], color=COLORS[i]) for i in range(len(symbs))] # Create a plot data object and give it this data bpd = ArrayPlotData() bpd.set_data("index", rts) bpd.set_data("allocations", symb_data) # Create a contour polygon plot of the data bplot = Plot(bpd, title="Allocations") bplot.stacked_bar_plot(("index", "allocations"), color = COLORS, outline_color = "gray") bplot.padding = 50 #bplot.legend.visible = True # Add a plot of the stocks stock_obj_list = [p.stocks[symb] for symb in symbs] #for itm in stock_obj_list: #itm.print_traits() #print "Has Cache?:", itm.stock_data_cache is not None splot = StockPlot(stocks=[p.stocks[symb] for symb in symbs], colors=COLORS).plot container.add(bplot) container.add(plot) container.add(splot) return container
def _plot_default(self): stations = self.stations lon, lat = self._proj(stations['LON'].view(numpy.ndarray), stations['LAT'].view(numpy.ndarray)) shift = self._shift lon = (lon + shift / 2.) / (shift) lat = (lat + shift / 2.) / (shift) plot = Plot(ArrayPlotData(index=lon, value=lat)) plot.plot( ("index", "value"), type="scatter", name="stations", marker="dot", outline_color='black', color=(1., 0., 0., 0.2), line_width=1., marker_size=1, ) mbtiles_fname = os.path.join('Data', 'tiles.mbtiles') if os.path.exists(mbtiles_fname): tile_cache = MBTileManager(filename=mbtiles_fname, min_level=0, max_level=7) else: tile_cache = HTTPTileManager( min_level=0, max_level=6, server='oatile1.mqcdn.com', url='/tiles/1.0.0/sat/%(zoom)d/%(row)d/%(col)d.jpg', ) # Right now, some of the tools are a little invasive, and we need the # actual ScatterPlot object to give to them scatter = plot.plots['stations'][0] map = Map(scatter, tile_cache=tile_cache, alpha=0.8, zoom_level=2) scatter.underlays.append(map) map.on_trait_change(lambda new: self._update_scatter(scatter, new), 'zoom_level') self._update_scatter(scatter, map.zoom_level) lasso_selection = LassoSelection(component=scatter, selection_datasource=scatter.index) scatter.tools.append(lasso_selection) scatter.overlays.append( LassoOverlay(component=scatter, selection_fill_color='lawngreen', selection_border_color='lightgreen', selection_alpha=0.5, selection_border_width=2.0, lasso_selection=lasso_selection)) scatter.overlays.append( ScatterInspectorOverlay(scatter, selection_metadata_name='selection', selection_marker_size=4, selection_color="lawngreen")) scatter.index.on_trait_change(self._metadata_handler, "metadata_changed") scatter.tools.append(PanTool(scatter, drag_button='right')) scatter.tools.append(ZoomTool(scatter)) plot.index_axis.title = "Longitude" plot.index_axis.tick_label_formatter = self._convert_lon plot.value_axis.title = "Latitude" plot.value_axis.tick_label_formatter = self._convert_lat plot.padding_right = plot.padding_top = 2 container = OverlayPlotContainer(use_backbuffer=True, bgcolor="sys_window") container.add(plot) container.bgcolor = "sys_window" return container