def _resplotter_default(self): res = np.zeros((400, 400)) self.pd = ArrayPlotData(res=res) p = Plot(self.pd) img = p.img_plot('res', name="my_plot") my_plot = p.plots["my_plot"][0] colormap = my_plot.color_mapper colorbar = ColorBar( index_mapper=dc.LinearMapper(range=colormap.range), color_mapper=colormap, orientation='v', plot=my_plot, resizable='v', width=30, padding=20) range_selection = RangeSelection(component=colorbar) colorbar.tools.append(range_selection) colorbar.overlays.append(RangeSelectionOverlay(component=colorbar, border_color="white", alpha=0.8, fill_color="lightgray")) range_selection.listeners.append(my_plot) con = HPlotContainer() con.add(p) con.add(colorbar) return con
def _plot_default(self): self.data = self._data_default() plot = Plot(self.data) for ii, s_name in enumerate(self._samples): color = COLORS[ii % len(self._samples)] plot.plot(('bins',s_name), name=s_name, type='filled_line', edge_color=color, face_color=color, alpha=0.5, bgcolor='white', render_style='hold') # render_style determines whether interpolate plot.index = plot._get_or_create_datasource('bins') #set index name manually so range selection works plot.index_scale = 'log' plot.title = 'Fermi Plot' plot.padding = 50 plot.legend.visible = True plot.tools.append(PanTool(plot)) plot.active_tool = RangeSelection(plot) plot.overlays.append(RangeSelectionOverlay(component=plot)) zoom = ZoomTool(component=plot, tool_mode='box', always_on=False) plot.overlays.append(zoom) return plot
def update_main_plot(self): """ Build main plot """ self.ts_plot = ToolbarPlot(self.arr_plot_data) for i, k in enumerate([k for k in self.ts_data.keys() if k != "index"]): renderer = self.ts_plot.plot(("index", k), name = k, color = colors[i % len(colors)])[0] if self.index_is_dates: # Index was an array of datetime: overwrite the x axis self.ts_plot.x_axis = None x_axis = PlotAxis(self.ts_plot, orientation="bottom", tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem())) self.ts_plot.overlays.append(x_axis) self.ts_plot.x_grid.tick_generator = x_axis.tick_generator if self.data_file: self.ts_plot.title = ("Time series visualization from %s" % (os.path.split(self.data_file)[1])) else: self.ts_plot.title = "Time series visualization" attach_tools(self.ts_plot) # Attach the range selection to the last renderer; any one will do self.ts_plot.tools.append(RangeSelection(renderer, left_button_selects = False, auto_handle_event = False)) # Attach the corresponding overlay self._range_selection_overlay = RangeSelectionOverlay(renderer, metadata_name="selections") self.ts_plot.overlays.append(self._range_selection_overlay) # Grab a reference to the Time axis datasource and add a listener to its # selections metadata self.times_ds = renderer.index self.times_ds.on_trait_change(self._selections_changed)
def control(self): """ A drawable control with a color bar. """ color_map = self.plot_obj.color_mapper linear_mapper = LinearMapper(range=color_map.range) color_bar = ColorBar(index_mapper=linear_mapper, color_mapper=color_map, plot=self.plot_obj, orientation='v', resizable='v', width=30) color_bar._axis.tick_label_formatter = self.sci_formatter color_bar.padding_top = self.padding_top color_bar.padding_bottom = self.padding_bottom color_bar.padding_left = 50 # Room for labels. color_bar.padding_right = 10 range_selection = RangeSelection(component=color_bar) range_selection.listeners.append(self.plot_obj) color_bar.tools.append(range_selection) range_selection_overlay = RangeSelectionOverlay(component=color_bar) color_bar.overlays.append(range_selection_overlay) container = HPlotContainer(use_backbuffer=True) container.add(self) container.add(color_bar) return Window(self.parent, component=container).control
def _update_rangeselect(self): ''' Overwrites range selection tool in current plot.''' #### Remove current overlay self.plot.overlays = [ obj for obj in self.plot.overlays if not isinstance(obj, RangeSelectionOverlay) ] mycomp = self.plot.plots.itervalues().next()[ 0] #Quick wayt to get first value in dictionary inds = range(len(self.df.index)) idx = ArrayDataSource(inds) vals = ArrayDataSource(df.index.values) index_range = DataRange1D(idx) val_range = DataRange1D(vals) imap = LinearMapper( range=index_range) #,stretch_data=self.index_mapper.stretch_data) vmap = LinearMapper(range=val_range) # mycomp.index_range.refresh() mycomp.index_mapper = imap mycomp.value_mapper = vmap self.rangeselect = RangeSelection(mycomp, axis=self.selection_axis) self.plot.active_tool = self.rangeselect self.plot.overlays.append(RangeSelectionOverlay(component=mycomp)) self.rangeselect.on_trait_change(self.on_selection_changed, "selection")
def _create_price_plots(self, times, prices, mini_height=75): """ Creates the two plots of prices and returns them. One of the plots can be zoomed and panned, and the other plot (smaller) always shows the full data. *dates* and *prices* are two data sources. """ # Create the price plot price_plot = FilledLinePlot( index=times, value=prices, index_mapper=LinearMapper(range=DataRange1D(times)), value_mapper=LinearMapper(range=DataRange1D(prices)), edge_color="blue", face_color="paleturquoise", bgcolor="white", border_visible=True) # Add pan and zoom price_plot.tools.append( PanTool( price_plot, constrain=True, constrain_direction="x")) price_plot.overlays.append( ZoomTool( price_plot, drag_button="right", always_on=True, tool_mode="range", axis="index", max_zoom_out_factor=1.0, )) # Create the miniplot miniplot = LinePlot( index=times, value=prices, index_mapper=LinearMapper(range=DataRange1D(times)), value_mapper=LinearMapper(range=DataRange1D(prices)), color="black", border_visible=True, bgcolor="white", height=mini_height, resizable="h") # Add a range overlay to the miniplot that is hooked up to the range # of the main price_plot range_tool = RangeSelection(miniplot) miniplot.tools.append(range_tool) range_overlay = RangeSelectionOverlay( miniplot, metadata_name="selections") miniplot.overlays.append(range_overlay) range_tool.on_trait_change(self._range_selection_handler, "selection") # Attach a handler that sets the tool when the plot's index range changes self.range_tool = range_tool price_plot.index_range.on_trait_change(self._plot_range_handler, "updated") return price_plot, miniplot
def _featureselmode_changed(self, old, new): pl = self.plot if new == 'No Selection': pl.tools[0].drag_button = 'left' self.maintool = (None, None) elif new == 'Click Select': pl.tools[0].drag_button = 'right' fctool = FeatureClickTool(plot=self.plot) self.maintool = (fctool, None) fctool.on_trait_change(self._add_feature_point, 'mouse_clicked') elif new == 'Range Select': pl.tools[0].drag_button = 'right' fplot = pl.plots['flux'][0] #TODO:clean up these hacky bugfix techniques if possible rstool = RangeSelectionBugfix(component=fplot, left_button_selects=True, enable_resize=False, mapper=self.plot.x_mapper) rstool.plot = fplot rstool.component = pl rsoverlay = RangeSelectionOverlay(component=fplot, mapper=self.plot.x_mapper) rsoverlay.plot = fplot rsoverlay.component = pl self.maintool = (rstool, rsoverlay) rstool.on_trait_change(self._add_feature_range, 'selection_completed') elif new == 'Base Select': pl.tools[0].drag_button = 'right' slt = SingleLineTool(component=self.plot) slt.component = self.plot self.maintool = (slt, slt) slt.on_trait_change(self._add_feature_base, 'finished') elif new == 'Click Delete': pl.tools[0].drag_button = 'right' fctool = FeatureClickTool(plot=self.plot) self.maintool = (fctool, None) fctool.on_trait_change(self._del_feature_point, 'mouse_clicked') else: assert True, 'enum invalid!'
def _featureselmode_changed(self,old,new): pl = self.plot if new == 'No Selection': pl.tools[0].drag_button = 'left' self.maintool = (None,None) elif new == 'Click Select': pl.tools[0].drag_button = 'right' fctool = FeatureClickTool(plot=self.plot) self.maintool = (fctool,None) fctool.on_trait_change(self._add_feature_point,'mouse_clicked') elif new == 'Range Select': pl.tools[0].drag_button = 'right' fplot = pl.plots['flux'][0] #TODO:clean up these hacky bugfix techniques if possible rstool = RangeSelectionBugfix(component=fplot, left_button_selects=True, enable_resize=False, mapper=self.plot.x_mapper) rstool.plot = fplot rstool.component = pl rsoverlay = RangeSelectionOverlay(component=fplot, mapper=self.plot.x_mapper) rsoverlay.plot = fplot rsoverlay.component = pl self.maintool = (rstool,rsoverlay) rstool.on_trait_change(self._add_feature_range,'selection_completed') elif new == 'Base Select': pl.tools[0].drag_button = 'right' slt = SingleLineTool(component=self.plot) slt.component = self.plot self.maintool = (slt,slt) slt.on_trait_change(self._add_feature_base,'finished') elif new == 'Click Delete': pl.tools[0].drag_button = 'right' fctool = FeatureClickTool(plot=self.plot) self.maintool = (fctool,None) fctool.on_trait_change(self._del_feature_point,'mouse_clicked') else: assert True,'enum invalid!'
def plot_datasets(self, datasets, scale='linear', reset_view=True): if self.plots: self.plot.delplot(*self.plot.plots.keys()) self.plots = {} active = filter(lambda d: d.metadata['ui'].active, datasets) hilite = filter(lambda d: d.metadata['ui'].markers, active) if len(active)==0: return None for dataset in active: ui = dataset.metadata['ui'] data = dataset.data name = ui.name or dataset.name x, y = np.transpose(data[:, [0,1]]) self.plot_data.set_data(name + '_x', x) self.plot_data.set_data(name + '_y', rescale(y, method=scale)) color = ui.color if color is None: color = 'auto' plot = self.plot.plot((name + '_x', name + '_y'), name=name, type='line', color=color, line_width=ui.line_width) if color == 'auto': ui.color = tuple( (np.array(plot[0].color_) * 255).astype('uint8').tolist()) self.plots[name] = plot for dataset in hilite: ui = dataset.metadata['ui'] data = dataset.data name = ui.name or dataset.name # Overlay a scatter plot on the original line plot to highlight # data points as circles. plot = self.plot.plot((name + '_x', name + '_y'), name=name + '_selection', type='scatter', color=ui.color, outline_color=ui.color, marker_size=ui.marker_size, line_width=ui.line_width) self.plots[name] = plot if len(datasets) > 0: self.plot0renderer = plot[0] self.range_selection_tool = RangeSelection(self.plot0renderer, left_button_selects=True) self.range_selection_overlay = RangeSelectionOverlay(component=self.plot0renderer) if reset_view: self.reset_view() # Since highlighted datasets are plotted twice, both plots show up in # the legend. This fixes that. self.plot.legend.plots = self.plots self.show_legend('Overlay') self._set_scale(scale)
def _plot_default(self): plot_data = ArrayPlotData( x=np.linspace(0, 1, 10), y=np.linspace(0, 1, 10) ) plot = Plot(plot_data) r, = plot.plot(("x", "y")) range_tool = RangeSelection(r) r.overlays.append(RangeSelectionOverlay(axis='index', component=r)) r.tools.append(range_tool) self.range_tool = range_tool return plot
def create_colorbar(colormap): colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, orientation='v', resizable='v', width=30, padding=20) colorbar.tools.append(RangeSelection(component=colorbar)) colorbar.overlays.append(RangeSelectionOverlay(component=colorbar, border_color="white", alpha=0.8, fill_color="lightgray")) return colorbar
def setup(self, x, y, ans): p = self.new_plot() p.padding_left = 60 p.y_axis.tick_label_formatter = tick_formatter p.y_axis.tick_generator = StaticTickGenerator() p.y_axis.title = 'Analysis Type' # p.y_grid.line_style='solid' # p.y_grid.line_color='green' # p.y_grid.line_weight = 1.5 self.set_y_limits(min_=-1, max_=len(TICKS)) p.index_range.tight_bounds = False p.x_axis.tick_generator = ScalesTickGenerator( scale=CalendarScaleSystem()) p.x_grid.tick_generator = p.x_axis.tick_generator p.x_axis.title = 'Time' # p.y_axis.tick_label_rotate_angle = 45 scatter, _ = self.new_series(x, y, type='scatter', marker_size=1.5, selection_marker='circle', selection_marker_size=2.5) broadcaster = BroadcasterTool() scatter.tools.append(broadcaster) point_inspector = AnalysisPointInspector( scatter, analyses=ans, value_format=get_analysis_type, additional_info=lambda x: ('Time={}'.format(x.rundate), 'Project={}'.format(x.project))) pinspector_overlay = PointInspectorOverlay(component=scatter, tool=point_inspector) range_selector = RangeSelection(scatter, left_button_selects=True) broadcaster.tools.append(point_inspector) broadcaster.tools.append(range_selector) scatter.overlays.append(RangeSelectionOverlay(component=scatter)) scatter.overlays.append(pinspector_overlay) self.scatter = scatter
def _create_returns_plot(self): plot = Plot(self.plotdata) plot.legend.visible = True #FIXME: The legend move tool doesn't seem to quite work right now #plot.legend.tools.append(LegendTool(plot.legend)) plot.x_axis = None x_axis = PlotAxis( plot, orientation="bottom", tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem())) plot.overlays.append(x_axis) plot.x_grid.tick_generator = x_axis.tick_generator for i, name in enumerate(self.plotdata.list_data()): if name == "times": continue renderer = plot.plot(("times", name), type="line", name=name, color=tuple(COLOR_PALETTE[i]))[0] # Tricky: need to set auto_handle_event on the RangeSelection # so that it passes left-clicks to the PanTool # FIXME: The range selection is still getting the initial left down renderer.tools.append( RangeSelection(renderer, left_button_selects=False, auto_handle_event=False)) plot.tools.append( PanTool(plot, drag_button="left", constrain=True, constrain_direction="x", restrict_to_data=True)) plot.overlays.append( ZoomTool(plot, tool_mode="range", max_zoom_out=1.0, x_min_zoom_factor=float(1e-3))) # Attach the range selection to the last renderer; any one will do self._range_selection_overlay = RangeSelectionOverlay( renderer, metadata_name="selections") renderer.overlays.append(self._range_selection_overlay) # Grab a reference to the Time axis datasource and add a listener to its # selections metadata self.times_ds = renderer.index self.times_ds.on_trait_change(self._selections_changed, 'metadata_changed') self.returns_plot = plot
def _time_plot_default(self): plot = Plot(self.data) line_plot = plot.plot(('t', 'y'))[0] line_plot.active_tool = RangeSelection(line_plot, left_button_selects=True) line_plot.overlays.append(RangeSelectionOverlay(component=line_plot)) self.selection = line_plot.active_tool plot.padding = 20 plot.padding_left = 50 self.selection.on_trait_change(self.handle_selection_change, 'selection') return plot
def _create_returns_plot(self): plot = Plot(self.plotdata) plot.legend.visible = False plot.x_axis = None x_axis = PlotAxis( plot, orientation="bottom", tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem())) plot.overlays.append(x_axis) plot.x_grid.tick_generator = x_axis.tick_generator for i, name in enumerate(self.plotdata.list_data()): if name == "times": continue renderer = plot.plot(("times", name), type="line", name=name, color="auto", line_width=2)[0] self.times_ds = renderer.index print('chaco: %s') % str(time.time() - tic) # Tricky: need to set auto_handle_event on the RangeSelection # so that it passes left-clicks to the PanTool # FIXME: The range selection is still getting the initial left down renderer.tools.append( RangeSelection(renderer, left_button_selects=False, auto_handle_event=False)) plot.tools.append( PanTool(plot, drag_button="left", constrain=True, constrain_direction="x")) plot.overlays.append( ZoomTool(plot, tool_mode="range", max_zoom_out=1.0)) # Attach the range selection to the last renderer; any one will do self._range_selection_overlay = RangeSelectionOverlay( renderer, metadata_name="selections") renderer.overlays.append(self._range_selection_overlay) # Grab a reference to the Time axis datasource and add a listener to its # selections metadata self.times_ds = renderer.index self.times_ds.on_trait_change(self._selections_changed, 'metadata_changed') self.returns_plot = plot
def _create_plot_component(use_downsampling=True): container = OverlayPlotContainer(padding=40, bgcolor="lightgray", use_backbuffer=True, border_visible=True, fill_padding=True) numpoints = 100000 low = -5 high = 15.0 x = arange(low, high + 0.001, (high - low) / numpoints) # Plot some bessel functionsless ../en value_mapper = None index_mapper = None for i in range(10): y = jn(i, x) plot = create_line_plot((x, y), color=tuple(COLOR_PALETTE[i]), width=2.0) plot.use_downsampling = use_downsampling if value_mapper is None: index_mapper = plot.index_mapper value_mapper = plot.value_mapper add_default_grids(plot) add_default_axes(plot) else: plot.value_mapper = value_mapper value_mapper.range.add(plot.value) plot.index_mapper = index_mapper index_mapper.range.add(plot.index) if i % 2 == 1: plot.line_style = "dash" plot.bgcolor = "white" container.add(plot) selection_overlay = RangeSelectionOverlay(component=plot) plot.tools.append(RangeSelection(plot)) zoom = ZoomTool(plot, tool_mode="box", always_on=False) plot.overlays.append(selection_overlay) plot.overlays.append(zoom) return container
def generate_colorbar(self, desc): """ Generate the colorbar to display along side the plot. """ super(CmapScatterPlotFactory, self).generate_colorbar(desc) colorbar = self.colorbar cmap_renderer = self._get_cmap_renderer() select_tool = "colorbar_selector" in self.plot_tools if select_tool: selection = ColormappedSelectionOverlay(cmap_renderer, fade_alpha=0.35, selection_type="mask") cmap_renderer.overlays.append(selection) colorbar.tools.append(RangeSelection(component=colorbar)) overlay = RangeSelectionOverlay(component=colorbar, border_color="white", alpha=0.8, fill_color="lightgray") colorbar.overlays.append(overlay)
def _create_plot_component(): numpoints = 100 low = -5 high = 15.001 x = arange(low, high, (high - low) / numpoints) # Plot a bessel function y = jn(0, x) plot = create_line_plot((x, y), color=(0, 0, 1, 1), width=2.0, index_sort="ascending") value_range = plot.value_mapper.range plot.active_tool = RangeSelection(plot, left_button_selects=True) plot.overlays.append(RangeSelectionOverlay(component=plot)) plot.bgcolor = "white" plot.padding = 50 add_default_grids(plot) add_default_axes(plot) return plot
def _create_plot_component(self): # find longest date index_lengths = [] for stock in self.stocks: if stock.stock_data_cache is not None: index_lengths.append(len(stock.stock_data_cache['date'])) else: index_lengths.append(len(stock.stock_data['date'])) index_lengths = np.array(index_lengths) lngest = index_lengths.argmax() shrtest = index_lengths.argmin() index = np.array([ time.mktime(x.timetuple()) for x in self.stocks[lngest].dates.tolist() ]) sel_range_low = time.mktime( self.stocks[shrtest].dates.tolist()[0].timetuple()) sel_range_high = time.mktime( self.stocks[shrtest].dates.tolist()[-1].timetuple()) sel_range_low_idx = np.where(index == sel_range_low)[0].item() sel_range_high_idx = np.where(index == sel_range_high)[0].item() pd = ArrayPlotData() # Now plot the returns for each asset (cumulative sum of periodic rates of return) for i in range(len(self.stocks)): if self.stocks[i].stock_data_cache is None: stk = self.stocks[i].stock_data else: stk = self.stocks[i].stock_data_cache pd.set_data( "idx%s" % i, np.array([ time.mktime(x.timetuple()) for x in stk['date'].tolist() ])) pd.set_data("y%s" % i, metrics.rate_array(stk)['rate'].cumsum()) plot = Plot(pd, bgcolor="none", padding=30, border_visible=True, overlay_border=True, use_backbuffer=False) for i in range(len(self.stocks)): # hang on to a reference to the last one of these... plt = plot.plot(("idx%s" % i, "y%s" % i), name=self.stocks[i].symbol, color=self.colors[i]) #value_range = plot.value_mapper.range #index_range = plot.index_mapper.range plt[0].active_tool = RangeSelection(plt[0], left_button_selects=True) plt[0].active_tool.selection = [ index[sel_range_low_idx], index[sel_range_high_idx] ] plt[0].overlays.append(RangeSelectionOverlay(component=plt[0])) #plot.bgcolor = "white" plot.padding = 50 add_default_grids(plot) # Set the plot's bottom axis to use the Scales ticking system scale_sys = CalendarScaleSystem( fill_ratio=0.4, default_numlabels=5, default_numticks=10, ) tick_gen = ScalesTickGenerator(scale=scale_sys) bottom_axis = PlotAxis(plot, orientation="bottom", tick_generator=tick_gen, label_color="white", line_color="white") # Hack to remove default axis - TODO: how do I *replace* an axis? del (plot.underlays[-4]) plot.overlays.append(bottom_axis) plot.legend.visible = True return plot
def create_hplot(self, key=None, mini=False): if mini: hpc = HPlotContainer(bgcolor='darkgrey', height=MINI_HEIGHT, resizable='h', padding=0) else: hpc = HPlotContainer(bgcolor='lightgrey', padding=HPLOT_PADDING, resizable='hv') # make slice plot for showing intesity profile of main plot #************************************************************ slice_plot = Plot(self.data, width=SLICE_PLOT_WIDTH, orientation="v", resizable="v", padding=MAIN_PADDING, padding_left=MAIN_PADDING_LEFT, bgcolor='beige', origin='top left') slice_plot.x_axis.visible = False slice_key = key + '_slice' ydata_key = key + '_y' slice_plot.plot((ydata_key, slice_key), name=slice_key) # make main plot for editing depth lines #************************************************************ main = Plot( self.data, border_visible=True, bgcolor='beige', origin='top left', padding=MAIN_PADDING, padding_left=MAIN_PADDING_LEFT, ) if mini: main.padding = MINI_PADDING # add intensity img to plot and get reference for line inspector #************************************************************ img_plot = main.img_plot(key, name=key, xbounds=self.model.xbounds[key], ybounds=self.model.ybounds[key], colormap=self._cmap)[0] # add line plots: use method since these may change #************************************************************ self.update_line_plots(key, main, update=True) # set slice plot index range to follow main plot value range #************************************************************ slice_plot.index_range = main.value_range # add vertical core lines to main plots and slices #************************************************************ # save pos and distance in session dict for view info and control for core in self.model.core_samples: loc_index, loc, dist = self.model.core_info_dict[core.core_id] # add boundarys to slice plot ref_line = self.model.final_lake_depth self.plot_core_depths(slice_plot, core, ref_line, loc_index) # add positions to main plots self.plot_core(main, core, ref_line, loc_index, loc) # now add tools depending if it is a mini plot or not #************************************************************ if mini: # add range selection tool only # first add a reference line to attach it to reference = self.make_reference_plot() main.add(reference) # attache range selector to this plot range_tool = RangeSelection(reference) reference.tools.append(range_tool) range_overlay = RangeSelectionOverlay(reference, metadata_name="selections") reference.overlays.append(range_overlay) range_tool.on_trait_change(self._range_selection_handler, "selection") # add zoombox to mini plot main.plot(('zoombox_x', 'zoombox_y'), type='polygon', face_color=ZOOMBOX_COLOR, alpha=ZOOMBOX_ALPHA) # add to hplot and dict hpc.add(main) self.hplot_dict['mini'] = hpc else: # add zoom tools main.tools.append(PanTool(main)) zoom = ZoomTool(main, tool_mode='box', axis='both', alpha=0.5) main.tools.append(zoom) main.overlays.append(zoom) main.value_mapper.on_trait_change(self.zoom_all_value, 'updated') main.index_mapper.on_trait_change(self.zoom_all_index, 'updated') # add line inspector and attach to freeze tool #********************************************* line_inspector = LineInspector(component=img_plot, axis='index_x', inspect_mode="indexed", is_interactive=True, write_metadata=True, metadata_name='x_slice', is_listener=True, color="white") img_plot.overlays.append(line_inspector) self.inspector_freeze_tool.tool_set.add(line_inspector) # add listener for changes to metadata made by line inspector #************************************************************ img_plot.on_trait_change(self.metadata_changed, 'index.metadata') # set slice plot index range to follow main plot value range #************************************************************ slice_plot.index_range = main.value_range # add clickable legend ; must update legend when depth_dict updated #****************************************************************** legend = Legend(component=main, padding=0, align="ur", font='modern 8') legend_highlighter = LegendHighlighter(legend, drag_button="right") legend.tools.append(legend_highlighter) self.update_legend_plots(legend, main) legend.visible = False self.legend_dict[key] = [legend, legend_highlighter] main.overlays.append(legend) # add main and slice plot to hplot container and dict #**************************************************** main.title = 'frequency = {} kHz'.format(key) main.title_font = TITLE_FONT hpc.add(main, slice_plot) self.hplot_dict[key] = hpc return hpc
def _create_plot_component(): # Create a scalar field to colormap# Create a scalar field to colormap xbounds = (-2 * pi, 2 * pi, 600) ybounds = (-1.5 * pi, 1.5 * pi, 300) xs = linspace(*xbounds) ys = linspace(*ybounds) x, y = meshgrid(xs, ys) z = jn(2, x) * y * x # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("imagedata", z) # Create the plot plot = Plot(pd) plot.img_plot( "imagedata", name="my_plot", xbounds=xbounds[:2], ybounds=ybounds[:2], colormap=jet) # Tweak some of the plot properties plot.title = "Selectable Image Plot" plot.padding = 50 # Right now, some of the tools are a little invasive, and we need the # actual CMapImage object to give to them my_plot = plot.plots["my_plot"][0] # Attach some tools to the plot plot.tools.append(PanTool(plot)) zoom = ZoomTool(component=plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) # Create the colorbar, handing in the appropriate range and colormap colormap = my_plot.color_mapper colorbar = ColorBar( index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=my_plot, orientation='v', resizable='v', width=30, padding=20) colorbar.padding_top = plot.padding_top colorbar.padding_bottom = plot.padding_bottom # create a range selection for the colorbar range_selection = RangeSelection(component=colorbar) colorbar.tools.append(range_selection) colorbar.overlays.append( RangeSelectionOverlay( component=colorbar, border_color="white", alpha=0.8, fill_color="lightgray")) # we also want to the range selection to inform the cmap plot of # the selection, so set that up as well range_selection.listeners.append(my_plot) # Create a container to position the plot and the colorbar side-by-side container = HPlotContainer(use_backbuffer=True) container.add(plot) container.add(colorbar) container.bgcolor = "lightgray" #my_plot.set_value_selection((-1.3, 6.9)) return container
def _create_plot_component(self): # we need the matrices! # start with the currently selected one #nr_nodes = self.matrix_data_ref[curr_edge].shape[0] # Create a plot data obect and give it this data self.pd = ArrayPlotData() self.pd.set_data("imagedata", self.matrix_data_ref[self.curr_edge]) # Create the plot self.tplot = Plot(self.pd, default_origin="top left") self.tplot.x_axis.orientation = "top" self.tplot.img_plot( "imagedata", name="my_plot", #xbounds=(0,nr_nodes), #ybounds=(0,nr_nodes), colormap=jet) # Tweak some of the plot properties self.tplot.title = self.curr_edge self.tplot.padding = 50 # Right now, some of the tools are a little invasive, and we need the # actual CMapImage object to give to them self.my_plot = self.tplot.plots["my_plot"][0] # Attach some tools to the plot self.tplot.tools.append(PanTool(self.tplot)) zoom = ZoomTool(component=self.tplot, tool_mode="box", always_on=False) self.tplot.overlays.append(zoom) # my custom tool to get the connection information self.custtool = CustomTool(self.tplot) self.tplot.tools.append(self.custtool) # Create the colorbar, handing in the appropriate range and colormap colormap = self.my_plot.color_mapper self.colorbar = ColorBar( index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=self.my_plot, orientation='v', resizable='v', width=30, padding=20) self.colorbar.padding_top = self.tplot.padding_top self.colorbar.padding_bottom = self.tplot.padding_bottom # TODO: the range selection gives a Segmentation Fault, # but why, the matrix_viewer.py example works just fine! # create a range selection for the colorbar self.range_selection = RangeSelection(component=self.colorbar) self.colorbar.tools.append(self.range_selection) self.colorbar.overlays.append( RangeSelectionOverlay(component=self.colorbar, border_color="white", alpha=0.8, fill_color="lightgray")) # we also want to the range selection to inform the cmap plot of # the selection, so set that up as well #self.range_selection.listeners.append(self.my_plot) # Create a container to position the plot and the colorbar side-by-side container = HPlotContainer(use_backbuffer=True) container.add(self.tplot) container.add(self.colorbar) container.bgcolor = "white" # my_plot.set_value_selection((-1.3, 6.9)) return container
def add_range_selector(self, plotid=0, series=0): # plot = self.series[plotid][series] plot = self.plots[plotid].plots['plot{}'.format(series)][0] plot.active_tool = RangeSelection(plot, left_button_selects=True) plot.overlays.append(RangeSelectionOverlay(component=plot))
def __init__(self, **kw): super(MLabChacoPlot, self).__init__(**kw) self.prices = get_data() x = self.prices['Date'] pd = ArrayPlotData(index = x) pd.set_data("y", self.prices["Crude Supply"]) # Create some line plots of some of the data plot = Plot(pd, bgcolor="none", padding=30, border_visible=True, overlay_border=True, use_backbuffer=False) #plot.legend.visible = True plot.plot(("index", "y"), name="Crude Price", color=(.3, .3, .8, .8)) #plot.tools.append(PanTool(plot)) plot.tools.append(PanTool(plot, constrain=True, drag_button="right", constrain_direction="x")) range_plt = plot.plots['Crude Price'][0] range_selection = RangeSelection(range_plt, left_button_selects=True) range_selection.on_trait_change(self.update_interval, 'selection') range_plt.tools.append(range_selection) range_plt.overlays.append(RangeSelectionOverlay(range_plt)) zoom = ZoomTool(component=plot, tool_mode="range", always_on=False, axis="index", max_zoom_out_factor=1.0,) plot.overlays.append(zoom) # Set the plot's bottom axis to use the Scales ticking system scale_sys = CalendarScaleSystem(fill_ratio=0.4, default_numlabels=5, default_numticks=10,) tick_gen = ScalesTickGenerator(scale=scale_sys) bottom_axis = ScalesPlotAxis(plot, orientation="bottom", tick_generator=tick_gen, label_color="white", line_color="white") # Hack to remove default axis - FIXME: how do I *replace* an axis? del(plot.underlays[-2]) plot.overlays.append(bottom_axis) # Create the mlab test mesh and get references to various parts of the # VTK pipeline f = mlab.figure(size=(700,500)) self.m = mlab.points3d(self.prices['Gasoline Supply'], self.prices['Jet Fuel Supply'], self.prices['Distillate Supply'], self.prices['Crude Supply']) # Add another glyph module to render the full set of points g2 = Glyph() g2.glyph.glyph_source.glyph_source.glyph_type = "circle" g2.glyph.glyph_source.glyph_source.filled = True g2.actor.property.opacity = 0.75 self.m.module_manager.source.add_module(g2) # Set a bunch of properties on the scene to make things look right self.m.module_manager.scalar_lut_manager.lut_mode = 'PuBuGn' self.m.glyph.mask_points.random_mode = False self.m.glyph.mask_points.on_ratio = 1 self.m.scene.isometric_view() self.m.scene.background = (.9, 0.95, 1.0) scene = mlab.gcf().scene render_window = scene.render_window renderer = scene.renderer rwi = scene.interactor plot.resizable = "" plot.bounds = [600,120] plot.padding = 25 plot.bgcolor = "white" plot.outer_position = [30,30] plot.tools.append(MoveTool(component=plot,drag_button="right")) container = OverlayPlotContainer(bgcolor = "transparent", fit_window = True) container.add(plot) # Create the Enable Window window = EnableVTKWindow(rwi, renderer, component=container, istyle_class = tvtk.InteractorStyleTrackballCamera, bgcolor = "transparent", event_passthrough = True, ) mlab.show()
def _create_plot_component(self): # Create a plot data object and give it this data self.pd = ArrayPlotData() self.pd.set_data("imagedata", self.data[self.data_name]) # find dimensions xdim = self.data[self.data_name].shape[1] ydim = self.data[self.data_name].shape[0] # Create the plot self.tplot = Plot(self.pd, default_origin="top left") self.tplot.x_axis.orientation = "top" self.tplot.img_plot("imagedata", name="my_plot", xbounds=(0.5, xdim + 0.5), ybounds=(0.5, ydim + 0.5), colormap=jet) # Tweak some of the plot properties self.tplot.title = "Connection Matrix for %s" % self.data_name self.tplot.padding = 80 # Right now, some of the tools are a little invasive, and we need the # actual CMapImage object to give to them self.my_plot = self.tplot.plots["my_plot"][0] # Attach some tools to the plot self.tplot.tools.append(PanTool(self.tplot)) zoom = ZoomTool(component=self.tplot, tool_mode="box", always_on=False) self.tplot.overlays.append(zoom) # my custom tool to get the connection information self.custtool = CustomTool(self.tplot) self.tplot.tools.append(self.custtool) # Create the colorbar, handing in the appropriate range and colormap colormap = self.my_plot.color_mapper self.colorbar = ColorBar( index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=self.my_plot, orientation='v', resizable='v', width=30, padding=20) self.colorbar.padding_top = self.tplot.padding_top self.colorbar.padding_bottom = self.tplot.padding_bottom # create a range selection for the colorbar self.range_selection = RangeSelection(component=self.colorbar) self.colorbar.tools.append(self.range_selection) self.colorbar.overlays.append( RangeSelectionOverlay(component=self.colorbar, border_color="white", alpha=0.8, fill_color="lightgray")) # we also want to the range selection to inform the cmap plot of # the selection, so set that up as well self.range_selection.listeners.append(self.my_plot) # Create a container to position the plot and the colorbar side-by-side container = HPlotContainer(use_backbuffer=True) container.add(self.tplot) container.add(self.colorbar) container.bgcolor = "white" return container
def create_timechart_container(project): """ create a vplotcontainer which connects all the inside plots to synchronize their index_range """ # find index limits low = 1 << 64 high = 0 for i in range(len(project.c_states)): if len(project.c_states[i].start_ts): low = min(low, project.c_states[i].start_ts[0]) high = max(high, project.c_states[i].end_ts[-1]) if len(project.p_states[i].start_ts): low = min(low, project.p_states[i].start_ts[0]) high = max(high, project.p_states[i].start_ts[-1]) for tc in project.processes: if len(tc.start_ts): low = min(low, tc.start_ts[0]) high = max(high, tc.end_ts[-1]) project.process_stats(low, high) if low > high: low = 0 high = 1 # we have the same x_mapper/range for each plots index_range = DataRange1D(low=low, high=high) index_mapper = LinearMapper(range=index_range, domain_limit=(low, high)) value_range = DataRange1D(low=0, high=project.num_cpu * 2 + project.num_process) value_mapper = LinearMapper(range=value_range, domain_limit=(0, project.num_cpu * 2 + project.num_process)) index = ArrayDataSource(array((low, high)), sort_order="ascending") plot = tcPlot(index=index, proj=project, bgcolor="white", padding=(0, 0, 0, 40), use_backbuffer=True, fill_padding=True, value_mapper=value_mapper, index_mapper=index_mapper, line_color="black", render_style='hold', line_width=1) plot.lowest_i = low plot.highest_i = high project.on_trait_change(plot.invalidate, "plot_redraw") project.on_trait_change(plot.invalidate, "selected") max_process = 50 if value_range.high > max_process: value_range.low = value_range.high - max_process # Attach some tools plot.tools.append(tools.myPanTool(plot, drag_button='left')) zoom = tools.myZoomTool(component=plot, tool_mode="range", always_on=True, axis="index", drag_button=None, zoom_to_mouse=True, x_max_zoom_factor=float("inf"), x_min_zoom_factor=float("-inf")) plot.tools.append(zoom) plot.range_selection = tools.myRangeSelection(plot, resize_margin=3) plot.tools.append(plot.range_selection) plot.overlays.append( RangeSelectionOverlay(component=plot, axis="index", use_backbuffer=True)) axe = PlotAxis(orientation='bottom', title='time', mapper=index_mapper, component=plot) plot.underlays.append(axe) plot.options.connect(plot) plot.range_tools.connect(plot) return plot
def __init__(self, **kwtraits): super(ResultExplorer, self).__init__(**kwtraits) # containers bgcolor = "sys_window" #(212/255.,208/255.,200/255.) # Windows standard background self.plot_container = container = VPlotContainer(use_backbuffer=True, padding=0, fill_padding=False, valign="center", bgcolor=bgcolor) subcontainer = HPlotContainer(use_backbuffer=True, padding=0, fill_padding=False, halign="center", bgcolor=bgcolor) # freqs self.synth = FreqSelector(parent=self) # data source self.plot_data = pd = ArrayPlotData() self.set_result_data() self.set_pict() # map plot self.map_plot = Plot(pd, padding=40) self.map_plot.img_plot("image", name="image") imgp = self.map_plot.img_plot("map_data", name="map", colormap=jet)[0] self.imgp = imgp t1 = self.map_plot.plot(("xpoly", "ypoly"), name="sector", type="polygon") t1[0].face_color = (0, 0, 0, 0) # set face color to transparent # map plot tools and overlays imgtool = ImageInspectorTool(imgp) imgp.tools.append(imgtool) overlay = ImageInspectorOverlay(component=imgp, image_inspector=imgtool, bgcolor="white", border_visible=True) self.map_plot.overlays.append(overlay) self.zoom = RectZoomSelect(self.map_plot, drag_button='right', always_on=True, tool_mode='box') self.map_plot.overlays.append(self.zoom) self.map_plot.tools.append(PanTool(self.map_plot)) # colorbar colormap = imgp.color_mapper self.drange = colormap.range self.drange.low_setting = "track" self.colorbar = cb = ColorBar( index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=self.map_plot, orientation='v', resizable='v', width=10, padding=20) # colorbar tools and overlays range_selection = RangeSelection(component=cb) cb.tools.append(range_selection) cb.overlays.append( RangeSelectionOverlay(component=cb, border_color="white", alpha=0.8, fill_color=bgcolor)) range_selection.listeners.append(imgp) # spectrum plot self.spec_plot = Plot(pd, padding=25) px = self.spec_plot.plot(("freqs", "spectrum"), name="spectrum", index_scale="log")[0] self.yrange = self.spec_plot.value_range px.index_mapper = MyLogMapper(range=self.spec_plot.index_range) # spectrum plot tools self.cursor = CursorTool( px) #, drag_button="left", color='blue', show_value_line=False) px.overlays.append(self.cursor) self.cursor.current_position = 0.3, 0.5 px.index_mapper.map_screen(0.5) # self.map_plot.tools.append(SaveTool(self.map_plot, filename='pic.png')) # layout self.set_map_details() self.reset_sector() subcontainer.add(self.map_plot) subcontainer.add(self.colorbar) # subcontainer.tools.append(SaveTool(subcontainer, filename='pic.png')) container.add(self.spec_plot) container.add(subcontainer) container.tools.append(SaveTool(container, filename='pic.pdf')) self.last_valid_digest = self.Beamformer.ext_digest