def _create_plot_component(): # Create a GridContainer to hold all of our plots: 2 rows, 3 columns: container = GridContainer(padding=40, fill_padding=True, bgcolor="lightgray", use_backbuffer=True, shape=(2, 3), spacing=(20, 20)) # Create the initial series of data x = linspace(-5, 15.0, 100) pd = ArrayPlotData(index=x) # Plot some bessel functions and add the plots to our container for i in range(6): pd.set_data("y" + str(i), jn(i, x)) plot = Plot(pd) plot.plot(("index", "y" + str(i)), color=tuple(COLOR_PALETTE[i]), line_width=2.0, bgcolor="white", border_visible=True) # Tweak some of the plot properties plot.border_width = 1 plot.padding = 0 plot.padding_top = 30 # Attach some tools to the plot plot.tools.append(PanTool(plot)) zoom = ZoomTool(plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) # Add to the grid container ( container.add(plot) # Set the upper-left plot to only be resizable vertically, and to have a # fixed horizontal width. This also constrains the width of the first column. ul_plot = container.components[0] ul_plot.set(resizable="v", width=200) ul_plot.overlays.append( PlotLabel("Not horizontally resizable", component=ul_plot)) # Set the bottom center plot to have a fixed width and height. # This also constrains the height of the bottom row and the width of # the middle column. cplot = container.components[4] cplot.set(resizable="", bounds=[400, 400]) cplot.overlays.append(PlotLabel("Not resizable", component=cplot)) container.padding_top = 50 container.overlays.append( PlotLabel( 'Resize the window - some plots resize, others cannot ' '(see source code)', component=container, font="swiss 16", overlay_position="top")) return container
def _create_spin_noise_plot(self): plot_data_spin_noise = ArrayPlotData(value=np.array((0., 1.)), time=np.array((0., 0.)), fit=np.array((0., 0.)), peak_free=np.array((0., 0.)), f=np.array((0., 0.)), fit_x=np.array((0., 0.))) plot = Plot(plot_data_spin_noise, width=50, height=40, padding=8, padding_left=64, padding_bottom=32) plot.plot(('time', 'value'), color='red', line_width=2, type='scatter') #, index_scale = 'log', value_scale = 'log') plot.index_axis.title = 'frequency [MHz]' plot.value_axis.title = 'noise spectrum [nT^2/Hz]' #plot.title='noise spectrum' line_label = PlotLabel(text='', hjustify='left', vjustify='top', position=[50, 100]) plot.overlays.append(line_label) self.line_label = line_label self.plot_data_spin_noise = plot_data_spin_noise self.spin_noise_plot = plot return self.spin_noise_plot
def _fit_changed(self, name, old, new): old.measurement = None new.measurement = self.measurement plot = self.line_plot plot2 = self.processed_plot # delete all old plots for key in plot.plots.keys()[0:1]: plot.delplot(key) for key in plot2.plots.keys()[1:]: plot2.delplot(key) # set new data source plot.data = self.fit.line_data plot2.data = self.fit.processed_plot_data # make new plots for item in self.fit.plots[0:1]: plot.plot(**item) for item in self.fit.plots[1:]: plot2.plot(**item) #if hasattr(self.fit,'legends'): #plot.legend(**self.fit.legends) # if the fit has an attr 'text' attached to it, print it in the lower left corner of the plot if hasattr(old, 'text'): label = plot.overlays[0] old.sync_trait('text', label, 'text', mutual=False, remove=True) plot.overlays = [] if hasattr(new, 'text'): label = PlotLabel(text=self.fit.text, hjustify='left', vjustify='bottom', position=[64, 32]) new.sync_trait('text', label, 'text', mutual=False) plot.overlays = [label]
def _create_plot(self): plot_data = ArrayPlotData(image=self.image) plot = Plot(plot_data, width=500, height=500, resizable='hv', aspect_ratio=1.0, padding=8, padding_left=32, padding_bottom=32) plot.img_plot('image', colormap=RdBu_r, xbounds=(self.X[0],self.X[-1]), ybounds=(self.Y[0],self.Y[-1]), name='image') image = plot.plots['image'][0] image.x_mapper.domain_limits = (self.imager.get_x_range()[0],self.imager.get_x_range()[1]) image.y_mapper.domain_limits = (self.imager.get_y_range()[0],self.imager.get_y_range()[1]) zoom = AspectZoomTool(image, enable_wheel=False) cursor = CursorTool2D(image, drag_button='left', color='yellow', marker_size=1.0, line_width=1.0 ) image.overlays.append(cursor) image.overlays.append(zoom) colormap = image.color_mapper colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=plot, orientation='v', resizable='v', width=16, height=320, padding=8, padding_left=32) container = HPlotContainer() container.add(plot) container.add(colorbar) z_label = PlotLabel(text='z=0.0', color='red', hjustify='left', vjustify='bottom', position=[10,10]) container.overlays.append(z_label) container.tools.append(SaveTool(container)) self.plot_data = plot_data self.scan_plot = image self.cursor = cursor self.zoom = zoom self.figure = plot self.figure_container = container self.sync_trait('z_label_text', z_label, 'text')
def _set_title_label(self, plot): font_size = self.plot_style.title_style.font_size font_name = self.plot_style.title_style.font_name font = '{} {}'.format(font_name, font_size) title_label = PlotLabel(self.plot_title, component=plot, font=font, overlay_position="top") plot.overlays.append(title_label) plot.title = title_label
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 _create_plot_component_vertical(signals=Array, use_downsampling=False): # container = HPlotContainer(resizable = "hv", bgcolor="lightgray", # fill_padding=True, padding = 10) container = VPlotContainer(resizable="hv", bgcolor="lightgray", fill_padding=True, padding=50) nSignal, nSample = np.shape(signals) time = arange(nSample) value_range = None plots = {} for i in range(nSignal): plot = create_line_plot( (time, signals[i]), color=tuple(COLOR_PALETTE[i % len(COLOR_PALETTE)]), width=1.0, # orientation="v") orientation="h") plot.origin_axis_visible = True # plot.origin = "top left" plot.padding_left = 10 plot.padding_right = 10 plot.border_visible = False plot.bgcolor = "white" if value_range is None: value_range = plot.value_mapper.range else: plot.value_range = value_range value_range.add(plot.value) container.add(plot) plots["Corr fun %d" % i] = 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 # container.padding_top = 50 container.overlays.append( PlotLabel("Correlation function", component=container, font="swiss 16", overlay_position="top")) # 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 _create_line_plot(self): line_data = ArrayPlotData(frequency=np.array((0.,1.)), counts=np.array((0.,0.)), fit=np.array((0.,0.))) line_plot = Plot(line_data, padding=8, padding_left=64, padding_bottom=32) line_plot.plot(('frequency','counts'), style='line', color='blue') line_plot.index_axis.title = 'Frequency [MHz]' line_plot.value_axis.title = 'Fluorescence counts' line_label = PlotLabel(text='', hjustify='left', vjustify='bottom', position=[64,128]) line_plot.overlays.append(line_label) self.line_label = line_label self.line_data = line_data self.line_plot = line_plot
def _add_avg_std_err(self, text): info_label = PlotLabel( text=text, component=self, overlay_position='outside bottom', border_visible=False, border_width=2, margin=6, fill_padding=False, hjustify='center', ) self.overlays.append(info_label)
def _create_second_method_plot(self): plot_data_second_method = ArrayPlotData(value=np.array((0., 1.)), time=np.array((0., 0.)), fit=np.array((0., 0.)) ) plot = Plot(plot_data_second_method, width=50, height=40, padding=8, padding_left=64, padding_bottom=32) plot.plot(('time', 'value'), color='green', line_width = 2) plot.index_axis.title = 'time [ns]' plot.value_axis.title = 'Normalized Contrast' #plot.title='noise spectrum' line_label = PlotLabel(text='', hjustify='left', vjustify='top', position=[64, 280]) plot.overlays.append(line_label) self.line_label = line_label self.plot_data_second_method= plot_data_second_method self.second_method_plot = plot return self.second_method_plot
def add_plot_label(self, txt, x, y, plotid=0, **kw): ''' ''' # print x, y # # x, y = .map_screen([(x, y)])[0] # x, y = self.plots[plotid].map_screen([(x, y)])[0] # print x, y c = self.plots[plotid] pl = PlotLabel(txt, overlay_position='inside top', hjustify='left', component=c, **kw) c.overlays.append(pl) return pl
def _create_line_plot(self): line_data = ArrayPlotData(index=np.array((0, 1)), spin_state=np.array((0, 0)), fit=np.array((0, 0))) plot = Plot(line_data, padding=8, padding_left=64, padding_bottom=36) plot.plot(('index', 'spin_state'), color='blue', name='spin_state') plot.plot(('index', 'fit'), color='red', name='fit') plot.index_axis.title = 'time [micro s]' plot.value_axis.title = 'spin state' plot.overlays.insert( 0, PlotLabel(text=self.label_text, hjustify='left', vjustify='bottom', position=[64, 32])) plot.tools.append(SaveTool(plot)) self.line_data = line_data self.line_plot = plot
def __init__(self, **traits): super(CameraImage, self).__init__(**traits) self._dims = (200, 320) self.data_store = ArrayPlotData(image=self.data) self._hud = dict() self.plot = Plot(self.data_store) # Draw the image renderers = self.plot.img_plot('image', name='camera_image', colormap=fix(gray, (0, 255))) self._image = renderers[0] self.plot.aspect_ratio = float(self._dims[1]) / self._dims[0] self.hud_overlay = PlotLabel(text='', component=self.plot, hjustify='left', overlay_position='inside bottom', color='white') self.plot.overlays.append(self.hud_overlay)
def set_title(self, t, font='modern', size=None): ''' ''' self._title = t pc = self.plotcontainer if pc.overlays: pc.overlays.pop() if not font in VALID_FONTS: font = 'modern' if size is None: size = 12 self._title_font = font self._title_size = size font = '{} {}'.format(font, size) # import wx # family = wx.FONTFAMILY_MODERN # style = wx.FONTSTYLE_NORMAL # weight = wx.FONTWEIGHT_NORMAL # font = wx.Font(size, family, style, weight, False, # font) pl = PlotLabel( t, component=pc, # bgcolor='red', # draw_layer='overlay' font=font, # vjustify='bottom', # overlay_position='top' ) # print pl pc.overlays.append(pl) # print pc.components # pc.add(pl) # pc._components.insert(0, pl) # pc.invalidate_and_redraw() # pc.request_redraw() self.redraw()
def _create_plot_component(): numpoints = 100 low = -5 high = 15.0 x = arange(low, high, (high - low) / numpoints) container = container_class(resizable="hv", bgcolor="lightgray", fill_padding=True, padding=10) # Plot some bessel functions value_range = None for i in range(10): y = jn(i, x) plot = create_line_plot((x, y), color=tuple(COLOR_PALETTE[i]), width=2.0, orientation=plot_orientation) plot.origin_axis_visible = True plot.origin = "top left" plot.padding_left = 10 plot.padding_right = 10 plot.border_visible = True plot.bgcolor = "white" if value_range is None: value_range = plot.value_mapper.range else: plot.value_range = value_range value_range.add(plot.value) if i % 2 == 1: plot.line_style = "dash" container.add(plot) container.padding_top = 50 container.overlays.append( PlotLabel("Bessel Functions in a Strip Plot", component=container, font="swiss 16", overlay_position="top")) return container
def set_title(self, t, font='modern', size=None): """ """ self._title = t pc = self.plotcontainer if pc.overlays: pc.overlays.pop() if not font in VALID_FONTS: font = 'modern' if size is None: size = 12 self._title_font = font self._title_size = size font = '{} {}'.format(font, size) pl = PlotLabel(t, component=pc, font=font) pc.overlays.append(pl) self.redraw()
def _rebuild_plot(self): container = self.plot value_range = DataRange1D(low=-1, high=1.) index_range = DataRange1D(self.index_ds, high='track', tracking_amount=24 * 3600 * 365) color_mapper = cmap(range=value_range) # Remove old plots container.remove(*container.components) for val, row in zip(self.value_ds, self.rows): horizon = HorizonPlot( index=self.index_ds, value=val, index_mapper=LinearMapper(range=index_range, stretch_data=False), value_mapper=BandedMapper(range=DataRange1D(val)), color_mapper=cmap(range=DataRange1D(val)), #color_mapper, negative_bands=False, ) horizon.tools.append( PanTool(horizon, constrain=True, constrain_direction="x")) horizon.overlays.append( PlotLabel(component=horizon, hjustify='right', text=row, overlay_position='outside left')) container.add(horizon) bottom_axis = PlotAxis( horizon, orientation="bottom", tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem())) container.overlays = [bottom_axis] container.request_redraw()
def _setup_plots(self): """Creates series of Bessel function plots""" plots = {} x = arange(self.low, self.high + 0.001, (self.high - self.low) / self.numpoints) for i in range(self.num_funs): y = jn(i, x) if i % 2 == 1: plot = create_line_plot((x, y), color=tuple(COLOR_PALETTE[i]), width=2.0) else: plot = create_scatter_plot((x, y), color=tuple(COLOR_PALETTE[i])) if i == 0: value_mapper, index_mapper, legend = \ self._setup_plot_tools(plot) else: self._setup_mapper(plot, value_mapper, index_mapper) self.add(plot) plots["Bessel j_%d" % i] = plot # Set the list of plots on the legend legend.plots = plots # Add the title at the top self.overlays.append( PlotLabel("Bessel functions", component=self, font="swiss 16", overlay_position="top")) # Add the traits inspector tool to the container self.tools.append(TraitsTool(self))
def _create_plot_component(self): from numpy import abs, cumprod, random # Chaco imports from chaco.api import ArrayDataSource, BarPlot, DataRange1D, \ LinearMapper, VPlotContainer, PlotAxis, \ FilledLinePlot, add_default_grids, PlotLabel from chaco.tools.api import PanTool, ZoomTool from chaco.scales.api import CalendarScaleSystem, ScaleSystem from chaco.scales_tick_generator import ScalesTickGenerator # Create the data and datasource objects # In order for the date axis to work, the index data points need to # be in units of seconds since the epoch. This is because we are using # the CalendarScaleSystem, whose formatters interpret the numerical values # as seconds since the epoch. numpoints = self.data.size index = np.arange(self.data.size) self.xsource = ArrayDataSource(index) #vol_ds = ArrayDataSource(volume, sort_order="none") self.ysource = ArrayDataSource(self.data, sort_order="none") xmapper = LinearMapper(range=DataRange1D(self.xsource)) #vol_mapper = LinearMapper(range=DataRange1D(vol_ds)) meas_mapper = LinearMapper(range=DataRange1D(self.ysource)) price_plot = FilledLinePlot(index=self.xsource, value=self.ysource, index_mapper=xmapper, value_mapper=meas_mapper, edge_color=tuple(cbrewer[0]), face_color="paleturquoise", bgcolor="gray", border_visible=True) price_plot.overlays.append(PlotAxis(price_plot, orientation='left')), # Set the plot's bottom axis to use the Scales ticking system # bottom_axis = PlotAxis(price_plot, orientation="bottom", # mapper=xmapper, # tick_generator=ScalesTickGenerator(scale=ScaleSystem())) # price_plot.overlays.append(bottom_axis) # hgrid, vgrid = add_default_grids(price_plot) # vgrid.tick_generator = bottom_axis.tick_generator # # 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=10.0, # )) container = VPlotContainer(bgcolor="lightblue", spacing=40, padding=50, fill_padding=False) container.add(price_plot) container.overlays.append(PlotLabel(self.title, component=container, # font="Times New Roman 24")) )) return container
def _create_plot_component(): container = OverlayPlotContainer(padding=50, fill_padding=True, bgcolor="lightgray", use_backbuffer=True) # Create the initial X-series of data numpoints = 100 low = -5 high = 15.0 x = arange(low, high + 0.001, (high - low) / numpoints) # Plot some bessel functions plots = {} broadcaster = BroadcasterTool() for i in range(4): y = jn(i, x) plot = create_line_plot((x, y), color=tuple(COLOR_PALETTE[i]), width=2.0) plot.index.sort_order = "ascending" plot.bgcolor = "white" plot.border_visible = True if i == 0: add_default_grids(plot) add_default_axes(plot) # Create a pan tool and give it a reference to the plot it should # manipulate, but don't attach it to the plot. Instead, attach it to # the broadcaster. pan = PanTool(plot) broadcaster.tools.append(pan) container.add(plot) plots["Bessel j_%d" % i] = plot # Add an axis on the right-hand side that corresponds to the second plot. # Note that it uses plot.value_mapper instead of plot0.value_mapper. plot1 = plots["Bessel j_1"] axis = PlotAxis(plot1, orientation="right") plot1.underlays.append(axis) # Add the broadcast tool to the container, instead of to an # individual plot container.tools.append(broadcaster) legend = Legend(component=container, padding=10, align="ur") legend.tools.append(LegendTool(legend, drag_button="right")) container.overlays.append(legend) # Set the list of plots on the legend legend.plots = plots # Add the title at the top container.overlays.append( PlotLabel("Bessel functions", component=container, font="swiss 16", overlay_position="top")) # Add the traits inspector tool to the container container.tools.append(TraitsTool(container)) return container
def _create_plot_component(): container = OverlayPlotContainer( padding=50, fill_padding=True, bgcolor="lightgray", use_backbuffer=True) # Create the initial X-series of data numpoints = 100 low = -5 high = 15.0 x = linspace(low, high, numpoints) now = time() timex = linspace(now, now + 7 * 24 * 3600, numpoints) # Plot some bessel functions value_mapper = None index_mapper = None plots = {} for i in range(10): y = jn(i, x) if i % 2 == 1: plot = create_line_plot( (timex, y), color=tuple(COLOR_PALETTE[i]), width=2.0) plot.index.sort_order = "ascending" else: plot = create_scatter_plot( (timex, y), color=tuple(COLOR_PALETTE[i])) plot.bgcolor = "white" plot.border_visible = True if i == 0: value_mapper = plot.value_mapper index_mapper = plot.index_mapper left, bottom = add_default_axes(plot) left.tick_generator = ScalesTickGenerator() bottom.tick_generator = ScalesTickGenerator( scale=CalendarScaleSystem()) add_default_grids(plot, tick_gen=bottom.tick_generator) 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 == 0: plot.tools.append(PanTool(plot)) zoom = ZoomTool(plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) # 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) container.add(plot) plots["Bessel j_%d" % i] = plot # Set the list of plots on the legend legend.plots = plots # Add the title at the top container.overlays.append( PlotLabel( "Bessel functions", component=container, font="swiss 16", overlay_position="top")) # Add the traits inspector tool to the container container.tools.append(TraitsTool(container)) return container
def _get_plot_overlay(self): if self.data is None or len(self.data.shape) == 1: return container = OverlayPlotContainer(resizable="v", fill_padding=True, padding=30, bgcolor="transparent", use_backbuffer=True) numpoints = self.data.shape[1] if self.scale_type == 'Time': index = self._create_dates(numpoints, start=self.first_day) else: index = range(numpoints) time_ds = ArrayDataSource(index) xmapper = LinearMapper(range=DataRange1D(time_ds)) corr_mapper = None for (m, cDx) in enumerate(self.data): corr_ds = ArrayDataSource(cDx, sort_order="none") if corr_mapper is None: corr_mapper = LinearMapper(range=DataRange1D(corr_ds)) corr_plot = LinePlot( index=time_ds, value=corr_ds, index_mapper=xmapper, value_mapper=corr_mapper, color=tuple(COLOR_PALETTE[m % len(COLOR_PALETTE)]), edge_color="blue", face_color="paleturquoise", #bgcolor="white", border_visible=True, padding_left=25) corr_mapper.range.add(corr_plot.value) if m == 0: ###### Y axis ##################################################### left = PlotAxis( orientation='left', title=self.y_lbl, title_font="modern 12", #title_spacing=0, tick_label_font="modern 8", tick_visible=True, small_axis_style=True, axis_line_visible=False, ensure_labels_bounded=True, #tick_label_color="transparent", mapper=corr_mapper, component=corr_plot) corr_plot.overlays.append(left) ###### X axis ##################################################### if self.scale_type == 'Time': # Just the last axis shows tick_labels bottom_axis = PlotAxis(corr_plot, orientation="bottom", title=self.x_lbl, tick_generator=ScalesTickGenerator( scale=CalendarScaleSystem())) else: bottom_axis = PlotAxis(orientation='bottom', title=self.x_lbl, title_font="modern 12", tick_visible=True, small_axis_style=True, axis_line_visible=False, component=corr_plot) corr_plot.overlays.append(bottom_axis) ###### Grids ##################################################### _, vgrid = add_default_grids(corr_plot) vgrid.tick_generator = bottom_axis.tick_generator ###### Tools ##################################################### corr_plot.tools.append( PanTool(corr_plot, constrain=True, constrain_direction="x")) corr_plot.overlays.append( ZoomTool( corr_plot, drag_button="right", always_on=True, tool_mode="box", #axis="index", max_zoom_out_factor=10.0, )) container.add(corr_plot) ###### Title ##################################################### container.overlays.append( PlotLabel(self.p_title, component=container, overlay_position="outside top", font="modern 16")) container.padding_bottom = 50 return container
def _get_plot_cmap(self): if self.data is None or len(self.data.shape) == 1: return numpoints = self.data.shape[1] if self.scale_type == 'Time': index_x = self._create_dates(numpoints, start=self.first_day) else: index_x = np.arange(numpoints) x_bounds = (index_x[0], index_x[-1], len(index_x)) y_bounds = (1, self.data.shape[0], self.data.shape[0]) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("imagedata", self.data) plot = Plot(pd) plot.img_plot("imagedata", name="corr_plot", origin="top left", xbounds=x_bounds[:2], ybounds=y_bounds[:2], colormap=jet, padding_left=25) corr_plot = plot.plots['corr_plot'][0] if self.scale_type == 'Time': # Just the last axis shows tick_labels bottom_axis = PlotAxis(corr_plot, orientation="bottom", title=self.x_lbl, tick_generator=ScalesTickGenerator( scale=CalendarScaleSystem())) else: bottom_axis = PlotAxis(orientation='bottom', title=self.x_lbl, title_font="modern 12", tick_visible=True, small_axis_style=True, axis_line_visible=False, component=corr_plot) corr_plot.overlays.append(bottom_axis) corr_plot.tools.append( PanTool(corr_plot, constrain=True, constrain_direction="x", constrain_key="shift")) corr_plot.overlays.append( ZoomTool( corr_plot, drag_button="right", always_on=True, tool_mode="range", axis="index", max_zoom_out_factor=10.0, )) # Create the colorbar, handing in the appropriate range and colormap colorbar = ColorBar( index_mapper=LinearMapper(range=corr_plot.color_mapper.range), color_mapper=corr_plot.color_mapper, plot=corr_plot, orientation='v', resizable='v', width=30, padding_top=corr_plot.padding_top, padding_bottom=corr_plot.padding_bottom, padding_left=50, padding_right=5) #colorbar.plot = corr_plot #colorbar.padding_top = corr_plot.padding_top #colorbar.padding_bottom = corr_plot.padding_bottom # Add pan and zoom tools to the colorbar pan_tool = PanTool(colorbar, constrain_direction="y", constrain=True) colorbar.tools.append(pan_tool) zoom_overlay = ZoomTool(colorbar, axis="index", tool_mode="range", always_on=False, drag_button=None) colorbar.overlays.append(zoom_overlay) # Create a container to position the plot and the colorbar side-by-side container = HPlotContainer(corr_plot, colorbar, use_backbuffer=True, bgcolor="transparent", spacing=9, padding=30) container.overlays.append( PlotLabel(self.p_title, component=container, overlay_position="outside top", font="modern 16")) container.overlays.append( PlotLabel(self.y_lbl, component=container, angle=90.0, overlay_position="outside left", font="modern 12")) container.padding_bottom = 50 return container
def setup_plots(self): self.screen = Plot(self.data, resizable="hv", padding=0, bgcolor="lightgray", border_visible=False) self.screen.index_grid.visible = False self.screen.value_grid.visible = False px = self.process.capture.pixelsize w, h = self.process.capture.width, self.process.capture.height # value_range last, see set_range() self.screen.index_range.low_setting = -w/2*px self.screen.index_range.high_setting = w/2*px self.screen.value_range.low_setting = -h/2*px self.screen.value_range.high_setting = h/2*px self.horiz = Plot(self.data, resizable="h", padding=0, height=100, bgcolor="lightgray", border_visible=False) self.horiz.value_mapper.range.low_setting = \ -.1*self.process.capture.maxval self.horiz.index_range = self.screen.index_range self.vert = Plot(self.data, orientation="v", resizable="v", padding=0, width=100, bgcolor="lightgray", border_visible=False) for p in self.horiz, self.vert: p.index_axis.visible = False p.value_axis.visible = False p.index_grid.visible = True p.value_grid.visible = False self.vert.value_mapper.range.low_setting = \ -.1*self.process.capture.maxval self.vert.index_range = self.screen.value_range #self.vert.value_range = self.horiz.value_range self.mini = Plot(self.data, width=100, height=100, resizable="", padding=0, bgcolor="lightgray", border_visible=False) self.mini.index_axis.visible = False self.mini.value_axis.visible = False self.label = PlotLabel(component=self.mini, overlay_position="inside left", font="modern 10", text=self.process.text) self.mini.overlays.append(self.label) self.plots = GridPlotContainer(shape=(2, 2), padding=0, spacing=(5, 5), use_backbuffer=True, bgcolor="lightgray") self.plots.component_grid = [[self.vert, self.screen], [self.mini, self.horiz ]] self.screen.overlays.append(ZoomTool(self.screen, x_max_zoom_factor=1e2, y_max_zoom_factor=1e2, x_min_zoom_factor=0.5, y_min_zoom_factor=0.5, zoom_factor=1.2)) self.screen.tools.append(PanTool(self.screen)) self.plots.tools.append(SaveTool(self.plots, filename="bullseye.pdf")) self.asum = Plot(self.data, padding=0, height=100, bgcolor="lightgray", title="major axis", border_visible=False) self.bsum = Plot(self.data, padding=0, height=100, bgcolor="lightgray", title="minor axis", border_visible=False) for p in self.asum, self.bsum: p.value_axis.visible = False p.value_grid.visible = False p.title_font = "modern 10" p.title_position = "left" p.title_angle = 90 # lock scales #self.bsum.value_range = self.asum.value_range #self.bsum.index_range = self.asum.index_range self.abplots = VPlotContainer(padding=20, spacing=20, use_backbuffer=True,bgcolor="lightgray", fill_padding=True) self.abplots.add(self.bsum, self.asum)
def _create_plot_component(): # Create the data and datasource objects # In order for the date axis to work, the index data points need to # be in units of seconds since the epoch. This is because we are using # the CalendarScaleSystem, whose formatters interpret the numerical values # as seconds since the epoch. numpoints = 500 index = create_dates(numpoints) returns = random.lognormal(0.01, 0.1, size=numpoints) price = 100.0 * cumprod(returns) volume = abs(random.normal(1000.0, 1500.0, size=numpoints) + 2000.0) time_ds = ArrayDataSource(index) vol_ds = ArrayDataSource(volume, sort_order="none") price_ds = ArrayDataSource(price, sort_order="none") xmapper = LinearMapper(range=DataRange1D(time_ds)) vol_mapper = LinearMapper(range=DataRange1D(vol_ds)) price_mapper = LinearMapper(range=DataRange1D(price_ds)) price_plot = FilledLinePlot(index=time_ds, value=price_ds, index_mapper=xmapper, value_mapper=price_mapper, edge_color="blue", face_color="paleturquoise", bgcolor="white", border_visible=True) price_plot.overlays.append(PlotAxis(price_plot, orientation='left')), # Set the plot's bottom axis to use the Scales ticking system bottom_axis = PlotAxis( price_plot, orientation="bottom", # mapper=xmapper, tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem())) price_plot.overlays.append(bottom_axis) hgrid, vgrid = add_default_grids(price_plot) vgrid.tick_generator = bottom_axis.tick_generator 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=10.0, )) vol_plot = BarPlot(index=time_ds, value=vol_ds, index_mapper=xmapper, value_mapper=vol_mapper, line_color="transparent", fill_color="black", bar_width=1.0, bar_width_type="screen", antialias=False, height=100, resizable="h", bgcolor="white", border_visible=True) hgrid, vgrid = add_default_grids(vol_plot) # Use the same tick generator as the x-axis on the price plot vgrid.tick_generator = bottom_axis.tick_generator vol_plot.underlays.append(PlotAxis(vol_plot, orientation='left')) vol_plot.tools.append( PanTool(vol_plot, constrain=True, constrain_direction="x")) container = VPlotContainer(bgcolor="lightblue", spacing=40, padding=50, fill_padding=False) container.add(vol_plot) container.add(price_plot) container.overlays.append( PlotLabel( "Financial Plot with Date Axis", component=container, #font="Times New Roman 24")) font="Arial 24")) return container
def _create_plot_component(): # Create the data and datasource objects numpoints = 500 index = arange(numpoints) returns = random.lognormal(0.01, 0.1, size=numpoints) price = 100.0 * cumprod(returns) volume = abs(random.normal(1000.0, 1500.0, size=numpoints) + 2000.0) time_ds = ArrayDataSource(index) vol_ds = ArrayDataSource(volume, sort_order="none") price_ds = ArrayDataSource(price, sort_order="none") xmapper = LinearMapper(range=DataRange1D(time_ds)) vol_mapper = LinearMapper(range=DataRange1D(vol_ds)) price_mapper = LinearMapper(range=DataRange1D(price_ds)) price_plot = FilledLinePlot(index=time_ds, value=price_ds, index_mapper=xmapper, value_mapper=price_mapper, edge_color="blue", face_color="paleturquoise", alpha=0.5, bgcolor="white", border_visible=True) add_default_grids(price_plot) price_plot.overlays.append(PlotAxis(price_plot, orientation='left')) price_plot.overlays.append(PlotAxis(price_plot, orientation='bottom')) 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")) vol_plot = BarPlot(index=time_ds, value=vol_ds, index_mapper=xmapper, value_mapper=vol_mapper, line_color="transparent", fill_color="black", bar_width=1.0, bar_width_type="screen", antialias=False, height=100, resizable="h", bgcolor="white", border_visible=True) add_default_grids(vol_plot) vol_plot.underlays.append(PlotAxis(vol_plot, orientation='left')) vol_plot.tools.append( PanTool(vol_plot, constrain=True, constrain_direction="x")) container = VPlotContainer(bgcolor="lightblue", spacing=20, padding=50, fill_padding=False) container.add(vol_plot) container.add(price_plot) container.overlays.append( PlotLabel( "Financial Plot", component=container, #font="Times New Roman 24")) font="Arial 24")) return container
def _create_plot(self): plot_data = ArrayPlotData(image=self.image) plot = Plot(plot_data, width=500, height=500, resizable='hv', aspect_ratio=1.0, padding=8, padding_left=32, padding_bottom=32) plot.img_plot('image', colormap=jet, xbounds=(self.X[0], self.X[-1]), ybounds=(self.Y[0], self.Y[-1]), name='image') image = plot.plots['image'][0] fitplot_data = ArrayPlotData(fitimage=self.fitimage) fitplot = Plot(fitplot_data, width=500, height=500, resizable='hv', aspect_ratio=1.0, padding=8, padding_left=32, padding_bottom=32) fitplot.img_plot('fitimage', colormap=jet, xbounds=(self.Xfit[0], self.Xfit[-1]), ybounds=(self.Yfit[0], self.Yfit[-1]), name='fitimage') fitplot.overlays.insert( 0, PlotLabel(text=self.label_text, hjustify='right', vjustify='bottom', position=[880, 590])) fitimage = fitplot.plots['fitimage'][0] image.x_mapper.domain_limits = (self.confocal.scanner.getXRange()[0], self.confocal.scanner.getXRange()[1]) image.y_mapper.domain_limits = (self.confocal.scanner.getYRange()[0], self.confocal.scanner.getYRange()[1]) fitimage.x_mapper.domain_limits = ( self.confocal.scanner.getXRange()[0], self.confocal.scanner.getXRange()[1]) fitimage.y_mapper.domain_limits = ( self.confocal.scanner.getYRange()[0], self.confocal.scanner.getYRange()[1]) colormap = image.color_mapper colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=plot, orientation='v', resizable='v', width=16, height=320, padding=8, padding_left=32) container = HPlotContainer() container.add(plot) container.add(colorbar) container.add(fitplot) container.tools.append(SaveTool(container)) self.plot_data = plot_data self.scan_plot = image self.figure = plot self.fitplot_data = fitplot_data self.fitscan_plot = fitimage self.fitfigure = fitplot self.figure_container = container
def _plot(self, x, y, z, scale): pd = ArrayPlotData() pd.set_data("imagedata", z) plot = Plot(pd, padding_left=60, fill_padding=True) plot.bgcolor = 'white' cmap = fix(jet, (0, z.max())) origin = 'bottom left' # origin = 'top left' # to flip y-axis plot.img_plot("imagedata", name="surface2d", xbounds=(np.min(x), np.max(x)), ybounds=(1.0, y[-1,-1]), colormap=cmap, hide_grids=True, interpolation='nearest', origin=origin, ) plot.default_origin = origin plot.x_axis.title = u'Angle (2\u0398)' tick_font = settings.tick_font plot.x_axis.title_font = settings.axis_title_font plot.y_axis.title_font = settings.axis_title_font plot.x_axis.tick_label_font = tick_font plot.y_axis.tick_label_font = tick_font plot.y_axis.title = "Dataset" plot.y_axis.tick_interval = 1.0 actual_plot = plot.plots["surface2d"][0] self.plot_zoom_tool = ClickUndoZoomTool( plot, tool_mode="box", always_on=True, pointer="cross", drag_button=settings.zoom_button, undo_button=settings.undo_button, x_min_zoom_factor=-np.inf, y_min_zoom_factor=-np.inf, ) plot.overlays.append(self.plot_zoom_tool) plot.tools.append(TraitsTool(plot)) # Add a color bar colormap = actual_plot.color_mapper colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=actual_plot, orientation='v', resizable='v', width=30, padding=40, padding_top=50, fill_padding=True) colorbar._axis.title_font = settings.axis_title_font colorbar._axis.tick_label_font = settings.tick_font # Add pan and zoom tools to the colorbar self.colorbar_zoom_tool = ClickUndoZoomTool(colorbar, axis="index", tool_mode="range", always_on=True, drag_button=settings.zoom_button, undo_button=settings.undo_button) pan_tool = PanToolWithHistory(colorbar, history_tool=self.colorbar_zoom_tool, constrain_direction="y", constrain=True, drag_button=settings.pan_button) colorbar.tools.append(pan_tool) colorbar.overlays.append(self.colorbar_zoom_tool) # Add a label to the top of the color bar colorbar_label = PlotLabel( u'Intensity\n{:^9}'.format('(' + get_value_scale_label(scale) + ')'), component=colorbar, font=settings.axis_title_font, ) colorbar.overlays.append(colorbar_label) colorbar.tools.append(TraitsTool(colorbar)) # Add the plot and colorbar side-by-side container = HPlotContainer(use_backbuffer=True) container.add(plot) container.add(colorbar) return container
def _image_label_default(self): return PlotLabel(text='', color='red', hjustify='left', vjustify='bottom', position=[10, 10])
def _create_plot_component(): container = OverlayPlotContainer(padding=60, fill_padding=True, use_backbuffer=True, border_visible=True) # Create the initial X-series of data numpoints = 100 low = -5 high = 15.0 x = arange(low, high + 0.001, (high - low) / numpoints) # Plot some bessel functions plots = {} broadcaster = BroadcasterTool() for i in range(4): y = jn(i, x) plot = create_line_plot((x, y), color=tuple(COLOR_PALETTE[i]), width=2.0) if i == 0: add_default_grids(plot) left_axis, _ = add_default_axes(plot) left_axis.title = "Bessel j0, j2, j3" elif i != 1: # Map correctly j2 and j3 on the first plot's axis: plot0 = plots["Bessel j_0"] plot.index_mapper = plot0.index_mapper plot.value_mapper = plot0.value_mapper plot0.value_mapper.range.add(plot.value) # Create a pan/zoom tool and give it a reference to the plot it should # manipulate, but don't attach it to the plot. Instead, attach it to # the broadcaster. Do it only for each independent set of axis_mappers: if i in [0, 1]: pan = PanTool(component=plot) broadcaster.tools.append(pan) zoom = ZoomTool(component=plot) broadcaster.tools.append(zoom) container.add(plot) plots["Bessel j_%d" % i] = plot # Add an axis on the right-hand side that corresponds to the second plot. # Note that it uses plot.value_mapper instead of plot0.value_mapper. plot1 = plots["Bessel j_1"] axis = PlotAxis(plot1, orientation="right") plot1.underlays.append(axis) axis.title = "Bessel j1" # Add the broadcast tool to one of the renderers: adding it to the # container instead breaks the box mode of the ZoomTool: plot0 = plots["Bessel j_0"] plot0.tools.append(broadcaster) # Create a legend, with tools to move it around and highlight renderers: legend = Legend(component=container, padding=10, align="ur") legend.tools.append(LegendTool(legend, drag_button="right")) legend.tools.append(LegendHighlighter(legend)) container.overlays.append(legend) # Set the list of plots on the legend legend.plots = plots # Add the title at the top container.overlays.append( PlotLabel("Bessel functions", component=container, font="swiss 16", overlay_position="top")) # Add the traits inspector tool to the container container.tools.append(TraitsTool(container)) return container