def test_basics(self): container = OverlayPlotContainer(resizable='', bounds=[100.0, 200.0]) self.assert_tuple(container.get_preferred_size(), (100.0, 200.0)) self.assertEqual(container._layout_needed, True) container.do_layout() self.assertEqual(container._layout_needed, False) return
def __init__(self): super(StackedPlot, self).__init__() self.container = OverlayPlotContainer(bgcolor='white', use_backbuffer=True, border_visible=True, padding=50, padding_left=110, fill_padding=True ) self.data = ArrayPlotData() self.chaco_plot = None self.value_mapper = None self.index_mapper = None self.x_axis = PlotAxis(component=self.container, orientation='bottom', title=u'Angle (2\u0398)', title_font=settings.axis_title_font, tick_label_font=settings.tick_font) y_axis_title = 'Normalized intensity (%s)' % get_value_scale_label('linear') self.y_axis = PlotAxis(component=self.container, orientation='left', title=y_axis_title, title_font=settings.axis_title_font, tick_label_font=settings.tick_font) self.container.overlays.extend([self.x_axis, self.y_axis]) self.container.tools.append( TraitsTool(self.container, classes=[LinePlot,PlotAxis])) self.colors = [] self.last_flip_order = self.flip_order
def _plot_default(self): # Create starting points for the vectors. numpts = self.numpts x = sort(random(numpts)) y = random(numpts) # Create vectors. vectorlen = self.vectorlen vectors = array( (random(numpts) * vectorlen, random(numpts) * vectorlen)).T data = ArrayPlotData() data.set_data('index', x) data.set_data('value', y) data.set_data('vectors', vectors) quiverplot = Plot(data) quiverplot.quiverplot(('index', 'value', 'vectors')) # Attach some tools to the plot quiverplot.tools.append(PanTool(quiverplot, constrain_key="shift")) zoom = ZoomTool(quiverplot) quiverplot.overlays.append(zoom) container = OverlayPlotContainer(quiverplot, padding=50) return container
def _create_plot_component(): # Create some data numpts = 400 x = sort(random(numpts)) y = random(numpts) xs = ArrayDataSource(x, sort_order='ascending') ys = ArrayDataSource(y) vectorlen = 15 vectors = array((random(numpts) * vectorlen, random(numpts) * vectorlen)).T vector_ds = MultiArrayDataSource(vectors) xrange = DataRange1D() xrange.add(xs) yrange = DataRange1D() yrange.add(ys) quiverplot = QuiverPlot(index=xs, value=ys, vectors=vector_ds, index_mapper=LinearMapper(range=xrange), value_mapper=LinearMapper(range=yrange), bgcolor="white") add_default_axes(quiverplot) add_default_grids(quiverplot) # Attach some tools to the plot quiverplot.tools.append(PanTool(quiverplot, constrain_key="shift")) zoom = ZoomTool(quiverplot) quiverplot.overlays.append(zoom) container = OverlayPlotContainer(quiverplot, padding=50) return container
def init(self, parent): factory = self.factory container = OverlayPlotContainer(bgcolor='transparent', padding=0, spacing=0) window = Window(parent, component=container) interval = self.high - self.low data = ([self.low, self.high], [0.5]*2) plot = create_line_plot(data, color='black', bgcolor="sys_window") plot.x_mapper.range.low = self.low - interval*0.1 plot.x_mapper.range.high = self.high + interval*0.1 plot.y_mapper.range.high = 1.0 plot.y_mapper.range.low = 0.0 range_selection = RangeSelection(plot, left_button_selects=True) # Do not allow the user to reset the range range_selection.event_state = "selected" range_selection.deselect = lambda x: None range_selection.on_trait_change(self.update_interval, 'selection') plot.tools.append(range_selection) plot.overlays.append(RangeKnobsOverlay(plot)) self.plot = plot container.add(self.plot) # To set the low and high, we're actually going to set the # 'selection' metadata on the line plot to the tuple (low,high). plot.index.metadata["selections"] = (0, 1.0) # Tell the editor what to display self.control = window.control self.control.SetSize((factory.width, factory.height))
def _plot_default(self): # Create data x = linspace(-5, 15.0, 100) y = jn(3, x) pd = ArrayPlotData(index=x, value=y) zoomable_plot = Plot(pd) zoomable_plot.plot(('index', 'value'), name='external', color='red', line_width=3) # Attach tools to the plot zoom = ZoomTool(component=zoomable_plot, tool_mode="box", always_on=False) zoomable_plot.overlays.append(zoom) zoomable_plot.tools.append(PanTool(zoomable_plot)) # Create a second inset plot, not resizable, not zoom-able inset_plot = Plot(pd) inset_plot.plot(('index', 'value'), color='blue') inset_plot.set(resizable='', bounds=[250, 150], position=[450, 350], border_visible=True) # Create a container and add our plots container = OverlayPlotContainer() container.add(zoomable_plot) container.add(inset_plot) return container
def _create_plot_component(): # Create some x-y data series to plot plot_area = OverlayPlotContainer(border_visible=True) container = HPlotContainer(padding=50, bgcolor="transparent") #container.spacing = 15 x = linspace(-2.0, 10.0, 100) for i in range(5): color = tuple(COLOR_PALETTE[i]) y = jn(i, x) renderer = create_line_plot((x, y), color=color) plot_area.add(renderer) #plot_area.padding_left = 20 axis = PlotAxis( orientation="left", resizable="v", mapper=renderer.y_mapper, axis_line_color=color, tick_color=color, tick_label_color=color, title_color=color, bgcolor="transparent", title="jn_%d" % i, border_visible=True, ) axis.bounds = [60, 0] axis.padding_left = 10 axis.padding_right = 10 container.add(axis) if i == 4: # Use the last plot's X mapper to create an X axis and a # vertical grid x_axis = PlotAxis(orientation="bottom", component=renderer, mapper=renderer.x_mapper) renderer.overlays.append(x_axis) grid = PlotGrid(mapper=renderer.x_mapper, orientation="vertical", line_color="lightgray", line_style="dot") renderer.underlays.append(grid) # Add the plot_area to the horizontal container container.add(plot_area) # Attach some tools to the plot broadcaster = BroadcasterTool() for plot in plot_area.components: broadcaster.tools.append(PanTool(plot)) # Attach the broadcaster to one of the plots. The choice of which # plot doesn't really matter, as long as one of them has a reference # to the tool and will hand events to it. plot.tools.append(broadcaster) return container
def _plot_default(self): container = OverlayPlotContainer(bgcolor="white") plots = self._make_curves() for plot in plots: plot.padding = 60 container.add(plot) bottom_axis = PlotAxis(plot, orientation='bottom') label_list = [ 'var a', 'var b', 'var c', 'var d', 'var e', 'var f', 'var g', 'var h', 'var i' ] vertical_axis = LabelAxis(plot, orientation='left', title='Categories', positions=list(range(1, 10)), labels=label_list) vertical2_axis = LabelAxis(plot, orientation='right', positions=list(range(1, 10)), labels=label_list) plot.underlays.append(vertical_axis) plot.underlays.append(vertical2_axis) plot.underlays.append(bottom_axis) return container
def setUp(self): if 'OUTPUT_TESTS' not in os.environ: raise SkipTest('Slow: define OUTPUT_TESTS to run') self.data = xye.XYEDataset.from_file( r'tests/testdata/si640c_low_temp_cal_p1_scan0.000000_adv0_0000.xye' ) class UI(object): color = None name = '' active = True markers = False self.data.metadata['ui'] = UI() self.datasets = [self.data] self.plot = RawDataPlot(self.datasets) self.plot.plot_datasets(self.datasets, scale='log') self.container = OverlayPlotContainer(self.plot.get_plot(), bgcolor="white", use_backbuffer=True, border_visible=False) self.container.request_redraw() self.basedir = os.path.join('tests', 'tmp') try: os.mkdir(self.basedir) except OSError, e: assert 'exists' in str(e)
def test_resizable_component(self): container = OverlayPlotContainer(resizable='', bounds=[200.0, 300.0]) component = PlotComponent(resizable='hv', position=[50.0, 56.0], bounds=[100.0, 110.0]) container.add(component) container.do_layout() self.assert_tuple(component.position, (0.0, 0.0)) self.assert_tuple(component.bounds, (200.0, 300.0)) comp2 = PlotComponent(resizable="h", position=[10, 20], bounds=[100, 150]) container.add(comp2) container.do_layout() self.assert_tuple(comp2.position, (0.0, 20.0)) self.assert_tuple(comp2.bounds, (200.0, 150.0)) comp3 = PlotComponent(resizable="v", position=[30, 40], bounds=[100, 150]) container.add(comp3) container.do_layout() self.assert_tuple(comp3.position, (30.0, 0.0)) self.assert_tuple(comp3.bounds, (100, 300)) return
def _create_window(self): numpoints = 50 low = -5 high = 15.0 x = arange(low, high, (high - low) / numpoints) container = OverlayPlotContainer(bgcolor="lightgray") common_index = None index_range = None value_range = None self.animated_plots = [] for i, color in enumerate(COLOR_PALETTE): if not common_index: animated_plot = AnimatedPlot(x, jn(i, x), color) common_index = animated_plot.plot.index index_range = animated_plot.plot.index_mapper.range value_range = animated_plot.plot.value_mapper.range else: animated_plot = AnimatedPlot(common_index, jn(i, x), color) animated_plot.plot.index_mapper.range = index_range animated_plot.plot.value_mapper.range = value_range container.add(animated_plot.plot) self.animated_plots.append(animated_plot) for i, a_plot in enumerate(self.animated_plots): a_plot.plot.position = [ 50 + (i % 3) * (PLOT_SIZE + 50), 50 + (i // 3) * (PLOT_SIZE + 50) ] self.timer = Timer(100.0, self.onTimer) self.container = container return Window(self, -1, component=container)
def get_line_plot(self, array_plot_data, title=''): plot = self._render_line_plot(array_plot_data) # container isn't necessary here, but we do it to keep it consistent # with how the other plot types return data. plot_container = OverlayPlotContainer(plot) self._base_plot = plot self.plot_container = plot_container return plot_container
def __init__(self): self.selection_handler = SelectionHandler() self.container = OverlayPlotContainer() self.underlays = [] self.add_pan_tool = False self.add_zoom_tool = False self.add_dragzoom = False self.show_grid = False
def test_min_size(self): container = OverlayPlotContainer(resizable='', bounds=[50.0, 50.0]) component = PlotComponent(resizable='', position=[50.0, 60.0], bounds=[100.0, 110.0]) container.add(component) container.do_layout() self.assert_tuple(component.position, (50.0, 60.0)) self.assert_tuple(component.bounds, (100.0, 110.0)) return
def _create_plot_component(): container = OverlayPlotContainer(padding=50, fill_padding=True, bgcolor="lightgray", use_backbuffer=True) # Create the initial X-series of data numpoints = 30 low = -5 high = 15.0 x = linspace(low, high, numpoints) y = jn(0, x) lineplot = create_line_plot((x, y), color=tuple(COLOR_PALETTE[0]), width=2.0) lineplot.selected_color = "none" scatter = ScatterPlot(index=lineplot.index, value=lineplot.value, index_mapper=lineplot.index_mapper, value_mapper=lineplot.value_mapper, color=tuple(COLOR_PALETTE[0]), marker_size=5) scatter.index.sort_order = "ascending" scatter.bgcolor = "white" scatter.border_visible = True add_default_grids(scatter) add_default_axes(scatter) scatter.tools.append(PanTool(scatter, drag_button="right")) # The ZoomTool tool is stateful and allows drawing a zoom # box to select a zoom region. zoom = ZoomTool(scatter, tool_mode="box", always_on=False, drag_button=None) scatter.overlays.append(zoom) scatter.tools.append(PointDraggingTool(scatter)) container.add(lineplot) container.add(scatter) # Add the title at the top container.overlays.append( PlotLabel("Line Editor", component=container, font="swiss 16", overlay_position="top")) return container
def _plot_default(self): container = OverlayPlotContainer(padding = 50, fill_padding = True, bgcolor = "lightgray", use_backbuffer=True) # Create the initial X-series of data numpoints = self.numpoints low = self.low high = self.high x = arange(low, high+0.001, (high-low)/numpoints) y = jn(0, x) plot = create_line_plot((x,y), color=tuple(COLOR_PALETTE[0]), width=2.0) plot.index.sort_order = "ascending" plot.bgcolor = "white" plot.border_visible = True add_default_grids(plot) add_default_axes(plot) # Add some tools plot.tools.append(PanTool(plot)) zoom = ZoomTool(plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) # Add a dynamic label. This can be dragged and moved around using the # right mouse button. Note the use of padding to offset the label # from its data point. label = DataLabel(component=plot, data_point=(x[40], y[40]), label_position="top left", padding=40, bgcolor = "lightgray", border_visible=False) plot.overlays.append(label) tool = DataLabelTool(label, drag_button="right", auto_arrow_root=True) label.tools.append(tool) # Add some static labels. label2 = DataLabel(component=plot, data_point=(x[20], y[20]), label_position="bottom right", border_visible=False, bgcolor="transparent", marker_color="blue", marker_line_color="transparent", marker = "diamond", arrow_visible=False) plot.overlays.append(label2) label3 = DataLabel(component=plot, data_point=(x[80], y[80]), label_position="top", padding_bottom=20, marker_color="transparent", marker_size=8, marker="circle", arrow_visible=False) plot.overlays.append(label3) container.add(plot) return container
def gen_line_plot(series_one, series_two, y_axis_name=''): """ Parameters ---------- series_one : nd array series_two : nd array """ size = min(series_one.shape[0], series_two.shape[0]) idx = ArrayDataSource(arange(size)) series_one_data = ArrayDataSource(series_one[:size]) series_two_data = ArrayDataSource(series_two[:size]) y_range = DataRange1D(series_one_data) y_range.tight_bounds = False y_range.margin = 50 x_mapper = LinearMapper(range=DataRange1D(idx)) y_mapper = LinearMapper(range=y_range) series_one_plot = LinePlot(index=idx, value=series_one_data, index_mapper=x_mapper, value_mapper=y_mapper, color='blue') series_two_plot = LinePlot(index=idx, value=series_two_data, index_mapper=x_mapper, value_mapper=y_mapper, color='red') container = OverlayPlotContainer(bgcolor='white', padding=25, fill_padding=False, border_visible=True) y_axis = PlotAxis(mapper=y_mapper, component=container, orientation='left') x_axis = PlotAxis(mapper=x_mapper, component=container, orientation='bottom') x_axis.title = 'Time' y_axis.title = y_axis_name legend = Legend(component=container, padding=10, align='ur') legend.plots = { 'Predicted': series_one_plot, 'Actual': series_two_plot, } container.add(series_one_plot) container.add(series_two_plot) container.overlays.append(y_axis) container.overlays.append(legend) return container
def main(): # Create some x-y data series to plot x = linspace(-2.0, 10.0, 100) pd = ArrayPlotData(index=x) for i in range(5): pd.set_data("y" + str(i), jn(i, x)) # 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", "y0", "y1", "y2"), name="j_n, n<3", color="auto") plot.plot(("index", "y3"), name="j_3", color="auto") plot.tools.append(PanTool(plot)) zoom = ZoomTool(component=plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) # Create the mlab test mesh and get references to various parts of the # VTK pipeline f = mlab.figure(size=(600, 500)) m = mlab.test_mesh() scene = mlab.gcf().scene render_window = scene.render_window renderer = scene.renderer rwi = scene.interactor plot.resizable = "" plot.bounds = [200, 200] plot.padding = 25 plot.bgcolor = "lightgray" 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.InteractorStyleSwitch, #istyle_class = tvtk.InteractorStyle, istyle_class=tvtk.InteractorStyleTrackballCamera, bgcolor="transparent", event_passthrough=True, ) mlab.show() return window, render_window
def test_multiple_min_size(self): comp1 = StaticPlotComponent([200, 50]) comp2 = StaticPlotComponent([60, 300]) container = OverlayPlotContainer(resizable='hv', bounds=[30, 30]) container.fit_components = "hv" container.add(comp1, comp2) container.do_layout() self.assert_tuple(container.get_preferred_size(), (200, 300)) self.assert_tuple(comp1.bounds, (200, 50)) self.assert_tuple(comp2.bounds, (60, 300)) return
def _create_component(self): rect1 = Region("orchid", position=[50, 50]) rect2 = Region("cornflowerblue", position=[200, 50]) rect1.overlays.append(Overlay("One", component=rect1)) rect2.overlays.append(Overlay("Two", component=rect2)) container1 = OverlayPlotContainer(bounds=[400, 400], resizable="") container1.add(rect1, rect2) container1.bgcolor = (0.60, 0.98, 0.60, 0.5) # "palegreen" rect3 = Region("purple", position=[50, 50]) rect4 = Region("teal", position=[200, 50]) rect3.overlays.append(Overlay("Three", component=rect3)) rect4.overlays.append(Overlay("Four", component=rect4)) container2 = OverlayPlotContainer(bounds=[400, 400], resizable="") container2.add(rect3, rect4) container2.bgcolor = "navajowhite" container2.position = [200, 200] top_container = OverlayPlotContainer() top_container.add(container1, container2) return top_container
def _plot_container_default(self): container = OverlayPlotContainer(padding=50, fill_padding=False, bgcolor="white", use_backbuffer=True) return container #--------------------------------------------------------------------- # Finishes initializing the editor by creating the underlying toolkit # widget: #--------------------------------------------------------------------- """ Finishes initializing the editor by creating the
def __init__(self, link): super(TrackingView, self).__init__() self.link = link self.link.add_callback(MSG_TRACKING_SNRS, self.tracking_snrs_callback) # ======= Line Plot ======= self.plot_data = ArrayPlotData(t=[0.0]) self.plot = Plot(self.plot_data, auto_colors=colours_list) self.plot.value_range.tight_bounds = False self.plot.value_range.low_setting = 0.0 for n in range(TRACK_N_CHANNELS): self.plot_data.set_data('ch'+str(n), [0.0]) self.plot.plot(('t', 'ch'+str(n)), type='line', color='auto') # ======= Bar Plot ======= idxs = ArrayDataSource(range(1, len(self.snrs)+1)) self.vals = ArrayDataSource(self.snrs, sort_order='none') # Create the index range index_range = DataRange1D(idxs, low=0.4, high=TRACK_N_CHANNELS+0.6) index_mapper = LinearMapper(range=index_range) # Create the value range value_range = DataRange1D(low=0.0, high=25.0) value_mapper = LinearMapper(range=value_range) plot = BarPlot(index=idxs, value=self.vals, index_mapper=index_mapper, value_mapper=value_mapper, line_color='blue', fill_color='blue', bar_width=0.8) container = OverlayPlotContainer(bgcolor = "white") plot.padding = 10 plot.padding_left = 30 plot.padding_bottom = 30 container.add(plot) left_axis = PlotAxis(plot, orientation='left') bottom_axis = LabelAxis(plot, orientation='bottom', labels = map(str, range(1, TRACK_N_CHANNELS+1)), positions = range(1, TRACK_N_CHANNELS+1), small_haxis_style=True) plot.underlays.append(left_axis) plot.underlays.append(bottom_axis) self.snr_bars = container self.python_console_cmds = { 'track': self }
def _create_plot_component_overlay(signals, use_downsampling=False): container = OverlayPlotContainer(padding=40, bgcolor="lightgray", use_backbuffer=True, border_visible=True, fill_padding=True) nSignal, nSample = np.shape(signals) time = arange(nSample) value_mapper = None index_mapper = None plots = {} for i in range(nSignal): plot = create_line_plot( (time, signals[i]), color=tuple(COLOR_PALETTE[i % len(COLOR_PALETTE)]), 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" plots["Corr fun %d" % i] = plot container.add(plot) # Add a legend in the upper right corner, and make it relocatable # legend = Legend(component=plot, padding=10, align="ur") # legend.tools.append(LegendTool(legend, drag_button="right")) # plot.overlays.append(legend) # legend.plots = plots # 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 get_scatter_quiver_plot(self, array_plot_data, title='', tools=[]): colorbar = None image_plot, csr = _render_image(array_plot_data, title) scatter_plot, colorbar = _render_scatter_overlay(image_plot, array_plot_data, tools=tools) quiver_plot = _render_quiver_overlay(image_plot, array_plot_data) image_container = OverlayPlotContainer(image_plot, scatter_plot, quiver_plot, ) if colorbar is not None: image_container = HPlotContainer(image_container, colorbar) self._base_plot = image_plot self._scatter_plot = scatter_plot self._quiver_plot = quiver_plot self.image_container = image_container return image_container
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 main(): from tvtk.api import tvtk from mayavi import mlab from enable.vtk_backend.vtk_window import EnableVTKWindow f = mlab.figure(size=(900, 850)) m = mlab.test_mesh() scene = mlab.gcf().scene render_window = scene.render_window renderer = scene.renderer rwi = scene.interactor # Create the plot timer_controller = TimerController() plots = create_plot_component(timer_controller) specplot, timeplot, spectrogram = plots for i, p in enumerate(plots): p.resizable = "" p.bgcolor = "transparent" p.bounds = [200, 200] p.outer_x = 0 p.outer_y = i * 250 p.tools.append(MoveTool(p, drag_button="right")) p.tools.append(PanTool(p)) p.tools.append(ZoomTool(p)) spectrogram.tools[-1].tool_mode = "range" spectrogram.tools[-1].axis = "value" spectrogram.tools[-2].constrain = True spectrogram.tools[-2].constrain_direction = "y" container = OverlayPlotContainer(bgcolor="transparent", fit_window=True) container.add(*plots) container.timer_callback = timer_controller.on_timer window = EnableVTKWindow( rwi, renderer, component=container, istyle_class=tvtk.InteractorStyleTrackballCamera, bgcolor="transparent", event_passthrough=True, ) mlab.show()
def test_fixed_size_component(self): container = OverlayPlotContainer(resizable='', bounds=[200.0, 300.0]) # non-resizable component component = PlotComponent(resizable='', position=[50.0, 60.0], bounds=[100.0, 110.0]) self.assertEqual(container._layout_needed, True) container.do_layout() container.add(component) self.assertEqual(container._layout_needed, True) container.do_layout() self.assertEqual(container._layout_needed, False) # check the results of the layout self.assert_tuple(container.get_preferred_size(), (200.0, 300.0)) self.assert_tuple(component.position, (50.0, 60.0)) self.assert_tuple(component.bounds, (100.0, 110.0)) return
def main(): plot = create_plot() plot.bounds = [400, 300] plot.outer_position = [30, 30] plot.resizable = "" cmap_renderer = plot.plots["my_plot"][0] # Create the colorbar, handing in the appropriate range and colormap colorbar = create_colorbar(plot.color_mapper) colorbar.outer_position = [450, 30] colorbar.plot = cmap_renderer colorbar.padding_top = plot.padding_top colorbar.padding_bottom = plot.padding_bottom container = OverlayPlotContainer(bgcolor="transparent", fit_window=True) container.add(plot) container.add(colorbar) start_vtk(container)
def init(self, parent): """ Finishes initializing the editor by creating the underlying toolkit widget. """ factory = self.factory plotitem = factory.plotitem container = OverlayPlotContainer(use_backbuffer=True) self._container = container window = Window(parent, component=container) self.control = control = window.control # new lines for Toolbar # panel = traits_ui_panel( parent, -1 ) ## # super(MFnPolarPlotEditor,self).init(panel) ## # plot_control = self.control ## self.control = panel ## # sizer = wx.BoxSizer( wx.HORIZONTAL) #VERTICAL ) # self._create_toolbar( panel, sizer ) ## # sizer.Add( plot_control, 1, wx.ALIGN_RIGHT | wx.EXPAND ) ## # panel.SetSizer( sizer ) #################################### control.SetSize((factory.width, factory.height)) object = self.object # Attach listeners to the object's traits appropriately so we can # update the plot when they change. For the _update_axis_grids() # callback, we have to wrap it in a lambda to keep traits from # inferring the calling convention based on introspecting the argument # list. for name in [plotitem.index] + plotitem.value_list: print("setting on trait change for ", name) object.on_trait_change(self._update_data, name) object.on_trait_change(self.update_editor, plotitem.type_trait) return
class PCPlotHandler(HasTraits): ''' Class for handling principal component plots. ''' # The container for the plot. container = OverlayPlotContainer() # the sklearn.decmoposition.PCA object pca = PCA # Whether or not to normalize the data, one of the parameters of the PCA # object whiten = Bool # The input data. table = Array # The selection_handler instance for the tableview selection_handler = Instance(SelectionHandler) def __init__(self): self.pca = PCA(n_components=2) self.pca.whiten = True self.container = OverlayPlotContainer() self.selection_handler = SelectionHandler() def draw_pc_plot(self): ''' Called to draw the PCA plot. ''' self.selection_handler.create_selection() if len(self.selection_handler.selected_indices) == 1: top_left = self.selection_handler.selected_indices[0][0:2] bot_right = self.selection_handler.selected_indices[0][2:4] data = self.table[top_left[0]:bot_right[0], top_left[1]:bot_right[1]] pc_red = self.pca.fit_transform(data) plotdata = ArrayPlotData(x=pc_red[:, 0], y=pc_red[:, 1]) plot = Plot(plotdata) plot.plot(("x", "y"), type='scatter') self.container.add(plot) self.container.request_redraw()