def __init__(self,*args, **kw): super(FieldDataController, self).__init__(*args, **kw) #self.plotdata = ArrayPlotData(x = self.model.index, y = self.model.data) self.model.intensity_map = zeros((100,100)) # Create a plot data obect and give it this data self.plot_data = ArrayPlotData() self.plot_data.set_data("imagedata", self.model.intensity_map) # Create a contour polygon plot of the data plot = Plot(self.plot_data, default_origin="top left") plot.contour_plot("imagedata", type="poly", poly_cmap=jet, name='Intensity map') # Create a contour line plot for the data, too plot.contour_plot("imagedata", type="line") # Tweak some of the plot properties plot.title = "Intensity Map" plot.padding = 50 plot.bg_color = "black" plot.fill_padding = True # 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) dragzoom = DragZoom(plot, drag_button="right") plot.tools.append(dragzoom) plot.tools.append(CustomTool(plot)) #plot.x_axis.title = 'Index' #plot.y_axis.title = r'Power [$\mu$W]' #self.renderer = plot.plot(("x", "y"), type="line", color="black") self.plot = plot
def _create_plot_component(): # Create some data index, sorted_vals = _create_data(200) # Create a plot data obect and give it this data pd = ArrayPlotData(index = index, min = sorted_vals[0], bar_min = sorted_vals[1], average = sorted_vals[2], bar_max = sorted_vals[3], max = sorted_vals[4]) # Create the plot plot = Plot(pd) plot.candle_plot(("index", "min", "bar_min", "average", "bar_max", "max"), color = "lightgray", bar_line_color = "black", stem_color = "blue", center_color = "red", center_width = 2) # Tweak some of the plot properties plot.title = "Candlestick Plot" plot.line_width = 0.5 plot.padding = 50 # Attach some tools to the plot plot.tools.append(PanTool(plot, constrain_key="shift")) zoom = ZoomTool(component=plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) return plot
def _create_plot_component(): # Create a scalar field to colormap xs = linspace(0, 10, 600) ys = linspace(0, 5, 600) x, y = meshgrid(xs, ys) z = exp(-(x**2 + y**2) / 100) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("imagedata", z) # Create the plot plot = Plot(pd) img_plot = plot.img_plot("imagedata", xbounds=(0, 10), ybounds=(0, 5), colormap=jet)[0] # Tweak some of the plot properties plot.title = "My First Image Plot" plot.padding = 50 # Attach some tools to the plot plot.tools.append(PanTool(plot)) zoom = ZoomTool(component=img_plot, tool_mode="box", always_on=False) img_plot.overlays.append(zoom) return plot
def _create_plot_component():# 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 = sin(x)*y # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("imagedata", z) # Create the plot plot = Plot(pd) img_plot = plot.img_plot("imagedata", xbounds = xbounds[:2], ybounds = ybounds[:2], colormap=jet)[0] # Tweak some of the plot properties plot.title = "My First Image Plot" plot.padding = 50 # 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) imgtool = ImageInspectorTool(img_plot) img_plot.tools.append(imgtool) overlay = ImageInspectorOverlay(component=img_plot, image_inspector=imgtool, bgcolor="white", border_visible=True) img_plot.overlays.append(overlay) return plot
def _create_plot_component(): # Create a GridContainer to hold all of our plots container = GridContainer(padding=20, fill_padding=True, bgcolor="lightgray", use_backbuffer=True, shape=(3,3), spacing=(12,12)) # 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(9): 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 = 10 # Set each plot's aspect ratio based on its position in the # 3x3 grid of plots. n,m = divmod(i, 3) plot.aspect_ratio = float(n+1) / (m+1) # 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) return container
def _create_plot_component(): pd = ArrayPlotData(x=random(100), y=random(100)) # Create some line plots of some of the data plot = Plot(pd) # Create a scatter plot and get a reference to it (separate from the # Plot object) because we'll need it for the regression tool below. scatterplot = plot.plot(("x", "y"), color="blue", type="scatter")[0] # Tweak some of the plot properties plot.padding = 50 # Attach some tools to the plot plot.tools.append(PanTool(plot, drag_button="right")) plot.overlays.append(ZoomTool(plot)) # Add the regression tool and overlay. These need to be added # directly to the scatterplot instance (and not the Plot instance). regression = RegressionLasso(scatterplot, selection_datasource=scatterplot.index) scatterplot.tools.append(regression) scatterplot.overlays.append(RegressionOverlay(scatterplot, lasso_selection=regression)) return plot
def _create_plot_component():# 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 = sin(x)*y # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("imagedata", z) # Create the plot plot = Plot(pd) img_plot = plot.img_plot("imagedata", xbounds=xbounds[:2], ybounds=ybounds[:2], colormap=jet)[0] # Tweak some of the plot properties plot.title = "Image Plot with Lasso" plot.padding = 50 lasso_selection = LassoSelection(component=img_plot) lasso_selection.on_trait_change(lasso_updated, "disjoint_selections") lasso_overlay = LassoOverlay(lasso_selection = lasso_selection, component=img_plot) img_plot.tools.append(lasso_selection) img_plot.overlays.append(lasso_overlay) return plot
def _create_plot_component(): # Create some x-y data series (with NaNs) to plot x = linspace(-5.0, 15.0, 500) x[75:125] = nan x[200:250] = nan x[300:330] = nan pd = ArrayPlotData(index = x) pd.set_data("value1", jn(0, x)) pd.set_data("value2", jn(1, x)) # Create some line and scatter plots of the data plot = Plot(pd) plot.plot(("index", "value1"), name="j_0(x)", color="red", width=2.0) plot.plot(("index", "value2"), type="scatter", marker_size=1, name="j_1(x)", color="green") # Tweak some of the plot properties plot.title = "Plots with NaNs" plot.padding = 50 plot.legend.visible = True # 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) return plot
def _create_plot_component(): # Create some data numpts = 5000 x = sort(random(numpts)) y = random(numpts) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("index", x) pd.set_data("value", y) # Create the plot plot = Plot(pd) plot.plot(("index", "value"), type="scatter", marker="circle", index_sort="ascending", color="orange", marker_size=3, bgcolor="white") # Tweak some of the plot properties plot.title = "Scatter Plot" plot.line_width = 0.5 plot.padding = 50 # Attach some tools to the plot plot.tools.append(PanTool(plot, constrain_key="shift")) zoom = ZoomTool(component=plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) return plot
def _create_plot_component(): # Create some x-y data series to plot x = linspace(1.0, 8.0, 200) pd = ArrayPlotData(index = x) pd.set_data("y0", sqrt(x)) pd.set_data("y1", x) pd.set_data("y2", x**2) pd.set_data("y3", exp(x)) pd.set_data("y4", gamma(x)) pd.set_data("y5", x**x) # Create some line plots of some of the data plot = Plot(pd) plot.plot(("index", "y0"), line_width=2, name="sqrt(x)", color="purple") plot.plot(("index", "y1"), line_width=2, name="x", color="blue") plot.plot(("index", "y2"), line_width=2, name="x**2", color="green") plot.plot(("index", "y3"), line_width=2, name="exp(x)", color="gold") plot.plot(("index", "y4"), line_width=2, name="gamma(x)",color="orange") plot.plot(("index", "y5"), line_width=2, name="x**x", color="red") # Set the value axis to display on a log scale plot.value_scale = "log" # Tweak some of the plot properties plot.title = "Log Plot" plot.padding = 50 plot.legend.visible = True # 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) return plot
def _create_plot_component(): # Create some data numpts = 1000 x = sort(random(numpts)) y = random(numpts) color = exp(-(x**2 + y**2)) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("index", x) pd.set_data("value", y) pd.set_data("color", color) # Create the plot plot = Plot(pd) plot.plot(("index", "value", "color"), type="cmap_scatter", name="my_plot", color_mapper=jet, marker = "square", fill_alpha = 0.5, marker_size = 6, outline_color = "black", border_visible = True, bgcolor = "white") # Tweak some of the plot properties plot.title = "Colormapped Scatter Plot" plot.padding = 50 plot.x_grid.visible = False plot.y_grid.visible = False plot.x_axis.font = "modern 16" plot.y_axis.font = "modern 16" # Right now, some of the tools are a little invasive, and we need the # actual ColomappedScatterPlot object to give to them cmap_renderer = plot.plots["my_plot"][0] # Attach some tools to the plot plot.tools.append(PanTool(plot, constrain_key="shift")) zoom = ZoomTool(component=plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) selection = ColormappedSelectionOverlay(cmap_renderer, fade_alpha=0.35, selection_type="mask") cmap_renderer.overlays.append(selection) # Create the colorbar, handing in the appropriate range and colormap colorbar = create_colorbar(plot.color_mapper) colorbar.plot = cmap_renderer colorbar.padding_top = plot.padding_top colorbar.padding_bottom = plot.padding_bottom # 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" return container
def _create_plot_component(obj): # Setup the spectrum plot frequencies = linspace(0.0, float(SAMPLING_RATE)/2, num=NUM_SAMPLES/2) obj.spectrum_data = ArrayPlotData(frequency=frequencies) empty_amplitude = zeros(NUM_SAMPLES/2) obj.spectrum_data.set_data('amplitude', empty_amplitude) obj.spectrum_plot = Plot(obj.spectrum_data) spec_renderer = obj.spectrum_plot.plot(("frequency", "amplitude"), name="Spectrum", color="red")[0] obj.spectrum_plot.padding = 50 obj.spectrum_plot.title = "Spectrum" spec_range = obj.spectrum_plot.plots.values()[0][0].value_mapper.range spec_range.low = 0.0 spec_range.high = 5.0 obj.spectrum_plot.index_axis.title = 'Frequency (hz)' obj.spectrum_plot.value_axis.title = 'Amplitude' # Time Series plot times = linspace(0.0, float(NUM_SAMPLES)/SAMPLING_RATE, num=NUM_SAMPLES) obj.time_data = ArrayPlotData(time=times) empty_amplitude = zeros(NUM_SAMPLES) obj.time_data.set_data('amplitude', empty_amplitude) obj.time_plot = Plot(obj.time_data) obj.time_plot.plot(("time", "amplitude"), name="Time", color="blue") obj.time_plot.padding = 50 obj.time_plot.title = "Time" obj.time_plot.index_axis.title = 'Time (seconds)' obj.time_plot.value_axis.title = 'Amplitude' time_range = obj.time_plot.plots.values()[0][0].value_mapper.range time_range.low = -0.2 time_range.high = 0.2 # Spectrogram plot values = [zeros(NUM_SAMPLES/2) for i in xrange(SPECTROGRAM_LENGTH)] p = WaterfallRenderer(index = spec_renderer.index, values = values, index_mapper = LinearMapper(range = obj.spectrum_plot.index_mapper.range), value_mapper = LinearMapper(range = DataRange1D(low=0, high=SPECTROGRAM_LENGTH)), y2_mapper = LinearMapper(low_pos=0, high_pos=8, range=DataRange1D(low=0, high=15)), ) spectrogram_plot = p obj.spectrogram_plot = p dummy = Plot() dummy.padding = 50 dummy.index_axis.mapper.range = p.index_mapper.range dummy.index_axis.title = "Frequency (hz)" dummy.add(p) container = HPlotContainer() container.add(obj.spectrum_plot) container.add(obj.time_plot) c2 = VPlotContainer() c2.add(dummy) c2.add(container) return c2
def _create_plot_component(): # Create some data numpts = 1000 x = numpy.arange(0, numpts) y = numpy.random.random(numpts) marker_size = numpy.random.normal(4.0, 4.0, numpts) # Create a plot data object and give it this data pd = ArrayPlotData() pd.set_data("index", x) pd.set_data("value", y) # Because this is a non-standard renderer, we can't call plot.plot, which # sets up the array data sources, mappers and default index/value ranges. # So, its gotta be done manually for now. index_ds = ArrayDataSource(x) value_ds = ArrayDataSource(y) # Create the plot plot = Plot(pd) plot.index_range.add(index_ds) plot.value_range.add(value_ds) # Create the index and value mappers using the plot data ranges imapper = LinearMapper(range=plot.index_range) vmapper = LinearMapper(range=plot.value_range) # Create the scatter renderer scatter = VariableSizeScatterPlot( index=index_ds, value=value_ds, index_mapper = imapper, value_mapper = vmapper, marker='circle', marker_size=marker_size, color=(1.0,0.0,0.75,0.4)) # Append the renderer to the list of the plot's plots plot.add(scatter) plot.plots['var_size_scatter'] = [scatter] # Tweak some of the plot properties plot.title = "Scatter Plot" plot.line_width = 0.5 plot.padding = 50 # Attach some tools to the plot plot.tools.append(PanTool(plot, constrain_key="shift")) zoom = ZoomTool(component=plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) return plot
def create_plot(): # Create some data numpts = 200 x = sort(random(numpts)) y = random(numpts) color = exp(-(x**2 + y**2)) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("index", x) pd.set_data("value", y) pd.set_data("color", color) # Create the plot plot = Plot(pd) plot.plot(("index", "value", "color"), type="cmap_scatter", name="my_plot", color_mapper=jet, marker = "square", fill_alpha = 0.5, marker_size = 6, outline_color = "black", border_visible = True, bgcolor = "white") # Tweak some of the plot properties plot.title = "Colormapped Scatter Plot" plot.padding = 50 plot.x_grid.visible = False plot.y_grid.visible = False plot.x_axis.font = "modern 16" plot.y_axis.font = "modern 16" # Set colors #plot.title_color = "white" #for axis in plot.x_axis, plot.y_axis: # axis.set(title_color="white", tick_label_color="white") # Right now, some of the tools are a little invasive, and we need the # actual ColomappedScatterPlot object to give to them cmap_renderer = plot.plots["my_plot"][0] # Attach some tools to the plot plot.tools.append(PanTool(plot, constrain_key="shift")) zoom = ZoomTool(component=plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) selection = ColormappedSelectionOverlay(cmap_renderer, fade_alpha=0.35, selection_type="mask") cmap_renderer.overlays.append(selection) plot.tools.append(MoveTool(plot, drag_button="right")) return plot
def _create_plot_component(): # Create some data npts = 100 x = sort(random(npts)) y = random(npts) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("index", x) pd.set_data("value", y) # Create the plot plot = Plot(pd) plot.plot(("index", "value"), type="scatter", name="my_plot", marker="circle", index_sort="ascending", color="slategray", marker_size=6, bgcolor="white") # Tweak some of the plot properties plot.title = "Scatter Plot With Selection" plot.line_width = 1 plot.padding = 50 # Right now, some of the tools are a little invasive, and we need the # actual ScatterPlot object to give to them my_plot = plot.plots["my_plot"][0] # Attach some tools to the plot my_plot.tools.append(ScatterInspector(my_plot, selection_mode="toggle", persistent_hover=False)) my_plot.overlays.append( ScatterInspectorOverlay(my_plot, hover_color = "transparent", hover_marker_size = 10, hover_outline_color = "purple", hover_line_width = 2, selection_marker_size = 8, selection_color = "lawngreen") ) my_plot.tools.append(PanTool(my_plot)) my_plot.overlays.append(ZoomTool(my_plot, drag_button="right")) return plot
def 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.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 _create_plot_component(): # Use n_gon to compute center locations for our polygons points = n_gon(center=(0, 0), r=4, nsides=8) # Choose some colors for our polygons colors = { 3: 0xAABBCC, 4: "orange", 5: "yellow", 6: "lightgreen", 7: "green", 8: "blue", 9: "lavender", 10: "purple", } # Create a PlotData object to store the polygon data pd = ArrayPlotData() # Create a Polygon Plot to draw the regular polygons polyplot = Plot(pd) # Store path data for each polygon, and plot nsides = 3 for p in points: npoints = n_gon(center=p, r=2, nsides=nsides) nxarray, nyarray = transpose(npoints) pd.set_data("x" + str(nsides), nxarray) pd.set_data("y" + str(nsides), nyarray) plot = polyplot.plot( ("x" + str(nsides), "y" + str(nsides)), type="polygon", face_color=colors[nsides], hittest_type="poly" )[0] plot.tools.append(DataspaceMoveTool(plot, drag_button="right")) nsides = nsides + 1 # Tweak some of the plot properties polyplot.padding = 50 polyplot.title = "Polygon Plot" # Attach some tools to the plot polyplot.tools.append(PanTool(polyplot)) zoom = ZoomTool(polyplot, tool_mode="box", always_on=False) polyplot.overlays.append(zoom) return polyplot
def _field_data_plots_default(self): # Plot data and vertical container object data = ArrayPlotData(**self._get_field_plots_data()) container = VPlotContainer() # Add individual distributions plots to container for key in ('area', 'diameter', 'average', 'peak'): p = Plot(data) p.plot((key+'_bins', key), name=key, type='polygon', edge_width=2, edge_color='red', face_color='salmon') p.x_axis.title = key p.y_axis.title = 'count' p.padding = [50, 30, 20, 40] container.add(p) return container
def _create_plot_component(): # Create some data npts = 2000 x = sort(random(npts)) y = random(npts) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("index", x) pd.set_data("value", y) # Create the plot plot = Plot(pd) plot.plot(("index", "value"), type="scatter", name="my_plot", marker="circle", index_sort="ascending", color="red", marker_size=4, bgcolor="white") # Tweak some of the plot properties plot.title = "Scatter Plot With Selection" plot.line_width = 1 plot.padding = 50 # Right now, some of the tools are a little invasive, and we need the # actual ScatterPlot object to give to them my_plot = plot.plots["my_plot"][0] # Attach some tools to the plot lasso_selection = LassoSelection(component=my_plot, selection_datasource=my_plot.index) my_plot.active_tool = lasso_selection my_plot.tools.append(ScatterInspector(my_plot)) lasso_overlay = LassoOverlay(lasso_selection=lasso_selection, component=my_plot) my_plot.overlays.append(lasso_overlay) # Uncomment this if you would like to see incremental updates: #lasso_selection.incremental_select = True return plot
def _unit_data_plots_default(self): # Plot data and vertical container object data = ArrayPlotData(**self._get_unit_plots_data()) container = VPlotContainer() # Add individual distribution plots to container for key in ('avg_diameter', 'avg_area', 'coverage', 'max_r', 'num_fields'): p = Plot(data) p.plot((key+'_bins', key), name=key, type='polygon', edge_width=2, edge_color='mediumblue', face_color='lightsteelblue') p.x_axis.title = key p.y_axis.title = 'count' p.padding = [50, 30, 20, 40] if key == 'num_fields': p.x_axis.tick_interval = 1 container.add(p) return container
def _create_plot_component(): # 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 plot1 = Plot(pd) plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red") plot1.plot(("index", "y3"), name="j_3", color="blue") # Tweak some of the plot properties plot1.title = "Inset Plot" plot1.padding = 50 # Attach some tools to the plot plot1.tools.append(PanTool(plot1)) zoom = ZoomTool(component=plot1, tool_mode="box", always_on=False) plot1.overlays.append(zoom) # Create a second scatter plot of one of the datasets, linking its # range to the first plot plot2 = Plot(pd, range2d=plot1.range2d, padding=50) plot2.plot(('index', 'y3'), type="scatter", color="blue", marker="circle") plot2.set(resizable = "", bounds = [250, 250], position = [550,150], bgcolor = "white", border_visible = True, unified_draw = True ) plot2.tools.append(PanTool(plot2)) plot2.tools.append(MoveTool(plot2, drag_button="right")) zoom = ZoomTool(component=plot2, tool_mode="box", always_on=False) plot2.overlays.append(zoom) # Create a container and add our plots container = OverlayPlotContainer() container.add(plot1) container.add(plot2) return container
def stairstep_plot(energy, data, data_name): # Munge the data into a plotable form x, y = stair_step(energy, data) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("index", x) pd.set_data("value", y) # Create the plot plot = Plot(pd) plot.plot(("index", "value"), type="line", marker="circle", index_sort="ascending", color="red", marker_size=3, bgcolor="white") # Tweak some of the plot properties plot.title = data_name plot.line_width = 0.5 plot.padding = 100 plot.x_axis.title = "Energy [MeV]" plot.x_axis.title_font = "Roman 16" plot.x_axis.tick_label_font = "Roman 12" plot.y_axis.title = "Data" plot.y_axis.title_font = "Roman 16" plot.y_axis.tick_label_font = "Roman 12" plot.index_scale = 'log' plot.value_scale = 'log' # 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) return plot
def _create_plot_component(self): # Create the plot pd = self.pd plot = Plot(pd, default_origin="top left", orientation="h") plot.x_axis.orientation = "top" plot.padding = 20 #plot.y_axis.orientation = "top" # Tweak some of the plot properties #plot.bgcolor = "white" plot.bgcolor = bg_color # Attach some tools to the plot # plot.tools.append(PanTool(plot,constrain_key="shift", drag_button = 'right')) printer = DataPrinter(component=plot, process=self.process_selection) plot.tools.append(printer) plot.overlays.append( ZoomTool(component=plot, tool_mode="box", always_on=False)) return plot
def _plot_default(self): self._pd = ArrayPlotData() self._pd.set_data("imagedata", self._image) plot = Plot(self._pd, default_origin="top left") plot.x_axis.orientation = "top" img_plot = plot.img_plot("imagedata")[0] plot.bgcolor = "white" # Tweak some of the plot properties plot.title = "Click to add points, press Enter to clear selection" plot.padding = 50 plot.line_width = 1 # Attach some tools to the plot pan = PanTool(plot, drag_button="right", constrain_key="shift") plot.tools.append(pan) zoom = ZoomTool(component=plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) return plot
def _create_plot_component(): # Create a scalar field to contour xs = linspace(-2*pi, 2*pi, 600) ys = linspace(-1.5*pi, 1.5*pi, 300) x, y = meshgrid(xs,ys) z = tanh(x*y/6)*cosh(exp(-y**2)*x/3) z = x*y # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("imagedata", z) # Create a contour polygon plot of the data plot = Plot(pd, default_origin="top left") plot.contour_plot("imagedata", type="poly", poly_cmap=jet, xbounds=(xs[0], xs[-1]), ybounds=(ys[0], ys[-1])) # Create a contour line plot for the data, too plot.contour_plot("imagedata", type="line", xbounds=(xs[0], xs[-1]), ybounds=(ys[0], ys[-1])) # Tweak some of the plot properties plot.title = "My First Contour Plot" plot.padding = 50 plot.bg_color = "white" plot.fill_padding = True # 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) return plot
def _create_plot_component(): # 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 plot1 = Plot(pd) plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red") # Tweak some of the plot properties plot1.title = "My First Line Plot" plot1.padding = 50 plot1.padding_top = 75 plot1.legend.visible = True x = linspace(-5, 15.0, 100) y = jn(5, x) foreign_plot = create_line_plot((x,y), color=tuple(COLOR_PALETTE[0]), width=2.0) left, bottom = add_default_axes(foreign_plot) left.orientation = "right" bottom.orientation = "top" plot1.add(foreign_plot) # Attach some tools to the plot broadcaster = BroadcasterTool() broadcaster.tools.append(PanTool(plot1)) broadcaster.tools.append(PanTool(foreign_plot)) for c in (plot1, foreign_plot): zoom = ZoomTool(component=c, tool_mode="box", always_on=False) broadcaster.tools.append(zoom) plot1.tools.append(broadcaster) return plot1
def _create_plot_component(): # Create a scalar field to contour xs = linspace(-2 * pi, 2 * pi, 600) ys = linspace(-1.5 * pi, 1.5 * pi, 300) x, y = meshgrid(xs, ys) z = tanh(x * y / 6) * cosh(exp(-y**2) * x / 3) z = x * y # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("imagedata", z) # Create a contour polygon plot of the data plot = Plot(pd, default_origin="top left") plot.contour_plot("imagedata", type="poly", poly_cmap=jet, xbounds=(xs[0], xs[-1]), ybounds=(ys[0], ys[-1])) # Create a contour line plot for the data, too plot.contour_plot("imagedata", type="line", xbounds=(xs[0], xs[-1]), ybounds=(ys[0], ys[-1])) # Tweak some of the plot properties plot.title = "My First Contour Plot" plot.padding = 50 plot.bg_color = "white" plot.fill_padding = True # 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) return plot
def _create_plot_component(): # Create a scalar field to colormap xs = linspace(0, 10, 600) ys = linspace(0, 5, 600) x, y = meshgrid(xs, ys) z = exp(-(x ** 2 + y ** 2) / 100) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("imagedata", z) # Create the plot plot = Plot(pd) img_plot = plot.img_plot("imagedata", xbounds=(0, 10), ybounds=(0, 5), colormap=jet)[0] # Tweak some of the plot properties plot.title = "My First Image Plot" plot.padding = 50 # Attach some tools to the plot plot.tools.append(PanTool(plot)) zoom = ZoomTool(component=img_plot, tool_mode="box", always_on=False) img_plot.overlays.append(zoom) return plot
def _create_plot_component(): # Create some data numpts = 1000 x = sort(random(numpts)) y = random(numpts) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("index", x) pd.set_data("value", y) # Create the plot plot = Plot(pd) plot.plot(("index", "value"), type="scatter", name="my_plot", marker="square", index_sort="ascending", color="lightblue", outline_color="none", marker_size=3, bgcolor="white") # Tweak some of the plot properties plot.title = "Click to add points, press Enter to finalize selection" plot.padding = 50 plot.line_width = 1 # Attach some tools to the plot pan = PanTool(plot, drag_button="right", constrain_key="shift") plot.tools.append(pan) zoom = ZoomTool(component=plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) plot.overlays.append(MyLineDrawer(plot)) return plot
def make_image_plot(self, img_data): p = Plot(self.data, aspect_ratio=1) p.x_axis.visible = False p.y_axis.visible = False p.padding = [1, 1, 1, 1] return p, p.img_plot(img_data, colormap=gray, origin="top left")[0]
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 add_plot(self, signal, sweep_point=None): ## waveform = signal.get_waveform() ## x = waveform.get_x()[-1][0].tolist() ## y = np.real(waveform.get_y()[0].tolist()) if sweep_point is None: sweep_point = signal.get_circuit()._sweep_set._points[0] trace = Trace(signal, self, self._next_color(), sweep_point) x_name = trace.index_label y_name = trace.label x = trace.get_indices() y = trace.get_values() if type(y[0]) == complex: y = [value.real for value in y] #print x_name, len(x) #print y_name, len(y) #print x #print y if self.firstplot: self.plotdata = ArrayPlotData() self.plotdata.set_data(x_name, x) self.plotdata.set_data(y_name, y) plot = Plot(self.plotdata) plot.padding = 1 plot.bgcolor = "white" plot.border_visible = True add_default_grids(plot) add_default_axes(plot) plot.tools.append(PanTool(plot)) # The ZoomTool tool is stateful and allows drawing a zoom # box to select a zoom region. zoom = CustomZoomTool(plot) plot.overlays.append(zoom) # The DragZoom tool just zooms in and out as the user drags # the mouse vertically. dragzoom = DragZoom(plot, drag_button="right") plot.tools.append(dragzoom) #~ # Add a legend in the upper right corner, and make it relocatable #~ self.legend = Legend(component=plot, padding=10, align="ur") #~ self.legend.tools.append(LegendTool(self.legend, drag_button="right")) #~ plot.overlays.append(self.legend) #~ self.legend.plots = {} self.firstplot = False self.container.add(plot) self.plot = plot else: self.plotdata.set_data(x_name, x) self.plotdata.set_data(y_name, y) #self.plot.plot(self.plotdata.list_data()) pl = self.plot.plot( (x_name, y_name), name=trace.label, type="line", color=trace.color, line_style=trace.line_style, line_width=trace.line_width, marker=trace.marker, marker_size=trace.marker_size, marker_color=trace.marker_color) self.legend.plots[trace.label] = pl self.Refresh()
def clone_plot(clonetool, drop_position): # A little sketchy... canvas = clonetool.component.container.component.component # Create a new Plot object oldplot = clonetool.component newplot = Plot(oldplot.data) basic_traits = ["orientation", "default_origin", "bgcolor", "border_color", "border_width", "border_visible", "draw_layer", "unified_draw", "fit_components", "fill_padding", "visible", "aspect_ratio", "title"] for attr in basic_traits: setattr(newplot, attr, getattr(oldplot, attr)) # copy the ranges dst = newplot.range2d src = oldplot.range2d #for attr in ('_low_setting', '_low_value', '_high_setting', '_high_value'): # setattr(dst, attr, getattr(src, attr)) dst._xrange.sources = copy(src._xrange.sources) dst._yrange.sources = copy(src._yrange.sources) newplot.padding = oldplot.padding newplot.bounds = oldplot.bounds[:] newplot.resizable = "" newplot.position = drop_position newplot.datasources = copy(oldplot.datasources) for name, renderers in oldplot.plots.items(): newrenderers = [] for renderer in renderers: new_r = clone_renderer(renderer) new_r.index_mapper = LinearMapper(range=newplot.index_range) new_r.value_mapper = LinearMapper(range=newplot.value_range) new_r._layout_needed = True new_r.invalidate_draw() new_r.resizable = "hv" newrenderers.append(new_r) newplot.plots[name] = newrenderers #newplot.plots = copy(oldplot.plots) for name, renderers in newplot.plots.items(): newplot.add(*renderers) newplot.index_axis.title = oldplot.index_axis.title newplot.index_axis.unified_draw = True newplot.value_axis.title = oldplot.value_axis.title newplot.value_axis.unified_draw = True # Add new tools to the new plot newplot.tools.append(AxisTool(component=newplot, range_controller=canvas.range_controller)) # Add tools to the new plot pan_traits = ["drag_button", "constrain", "constrain_key", "constrain_direction", "speed"] zoom_traits = ["tool_mode", "always_on", "axis", "enable_wheel", "drag_button", "wheel_zoom_step", "enter_zoom_key", "exit_zoom_key", "pointer", "color", "alpha", "border_color", "border_size", "disable_on_complete", "minimum_screen_delta", "max_zoom_in_factor", "max_zoom_out_factor"] move_traits = ["drag_button", "end_drag_on_leave", "cancel_keys", "capture_mouse", "modifier_key"] if not MULTITOUCH: for tool in oldplot.tools: if isinstance(tool, PanTool): newtool = tool.clone_traits(pan_traits) newtool.component = newplot break else: newtool = PanTool(newplot) # Reconfigure the pan tool to always use the left mouse, because we will # put plot move on the right mouse button newtool.drag_button = "left" newplot.tools.append(newtool) for tool in oldplot.tools: if isinstance(tool, MoveTool): newtool = tool.clone_traits(move_traits) newtool.component = newplot break else: newtool = MoveTool(newplot, drag_button="right") newplot.tools.append(newtool) for tool in oldplot.tools: if isinstance(tool, ZoomTool): newtool = tool.clone_traits(zoom_traits) newtool.component = newplot break else: newtool = ZoomTool(newplot) newplot.tools.append(newtool) else: pz = MPPanZoom(newplot) #pz.pan.constrain = True #pz.pan.constrain_direction = "x" #pz.zoom.mode = "range" #pz.zoom.axis = "index" newplot.tools.append(MPPanZoom(newplot)) #newplot.tools.append(MTMoveTool( newplot._layout_needed = True clonetool.dest.add(newplot) newplot.invalidate_draw() newplot.request_redraw() canvas.request_redraw() return
def _create_plot_component(): # Create a scalar field to colormap x_extents = (-2*pi, 2*pi) y_extents = (-1.5*pi, 1.5*pi) xs = linspace(-2*pi, 2*pi, 200) ys = linspace(-1.5*pi, 1.5*pi, 100) x, y = meshgrid(xs,ys) zs = sin(log(abs((x+1)**4)+0.05))*cos(y)*1.1*(-y) + \ sin(((x+1)**2 + y**2)/4) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("imagedata", zs) # Create the left plot, a colormap and simple contours lplot = Plot(pd) lplot.img_plot("imagedata", name="cm_plot", xbounds=x_extents, ybounds=y_extents, colormap=gmt_drywet) lplot.contour_plot("imagedata", type="line", xbounds=x_extents, ybounds=y_extents) # Tweak some of the plot properties lplot.title = "Colormap and contours" lplot.padding = 20 lplot.bg_color = "white" lplot.fill_padding = True # Add some tools to the plot zoom = ZoomTool(lplot, tool_mode="box", always_on=False) lplot.overlays.append(zoom) lplot.tools.append(PanTool(lplot, constrain_key="shift")) # Right now, some of the tools are a little invasive, and we need the # actual CMapImage object to give to them cm_plot = lplot.plots["cm_plot"][0] # Create the colorbar, handing in the appropriate range and colormap colormap = cm_plot.color_mapper colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=cm_plot, orientation='v', resizable='v', width=30, padding=20) colorbar.padding_top = lplot.padding_top colorbar.padding_bottom = lplot.padding_bottom # Create the left plot, contours of varying color and width rplot = Plot(pd, range2d=lplot.range2d) rplot.contour_plot("imagedata", type="line", xbounds=x_extents, ybounds=y_extents, bgcolor="black", levels=15, styles="solid", widths=list(linspace(4.0, 0.1, 15)), colors=gmt_drywet) # Add some tools to the plot zoom = ZoomTool(rplot, tool_mode="box", always_on=False) rplot.overlays.append(zoom) rplot.tools.append(PanTool(rplot, constrain_key="shift")) # Tweak some of the plot properties rplot.title = "Varying contour lines" rplot.padding = 20 rplot.bg_color = "white" rplot.fill_padding = True # Create a container and add our plots container = HPlotContainer(padding=40, fill_padding=True, bgcolor = "white", use_backbuffer=True) container.add(colorbar) container.add(lplot) container.add(rplot) return container
def _h_plot_default(self): plot = Plot(self.pd, resizable="h") plot.height = 100 plot.padding = 20 plot.plot(("h_index", "h_value")) return plot
def _create_plot_component(): # Create some data numpts = 1000 x = sort(random(numpts)) y = random(numpts) color = exp(-(x**2 + y**2)) # Create a plot data obect and give it this data pd = ArrayPlotData() pd.set_data("index", x) pd.set_data("value", y) pd.set_data("color", color) # Create the plot plot = Plot(pd) plot.plot(("index", "value", "color"), type="cmap_scatter", name="my_plot", color_mapper=gist_earth, marker = "square", fill_alpha = 0.5, marker_size = 8, outline_color = "black", border_visible = True, bgcolor = "white") # Tweak some of the plot properties plot.title = "Colormapped Scatter Plot with Pan/Zoom Color Bar" plot.padding = 50 plot.x_grid.visible = False plot.y_grid.visible = False plot.x_axis.font = "modern 16" plot.y_axis.font = "modern 16" # Add pan and zoom to the plot plot.tools.append(PanTool(plot, constrain_key="shift")) zoom = ZoomTool(plot) plot.overlays.append(zoom) # Create the colorbar, handing in the appropriate range and colormap colorbar = ColorBar(index_mapper=LinearMapper(range=plot.color_mapper.range), color_mapper=plot.color_mapper, orientation='v', resizable='v', width=30, padding=20) colorbar.plot = plot colorbar.padding_top = plot.padding_top colorbar.padding_bottom = plot.padding_bottom # Add pan and zoom tools to the colorbar colorbar.tools.append(PanTool(colorbar, constrain_direction="y", constrain=True)) zoom_overlay = ZoomTool(colorbar, axis="index", tool_mode="range", always_on=True, drag_button="right") colorbar.overlays.append(zoom_overlay) # Create a container to position the plot and the colorbar side-by-side container = HPlotContainer(plot, colorbar, use_backbuffer=True, bgcolor="lightgray") return container