def _create_plot_component(): # Load state data states = pandas.read_csv('states.csv') lon = (states['longitude'] + 180.) / 360. lat = numpy.radians(states['latitude']) lat = (1 - (1. - numpy.log(numpy.tan(lat) + (1. / numpy.cos(lat))) / numpy.pi) / 2.0) populations = pandas.read_csv('state_populations.csv') data = populations['2010'] lon = lon.view(numpy.ndarray) lat = lat.view(numpy.ndarray) data = data.view(numpy.ndarray) plot = Plot(ArrayPlotData(index=lon, value=lat, color=data)) renderers = plot.plot( ("index", "value", "color"), type="cmap_scatter", name="unfunded", color_mapper=OrRd, marker="circle", outline_color='lightgray', line_width=1., marker_size=10, ) tile_cache = MBTileManager(filename='./map.mbtiles', min_level=2, max_level=4) # Need a better way add the overlays cmap = renderers[0] map = Map(cmap, tile_cache=tile_cache, zoom_level=3) cmap.underlays.append(map) plot.title = "2010 Population" plot.tools.append(PanTool(plot)) plot.tools.append(ZoomTool(plot)) plot.index_axis.title = "Longitude" plot.index_axis.tick_label_formatter = convert_lon plot.value_axis.title = "Latitude" plot.value_axis.tick_label_formatter = convert_lat cmap.overlays.append( ColormappedSelectionOverlay(cmap, fade_alpha=0.35, selection_type="mask")) colorbar = create_colorbar(plot.color_mapper) colorbar.plot = cmap colorbar.padding_top = plot.padding_top colorbar.padding_bottom = plot.padding_bottom container = HPlotContainer(use_backbuffer=True) container.add(plot) container.add(colorbar) container.bgcolor = "lightgray" return container
def control(self): """ A drawable control with a color bar. """ color_map = self.plot_obj.color_mapper linear_mapper = LinearMapper(range=color_map.range) color_bar = ColorBar(index_mapper=linear_mapper, color_mapper=color_map, plot=self.plot_obj, orientation='v', resizable='v', width=30) color_bar._axis.tick_label_formatter = self.sci_formatter color_bar.padding_top = self.padding_top color_bar.padding_bottom = self.padding_bottom color_bar.padding_left = 50 # Room for labels. color_bar.padding_right = 10 range_selection = RangeSelection(component=color_bar) range_selection.listeners.append(self.plot_obj) color_bar.tools.append(range_selection) range_selection_overlay = RangeSelectionOverlay(component=color_bar) color_bar.overlays.append(range_selection_overlay) container = HPlotContainer(use_backbuffer=True) container.add(self) container.add(color_bar) return Window(self.parent, component=container).control
def _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 _create_plot_component(): # Create some data numpts = 1000 x = sort(random(numpts)) y = random(numpts) color = randint(0, 7, numpts) # 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=accent, 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 with Range-selectable Data Points" 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(): # 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, title="Line Plot", padding=50, border_visible=True) plot1.legend.visible = True plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red") plot1.plot(("index", "y3"), name="j_3", color="blue") # 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, title="Scatter plot", padding=50, border_visible=True) plot2.plot(('index', 'y3'), type="scatter", color="blue", marker="circle") # Create a container and add our plots container = HPlotContainer() container.add(plot1) container.add(plot2) return container
def _container_default(self): x = arange(-5.0, 15.0, 20.0/100) y = jn(0, x) left_plot = create_line_plot((x, y), bgcolor="white", add_grid=True, add_axis=True) left_plot.tools.append(PanTool(left_plot)) self.left_plot = left_plot y = jn(1, x) right_plot = create_line_plot((x, y), bgcolor="white", add_grid=True, add_axis=True) right_plot.tools.append(PanTool(right_plot)) right_plot.y_axis.orientation = "right" self.right_plot = right_plot # Tone down the colors on the grids right_plot.hgrid.line_color = (0.3, 0.3, 0.3, 0.5) right_plot.vgrid.line_color = (0.3, 0.3, 0.3, 0.5) left_plot.hgrid.line_color = (0.3, 0.3, 0.3, 0.5) left_plot.vgrid.line_color = (0.3, 0.3, 0.3, 0.5) container = HPlotContainer(spacing=20, padding=50, bgcolor="lightgray") container.add(left_plot) container.add(right_plot) return container
def _plot_default(self): plot = Plot(self.plotdata) plot.title = "Simplex on the Rosenbrock function" plot.img_plot("background", name="background", xbounds=(0,1.5), ybounds=(0,1.5), colormap=jet(DataRange1D(low=0,high=100)), ) plot.plot(("values_x", "values_y"), type="scatter", color="red") background = plot.plots["background"][0] colormap = background.color_mapper colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=background, orientation='v', resizable='v', width=30, padding=20) colorbar.padding_top = plot.padding_top colorbar.padding_bottom = plot.padding_bottom container = HPlotContainer(use_backbuffer = True) container.add(plot) container.add(colorbar) container.bgcolor = "lightgray" return container
def _resplotter_default(self): res = np.zeros((400, 400)) self.pd = ArrayPlotData(res=res) p = Plot(self.pd) img = p.img_plot('res', name="my_plot") my_plot = p.plots["my_plot"][0] colormap = my_plot.color_mapper colorbar = ColorBar( index_mapper=dc.LinearMapper(range=colormap.range), color_mapper=colormap, orientation='v', plot=my_plot, resizable='v', width=30, padding=20) range_selection = RangeSelection(component=colorbar) colorbar.tools.append(range_selection) colorbar.overlays.append(RangeSelectionOverlay(component=colorbar, border_color="white", alpha=0.8, fill_color="lightgray")) range_selection.listeners.append(my_plot) con = HPlotContainer() con.add(p) con.add(colorbar) return con
def __init__(self): # Create the data and the PlotData object x = linspace(-14, 14, 100) y = sin(x) * x**3 plotdata = ArrayPlotData(x = x, y = y) # Create a scatter plot scatter_plot = Plot(plotdata) scatter_plot.plot(("x", "y"), type="scatter", color="blue") # Create a line plot line_plot1 = Plot(plotdata) line_plot1.plot(("x", "y"), type="line", color="blue") line_plot2 = Plot(plotdata) line_plot2.plot(("x", "y"), type="line", color="red") # Create a vertical container containing two horizontal containers h_container1 = HPlotContainer() h_container2 = HPlotContainer() outer_container = VPlotContainer(h_container1, h_container2, stack_order="top_to_bottom") # Add the two plots to the first container h_container1.add(scatter_plot, line_plot1, line_plot2) # Now add the first line plot to the second container => it is removed # from the first, as each plot can only have one container h_container2.add(line_plot1) self.plot = outer_container
def _container_default(self): x = arange(-5.0, 15.0, 20.0 / 100) y = jn(0, x) left_plot = create_line_plot((x, y), bgcolor="white", add_grid=True, add_axis=True) left_plot.tools.append(PanTool(left_plot)) self.left_plot = left_plot y = jn(1, x) right_plot = create_line_plot((x, y), bgcolor="white", add_grid=True, add_axis=True) right_plot.tools.append(PanTool(right_plot)) right_plot.y_axis.orientation = "right" self.right_plot = right_plot # Tone down the colors on the grids right_plot.hgrid.line_color = (0.3, 0.3, 0.3, 0.5) right_plot.vgrid.line_color = (0.3, 0.3, 0.3, 0.5) left_plot.hgrid.line_color = (0.3, 0.3, 0.3, 0.5) left_plot.vgrid.line_color = (0.3, 0.3, 0.3, 0.5) container = HPlotContainer(spacing=20, padding=50, bgcolor="lightgray") container.add(left_plot) container.add(right_plot) return container
def _figure_image_default(self): plot = Plot(self.plot_data_image, width=180, height=180, padding=3, padding_left=48, padding_bottom=32) plot.img_plot('image', colormap=jet, name='image') plot.aspect_ratio=1 #plot.value_mapper.domain_limits = (scanner.getYRange()[0],scanner.getYRange()[1]) #plot.index_mapper.domain_limits = (scanner.getXRange()[0],scanner.getXRange()[1]) plot.value_mapper.domain_limits = (0,self.size_xy) plot.index_mapper.domain_limits = (0,self.size_xy) container = HPlotContainer() image = plot.plots['image'][0] colormap = image.color_mapper colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=plot, orientation='v', resizable='v', width=20, height=200, padding=8, padding_left=20) container = HPlotContainer() container.add(plot) container.add(colorbar) return container
def _hist2d_default(self): plot = Plot(self.hist2d_data, padding=(20, 0, 0, 40)) plot.img_plot("H", xbounds=self.xedges, ybounds=self.yedges, colormap=jet) plot.index_axis.title = "Voxel dist." plot.value_axis.title = "Root Square Error" # Create a colorbar colormap = plot.color_mapper colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=plot, orientation='v', resizable='v', width=20, padding=(20, 30, 0, 0)) 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, padding=0) container.add(colorbar) container.add(plot) container.bgcolor = "lightgray" return container
def _create_plot_component(): # Create some x-y data series to plot x = linspace(-2.0, 10.0, 40) pd = ArrayPlotData(index = x, y0=jn(0,x)) # Create some line plots of some of the data plot1 = Plot(pd, title="render_style = hold", padding=50, border_visible=True, overlay_border = True) plot1.legend.visible = True lineplot = plot1.plot(("index", "y0"), name="j_0", color="red", render_style="hold") # Attach some tools to the plot attach_tools(plot1) # Create a second scatter plot of one of the datasets, linking its # range to the first plot plot2 = Plot(pd, range2d=plot1.range2d, title="render_style = connectedhold", padding=50, border_visible=True, overlay_border=True) plot2.plot(('index', 'y0'), color="blue", render_style="connectedhold") attach_tools(plot2) # Create a container and add our plots container = HPlotContainer() container.add(plot1) container.add(plot2) return container
def __init__(self): # The delegates views don't work unless we caller the superclass __init__ super(CursorTest, self).__init__() container = HPlotContainer(padding=0, spacing=20) self.plot = container # a subcontainer for the first plot. # I'm not sure why this is required. Without it, the layout doesn't work right. subcontainer = OverlayPlotContainer(padding=40) container.add(subcontainer) # make some data index = numpy.linspace(-10, 10, 512) value = numpy.sin(index) # create a LinePlot instance and add it to the subcontainer line = create_line_plot([index, value], add_grid=True, add_axis=True, index_sort="ascending", orientation="h") subcontainer.add(line) # here's our first cursor. csr = CursorTool(line, drag_button="left", color="blue") self.cursor1 = csr # and set it's initial position (in data-space units) csr.current_position = 0.0, 0.0 # this is a rendered component so it goes in the overlays list line.overlays.append(csr) # some other standard tools line.tools.append(PanTool(line, drag_button="right")) line.overlays.append(ZoomTool(line)) # make some 2D data for a colourmap plot xy_range = (-5, 5) x = numpy.linspace(xy_range[0], xy_range[1], 100) y = numpy.linspace(xy_range[0], xy_range[1], 100) X, Y = numpy.meshgrid(x, y) Z = numpy.sin(X) * numpy.arctan2(Y, X) # easiest way to get a CMapImagePlot is to use the Plot class ds = ArrayPlotData() ds.set_data("img", Z) img = Plot(ds, padding=40) cmapImgPlot = img.img_plot("img", xbounds=xy_range, ybounds=xy_range, colormap=jet)[0] container.add(img) # now make another cursor csr2 = CursorTool(cmapImgPlot, drag_button="left", color="white", line_width=2.0) self.cursor2 = csr2 csr2.current_position = 1.0, 1.5 cmapImgPlot.overlays.append(csr2) # add some standard tools. Note, I'm assigning the PanTool to the # right mouse-button to avoid conflicting with the cursors cmapImgPlot.tools.append(PanTool(cmapImgPlot, drag_button="right")) cmapImgPlot.overlays.append(ZoomTool(cmapImgPlot))
def _SmoothPlot_default(self): plotdata = ArrayPlotData(imagedata=self.Smooth) plot = Plot(plotdata, width=500, height=500, resizable='hv') SmoothImage = plot.img_plot( 'imagedata', colormap=gray, xbounds=(self.X[0], self.X[-1]), ybounds=(self.Y[0], self.Y[-1]), )[0] SmoothImage.x_mapper.domain_limits = (self.X[0], self.X[-1]) SmoothImage.y_mapper.domain_limits = (self.Y[0], self.Y[-1]) SmoothImage.overlays.append(ZoomTool(SmoothImage)) colormap = SmoothImage.color_mapper colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=plot, orientation='v', resizable='v', width=10, padding=20) colorbar.padding_top = plot.padding_top colorbar.padding_bottom = plot.padding_bottom self.SmoothImage = SmoothImage container = HPlotContainer(padding=20, fill_padding=True, use_backbuffer=True) container.add(colorbar) container.add(plot) return container
def _create_plot_component(self): selected = Event() # 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, title="Line Plot", padding=50, border_visible=True) plot1.legend.visible = True plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red") # Attach some tools to the plot plot1.tools.append(PanTool(plot1)) self.zoom = BetterSelectingZoom(component=plot1, tool_mode="box", always_on=False, selection_completed = selected) plot1.overlays.append(self.zoom) container = HPlotContainer() container.add(plot1) self.zoom.on_trait_change(self.selection_changed, 'ratio') 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, title="Line Plot", padding=50, border_visible=True) plot1.legend.visible = True plot1.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="red") plot1.plot(("index", "y3"), name="j_3", color="blue") # 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, title="Scatter plot", padding=50, border_visible=True) plot2.plot(('index', 'y3'), type="scatter", color="blue", marker="circle") # Create a container and add our plots container = HPlotContainer() container.add(plot1) container.add(plot2) return container
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 = list(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 = list(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 range(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(): # Load state data states = pandas.read_csv('states.csv') lon = (states['longitude'] + 180.) / 360. lat = numpy.radians(states['latitude']) lat = (1 - (1. - numpy.log(numpy.tan(lat) + (1./numpy.cos(lat)))/numpy.pi)/2.0) populations = pandas.read_csv('state_populations.csv') data = populations['2010'] lon = lon.view(numpy.ndarray) lat = lat.view(numpy.ndarray) data = data.view(numpy.ndarray) plot = Plot(ArrayPlotData(index = lon, value=lat, color=data)) renderers = plot.plot(("index", "value", "color"), type = "cmap_scatter", name = "unfunded", color_mapper = OrRd, marker = "circle", outline_color = 'lightgray', line_width = 1., marker_size = 10, ) tile_cache = MBTileManager(filename = './map.mbtiles', min_level = 2, max_level = 4) # Need a better way add the overlays cmap = renderers[0] map = Map(cmap, tile_cache=tile_cache, zoom_level=3) cmap.underlays.append(map) plot.title = "2010 Population" plot.tools.append(PanTool(plot)) plot.tools.append(ZoomTool(plot)) plot.index_axis.title = "Longitude" plot.index_axis.tick_label_formatter = convert_lon plot.value_axis.title = "Latitude" plot.value_axis.tick_label_formatter = convert_lat cmap.overlays.append( ColormappedSelectionOverlay(cmap, fade_alpha=0.35, selection_type="mask")) colorbar = create_colorbar(plot.color_mapper) colorbar.plot = cmap colorbar.padding_top = plot.padding_top colorbar.padding_bottom = plot.padding_bottom container = HPlotContainer(use_backbuffer = True) container.add(plot) container.add(colorbar) container.bgcolor = "lightgray" return container
def test_valign(self): container = HPlotContainer(bounds=[300, 200], valign="center") comp1 = StaticPlotComponent([200, 100]) container.add(comp1) container.do_layout() self.assertEqual(comp1.position, [0, 50]) container.valign = "top" container.do_layout(force=True) self.assertEqual(comp1.position, [0, 100]) return
def test_valign(self): container = HPlotContainer(bounds=[300,200], valign="center") comp1 = StaticPlotComponent([200,100]) container.add(comp1) container.do_layout() self.assertEqual(comp1.position, [0,50]) container.valign="top" container.do_layout(force=True) self.assertEqual(comp1.position, [0,100]) return
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
class Graph(HasTraits): plot=None traits_view=View(Item('plot',editor=ComponentEditor(bgcolor="white"), show_label=False), width=1200, height=1024, resizable=True, title="BacLog") def __init__(self): super(Graph,self).__init__() self.container = HPlotContainer(padding=20, bgcolor="transparent") self.plot_area = OverlayPlotContainer(border_visible=True) def add(self,series,limit=None): broadcaster = BroadcasterTool() for name,line in series._plot.line.items(): if limit is not None and name not in limit: continue if line.time==[]: print "Graph.add> empty:", name continue plot=create_line_plot((seconds(line.time),line.data),color=line.color) self.plot_area.add(plot) axis = PlotAxis(orientation="left", resizable="v", mapper = plot.y_mapper, bgcolor="white", title = name, title_color = line.color, title_spacing = -4.0, border_visible = True,) ## Visual style axis.bounds = [60,0] axis.padding_left = 1 axis.padding_right = 1 self.container.add(axis) ## Tools (attach to all for now) plot.tools.append(broadcaster) broadcaster.tools.append(PanTool(plot)) broadcaster.tools.append(DragZoom(plot,maintain_aspect_ratio=False,drag_button='right',restrict_domain=True)) def run(self): ## Time axis (first one) plot=self.plot_area.components[0] time = PlotAxis(orientation="bottom", component=plot, mapper=plot.x_mapper) plot.overlays.append(time) ## Plot self.container.add(self.plot_area) self.plot=self.container self.configure_traits()
def _plot1_2d_container_default(self): if self.cost_data is None or len(self.cost_data) == 0: return plot = Plot(self.cost_plot_data) plot.title = "Cost function" plot.padding_left = 80 container = HPlotContainer() container.add(plot) self.rebuild_renderer(container) return container
def add_colorbar(self, desc): """ Colorbar generated: embed it together with plot & replace in desc. """ plot = desc["plot"] container = HPlotContainer( **self.plot_style.container_style.to_traits()) container.add(plot, self.colorbar) container.padding_right = sum( [comp.padding_right for comp in container.components]) container.bgcolor = "transparent" desc["plot"] = container
def _create_plot_component(max_pop, index_ds, value_ds, color_ds, paths): tile_cache = HTTPTileManager(min_level=2, max_level=4, server='tile.cloudmade.com', url='/1a1b06b230af4efdbb989ea99e9841af/20760/256/%(zoom)d/%(col)d/%(row)d.png') # noqa color_range = DataRange1D(color_ds, low_setting=0) choro = ChoroplethPlot( index=index_ds, value=value_ds, color_data=color_ds, index_mapper=LinearMapper(range=DataRange1D(index_ds)), value_mapper=LinearMapper(range=DataRange1D(value_ds)), color_mapper=colormap(range=color_range), outline_color='white', line_width=1.5, fill_alpha=1., compiled_paths=paths, tile_cache=tile_cache, zoom_level=3, ) container = OverlayPlotContainer( bgcolor='sys_window', padding=50, fill_padding=False, border_visible=True, ) container.add(choro) for dir in ['left']: axis = PlotAxis(tick_label_formatter=convert_lat, mapper=choro.value_mapper, component=container, orientation=dir) container.overlays.append(axis) for dir in ['top', 'bottom']: axis = PlotAxis(tick_label_formatter=convert_lon, mapper=choro.index_mapper, component=container, orientation=dir) container.overlays.append(axis) choro.tools.append(PanTool(choro)) choro.tools.append(ZoomTool(choro)) colorbar = create_colorbar(choro) colorbar.padding_top = container.padding_top colorbar.padding_bottom = container.padding_bottom plt = HPlotContainer(use_backbuffer=True) plt.add(container) plt.add(colorbar) plt.bgcolor = "sys_window" return plt
def _create_plot_component(): # Create the index numpoints = 100 low = -5 high = 15.0 x = arange(low, high, (high - low) / numpoints) plotdata = ArrayPlotData(x=x, y1=jn(0, x), y2=jn(1, x)) # Create the left plot left_plot = Plot(plotdata) left_plot.x_axis.title = "X" left_plot.y_axis.title = "j0(x)" renderer = left_plot.plot(("x", "y1"), type="line", color="blue", width=2.0)[0] renderer.overlays.append( LineInspector(renderer, axis='value', write_metadata=True, is_listener=True)) renderer.overlays.append( LineInspector(renderer, axis="index", write_metadata=True, is_listener=True)) left_plot.overlays.append(ZoomTool(left_plot, tool_mode="range")) left_plot.tools.append(PanTool(left_plot)) # Create the right plot right_plot = Plot(plotdata) right_plot.index_range = left_plot.index_range right_plot.orientation = "v" right_plot.x_axis.title = "j1(x)" right_plot.y_axis.title = "X" renderer2 = right_plot.plot(("x", "y2"), type="line", color="red", width=2.0)[0] renderer2.index = renderer.index renderer2.overlays.append( LineInspector(renderer2, write_metadata=True, is_listener=True)) renderer2.overlays.append( LineInspector(renderer2, axis="value", is_listener=True)) right_plot.overlays.append(ZoomTool(right_plot, tool_mode="range")) right_plot.tools.append(PanTool(right_plot)) container = HPlotContainer(background="lightgray") container.add(left_plot) container.add(right_plot) return container
class LinePlotUI(HasTraits): # Line data source line_data_source = Instance(LineDataSource) # container for all plots container = Instance(HPlotContainer) # Plot components within this container line_plot = Instance(Plot) # Plot data pd = Instance(ArrayPlotData) # Traits view definitions: traits_view = View(Group( UItem('container', editor=ComponentEditor(size=(500, 200)))), resizable=True) # ------------------------------------------------------------------------- # Private Traits # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- # Public View interface # ------------------------------------------------------------------------- def __init__(self, line_data_source=None): super(LinePlotUI, self).__init__() with errstate(invalid='ignore'): self.create_plot() self.line_data_source = line_data_source def create_plot(self): self.pd = ArrayPlotData(line_index=array([]), line_value=array([])) # Create the colormapped scalar plot self.line_plot = Plot(self.pd) self.line_plot.plot(("line_index", "line_value"), type="line") # Create a container and add components self.container = HPlotContainer() self.container.add(self.line_plot) @on_trait_change('line_data_source.data_source_changed') def update(self): xs = self.line_data_source.xs ys = self.line_data_source.ys self.pd.update(line_index=xs, line_value=ys) self.container.invalidate_draw() self.container.request_redraw()
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 plot = Plot(pd, title="Line Plot", padding=50, border_visible=True) 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.x_grid.line_color = "black" plot.y_grid.line_color = "black" xmin, xmax = 1.0, 6.0 ymin, ymax = 0.2, 0.80001 plot.x_grid.data_min = xmin plot.x_grid.data_max = xmax plot.x_grid.transverse_bounds = (ymin, ymax) plot.x_grid.transverse_mapper = plot.y_mapper plot.y_grid.data_min = ymin plot.y_grid.data_max = ymax plot.y_grid.transverse_bounds = (xmin, xmax) plot.y_grid.transverse_mapper = plot.x_mapper # 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) # A second plot whose vertical grid lines are clipped to the jn(3) function def my_bounds_func(ticks): """ Returns y_low and y_high for each grid tick in the array **ticks** """ tmp = array([zeros(len(ticks)), jn(3, ticks)]).T return tmp func_plot = Plot(pd, padding=50, border_visible=True) func_plot.plot(("index", "y3"), color="red") func_plot.x_grid.transverse_bounds = my_bounds_func func_plot.x_grid.transverse_mapper = func_plot.y_mapper func_plot.x_grid.line_color = "black" func_plot.tools.append(PanTool(func_plot)) container = HPlotContainer() container.add(plot) container.add(func_plot) return container
def _load_image_data(self, data): cont = HPlotContainer() pd = ArrayPlotData() plot = Plot(data=pd, padding=[30, 5, 5, 30], default_origin="top left") pd.set_data("img", data) img_plot = plot.img_plot("img")[0] self._add_inspector(img_plot) self._add_tools(img_plot) cont.add(plot) cont.request_redraw() self.image_container.container = cont
def _load_image_data(self, data): cont = HPlotContainer() pd = ArrayPlotData() plot = Plot(data=pd, padding=[30, 5, 5, 30], default_origin='top left') pd.set_data('img', data) img_plot = plot.img_plot('img', )[0] self._add_inspector(img_plot) self._add_tools(img_plot) cont.add(plot) cont.request_redraw() self.image_container.container = cont
def test_stack_nonresize(self): # Assuming resizable='' for all plot containers and components container = HPlotContainer(bounds=[300, 100]) comp1 = StaticPlotComponent([100, 70]) comp2 = StaticPlotComponent([90, 80]) comp3 = StaticPlotComponent([80, 90]) container.add(comp1, comp2, comp3) container.do_layout() self.assert_tuple(container.get_preferred_size(), (270, 90)) self.assert_tuple(container.bounds, (300, 100)) self.assert_tuple(comp1.position, (0, 0)) self.assert_tuple(comp2.position, (100, 0)) self.assert_tuple(comp3.position, (190, 0)) return
def test_stack_nonresize(self): # Assuming resizable='' for all plot containers and components container = HPlotContainer(bounds=[300,100]) comp1 = StaticPlotComponent([100,70]) comp2 = StaticPlotComponent([90,80]) comp3 = StaticPlotComponent([80,90]) container.add(comp1, comp2, comp3) container.do_layout() self.assert_tuple(container.get_preferred_size(), (270,90)) self.assert_tuple(container.bounds, (300,100)) self.assert_tuple(comp1.position, (0,0)) self.assert_tuple(comp2.position, (100,0)) self.assert_tuple(comp3.position, (190,0)) return
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 plot = Plot(pd, title="Line Plot", padding=50, border_visible=True) 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.x_grid.line_color = "black" plot.y_grid.line_color = "black" xmin, xmax = 1.0, 6.0 ymin, ymax = 0.2, 0.80001 plot.x_grid.set(data_min = xmin, data_max = xmax, transverse_bounds = (ymin, ymax), transverse_mapper = plot.y_mapper) plot.y_grid.set(data_min = ymin, data_max = ymax, transverse_bounds = (xmin, xmax), transverse_mapper = plot.x_mapper) # 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) # A second plot whose vertical grid lines are clipped to the jn(3) function def my_bounds_func(ticks): """ Returns y_low and y_high for each grid tick in the array **ticks** """ tmp = array([zeros(len(ticks)),jn(3, ticks)]).T return tmp func_plot = Plot(pd, padding=50, border_visible=True) func_plot.plot(("index", "y3"), color="red") func_plot.x_grid.set(transverse_bounds = my_bounds_func, transverse_mapper = func_plot.y_mapper, line_color="black") func_plot.tools.append(PanTool(func_plot)) container = HPlotContainer() container.add(plot) container.add(func_plot) return container
def _create_plot_component(model): # Create a plot data object and give it the model's data array. pd = ArrayPlotData() pd.set_data("imagedata", model.data) # Create the "main" Plot. plot = Plot(pd, padding=50) # Use a TransformColorMapper for the color map. tcm = TransformColorMapper.from_color_map(jet) # Create the image plot renderer in the main plot. renderer = plot.img_plot("imagedata", xbounds=model.x_array, ybounds=model.y_array, colormap=tcm)[0] # Create the colorbar. lm = LinearMapper(range=renderer.value_range, domain_limits=(renderer.value_range.low, renderer.value_range.high)) colorbar = ColorBar(index_mapper=lm, plot=plot, orientation='v', resizable='v', width=30, padding=20) 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(use_backbuffer=True) container.add(plot) container.add(colorbar) return container
def test_stack_one_resize(self): "Checks stacking with 1 resizable component thrown in" container = HPlotContainer(bounds=[300,100]) comp1 = StaticPlotComponent([100,70]) comp2 = StaticPlotComponent([90,80]) comp3 = StaticPlotComponent([80,90], resizable='hv') comp4 = StaticPlotComponent([40,50]) container.add(comp1, comp2, comp3, comp4) container.do_layout() self.assert_tuple(container.get_preferred_size(), (230,80)) self.assert_tuple(container.bounds, (300,100)) self.assert_tuple(comp1.position, (0,0)) self.assert_tuple(comp2.position, (100,0)) self.assert_tuple(comp3.position, (190,0)) self.assert_tuple(comp4.position, (260,0)) return
def test_stack_one_resize(self): "Checks stacking with 1 resizable component thrown in" container = HPlotContainer(bounds=[300, 100]) comp1 = StaticPlotComponent([100, 70]) comp2 = StaticPlotComponent([90, 80]) comp3 = StaticPlotComponent([80, 90], resizable='hv') comp4 = StaticPlotComponent([40, 50]) container.add(comp1, comp2, comp3, comp4) container.do_layout() self.assert_tuple(container.get_preferred_size(), (230, 80)) self.assert_tuple(container.bounds, (300, 100)) self.assert_tuple(comp1.position, (0, 0)) self.assert_tuple(comp2.position, (100, 0)) self.assert_tuple(comp3.position, (190, 0)) self.assert_tuple(comp4.position, (260, 0)) return
def _container_default(self): #image_container = OverlayPlotContainer(padding=20, # use_backbuffer=True, # unified_draw=True) #image_container.add(self.plot) container = HPlotContainer(padding=40, fill_padding=True, bgcolor="white", use_backbuffer=False) inner_cont = VPlotContainer(padding=0, use_backbuffer=True) # container = HPlotContainer(bgcolor = "white", use_backbuffer=False) # inner_cont = VPlotContainer(use_backbuffer=True) inner_cont.add(self.h_plot) inner_cont.add(self.plot) container.add(inner_cont) container.add(self.v_plot) return container
def _create_plot_component(model): # Create a plot data object and give it the model's data array. pd = ArrayPlotData() pd.set_data("imagedata", model.data) # Create the "main" Plot. plot = Plot(pd, padding=50) # Use a TransformColorMapper for the color map. tcm = TransformColorMapper.from_color_map(jet) # Create the image plot renderer in the main plot. renderer = plot.img_plot("imagedata", xbounds=model.x_array, ybounds=model.y_array, colormap=tcm)[0] # Create the colorbar. lm = LinearMapper(range=renderer.value_range, domain_limits=(renderer.value_range.low, renderer.value_range.high)) colorbar = ColorBar(index_mapper=lm, plot=plot, orientation='v', resizable='v', width=30, padding=20) 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(use_backbuffer = True) container.add(plot) container.add(colorbar) return container
def _corr_plot_default(self): diag = self.covar.diagonal() corr = self.covar / np.sqrt(np.outer(diag, diag)) N = len(diag) value_range = DataRange1D(low=-1, high=1) color_mapper = cmap(range=value_range) index = GridDataSource() value = ImageData() mapper = GridMapper(range=DataRange2D(index), y_low_pos=1.0, y_high_pos=0.0) index.set_data(xdata=np.arange(-0.5, N), ydata=np.arange(-0.5, N)) value.set_data(np.flipud(corr)) self.corr_data = value cmap_plot = CMapImagePlot(index=index, index_mapper=mapper, value=value, value_mapper=color_mapper, padding=(40, 40, 100, 40)) yaxis = PlotAxis( cmap_plot, orientation='left', tick_interval=1, tick_label_formatter=lambda x: self.header[int(N - 1 - x)], tick_generator=ShowAllTickGenerator(positions=np.arange(N))) xaxis = PlotAxis( cmap_plot, orientation='top', tick_interval=1, tick_label_formatter=lambda x: self.header[int(x)], tick_label_alignment='edge', tick_generator=ShowAllTickGenerator(positions=np.arange(N))) cmap_plot.overlays.append(yaxis) cmap_plot.overlays.append(xaxis) colorbar = ColorBar( index_mapper=LinearMapper(range=cmap_plot.value_range), plot=cmap_plot, orientation='v', resizable='v', width=10, padding=(40, 5, 100, 40)) container = HPlotContainer(bgcolor='transparent') container.add(cmap_plot) container.add(colorbar) return container
def _create_plot_component(): # Create the index numpoints = 100 low = -5 high = 15.0 x = arange(low, high, (high - low) / numpoints) plotdata = ArrayPlotData(x=x, y1=jn(0, x), y2=jn(1, x)) # Create the left plot left_plot = Plot(plotdata) left_plot.x_axis.title = "X" left_plot.y_axis.title = "j0(x)" renderer = left_plot.plot(("x", "y1"), type="line", color="blue", width=2.0)[0] renderer.overlays.append(LineInspector(renderer, axis='value', write_metadata=True, is_listener=True)) renderer.overlays.append(LineInspector(renderer, axis="index", write_metadata=True, is_listener=True)) left_plot.overlays.append(ZoomTool(left_plot, tool_mode="range")) left_plot.tools.append(PanTool(left_plot)) # Create the right plot right_plot = Plot(plotdata) right_plot.index_range = left_plot.index_range right_plot.orientation = "v" right_plot.x_axis.title = "j1(x)" right_plot.y_axis.title = "X" renderer2 = right_plot.plot(("x", "y2"), type="line", color="red", width=2.0)[0] renderer2.index = renderer.index renderer2.overlays.append(LineInspector(renderer2, write_metadata=True, is_listener=True)) renderer2.overlays.append(LineInspector(renderer2, axis="value", is_listener=True)) right_plot.overlays.append(ZoomTool(right_plot, tool_mode="range")) right_plot.tools.append(PanTool(right_plot)) container = HPlotContainer(background="lightgray") container.add(left_plot) container.add(right_plot) return container
def _create_plot_component(obj): # Setup the xaxis 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) obj.spectrum_plot.plot(("frequency", "amplitude"), name="Spectrum", color="red") 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' # Setup yaxis plot spectrogram_data = zeros((NUM_SAMPLES / 2, SPECTROGRAM_LENGTH)) obj.spectrogram_plotdata = ArrayPlotData() obj.spectrogram_plotdata.set_data('imagedata', spectrogram_data) spectrogram_plot = Plot(obj.spectrogram_plotdata) max_time = float(SPECTROGRAM_LENGTH * NUM_SAMPLES) / SAMPLING_RATE max_freq = float(SAMPLING_RATE / 2) spectrogram_plot.img_plot( 'imagedata', name='Spectrogram', xbounds=(0, max_time), ybounds=(0, max_freq), colormap=hot, ) range_obj = spectrogram_plot.plots['Spectrogram'][0].value_mapper.range range_obj.high = 5 range_obj.low = 0.0 spectrogram_plot.title = 'Spectrogram' obj.spectrogram_plot = spectrogram_plot container = HPlotContainer() container.add(obj.spectrum_plot) container.add(obj.spectrogram_plot) return container
def _create_plot_component(obj, cqtkernel): # Scale plot scale_data = zeros((OCTAVES * BINS, FRAMES_PER_PLOT)) obj.scale_plotdata = ArrayPlotData() obj.scale_plotdata.set_data('scaleimagedata', scale_data) scale_plot = Plot(obj.scale_plotdata) max_time = float(FRAMES_PER_PLOT * 2**(OCTAVES-1) * cqtkernel.FFTLen) / SAMPLING_RATE max_note_index = OCTAVES * BINS scale_plot.img_plot('scaleimagedata', name = 'Scale', xbounds=(0, max_time), ybounds=(0, max_note_index), colormap=hot, ) scale_range = scale_plot.plots['Scale'][0].value_mapper.range scale_range.high = 5 scale_range.low = 0.0 scale_plot.title = 'Scale' obj.scale_plot = scale_plot # CQT plot cqt_data = zeros((OCTAVES * BINS, FRAMES_PER_PLOT)) obj.cqt_plotdata = ArrayPlotData() obj.cqt_plotdata.set_data('cqtimagedata', cqt_data) cqt_plot = Plot(obj.cqt_plotdata) max_time = float(FRAMES_PER_PLOT * 2**(OCTAVES-1) * cqtkernel.FFTLen) / SAMPLING_RATE max_note_index = OCTAVES * BINS cqt_plot.img_plot('cqtimagedata', name = 'CQT', xbounds=(0, max_time), ybounds=(0, max_note_index), colormap=hot, ) cqt_range = cqt_plot.plots['CQT'][0].value_mapper.range cqt_range.high = 5 cqt_range.low = 0.0 cqt_plot.title = 'CQT' obj.cqt_plot = cqt_plot container = HPlotContainer() container.add(obj.scale_plot) container.add(obj.cqt_plot) return container
def _RegionsPlot_default(self): plotdata = ArrayPlotData(imagedata=self.RegionsAndLabels[0], x=self.XPositions, y=self.YPositions) plot = Plot(plotdata, width=500, height=500, resizable='hv') RegionsImage = plot.img_plot( 'imagedata', colormap=gray, xbounds=(self.X[0], self.X[-1]), ybounds=(self.Y[0], self.Y[-1]), )[0] RegionsImage.x_mapper.domain_limits = (self.X[0], self.X[-1]) RegionsImage.y_mapper.domain_limits = (self.Y[0], self.Y[-1]) RegionsImage.overlays.append(ZoomTool(RegionsImage)) scatterplot = plot.plot(('x', 'y'), type='scatter', marker='plus', color='yellow') colormap = RegionsImage.color_mapper colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=plot, orientation='v', resizable='v', width=10, padding=20) colorbar.padding_top = plot.padding_top colorbar.padding_bottom = plot.padding_bottom self.RegionsData = plotdata self.RegionsImage = RegionsImage container = HPlotContainer(padding=20, fill_padding=True, use_backbuffer=True) container.add(colorbar) container.add(plot) return container
def createPlot( self, showDataTag ): # picks the desired channel out of the interleaved data stride = self.header.getChannels() # the first sample contains the data tag - the user has the # option to not display with the offset enabled offset = 0 if showDataTag else stride # we first grab the entire table and then select ALL ipps # along with the associated channel we're interested in. # I'm assuming this slice is a reference of the original. self.dataView = self.header.getBuffer()[ :, offset::stride ] i = self.dataView['real'] q = self.dataView['imag'] xAxis = range( offset, i.size ) # compute magnitude pwr = ( i**2.00 + q**2.00 ) # compute power in dB pwr = 10*log10(pwr) # limit lower data value to -40dB to prevent -inf problems pwr = clip(pwr, -40, pwr.max() ) plotData = ArrayPlotData( pwr=pwr ) plot = Plot( plotData ) plot.img_plot( 'pwr', xbounds=(0,self.header.getSamples()-offset), ybounds=(0,self.header.getIpps()) ) plot.title = 'RTI Plot' colorbar = self.createColorbar( plot.color_mapper ) container = HPlotContainer( use_backbuffer = True ) container.add( plot ) container.add( colorbar ) return container
def _reconstruction_default(self): rows, cols = self.image.shape[:2] self.plot_data = ArrayPlotData(original=self.image[0], reconstruction=self.result[0]) aspect = cols / float(rows) old = Plot(self.plot_data) old.plot('original', ) old.title = 'Old' self.new = Plot(self.plot_data) self.new.plot('reconstruction') self.new.title = 'New' container = HPlotContainer(bgcolor='none') container.add(old) container.add(self.new) return container
def _reconstruction_default(self): rows, cols = self.image.shape[:2] self.plot_data = ArrayPlotData(original=self.image[0], reconstruction=self.result[0]) aspect = cols/float(rows) old = Plot(self.plot_data) old.plot('original', ) old.title = 'Old' self.new = Plot(self.plot_data) self.new.plot('reconstruction') self.new.title = 'New' container = HPlotContainer(bgcolor='none') container.add(old) container.add(self.new) return container
def _create_plot_component(): numpoints = 100 low = -5 high = 15.0 x = arange(low, high, (high-low)/numpoints) container = HPlotContainer(resizable = "hv", bgcolor="lightgray", fill_padding=True, padding = 10) # container = VPlotContainer(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="v") # orientation="h") 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("More Bessels", component=container, font = "swiss 16", overlay_position = "top")) return container
class ImageViewer(HasTraits): container = Instance(HPlotContainer, ()) plot = Any def load_image(self, path): if os.path.isfile(path): with open(path, 'r') as fp: self.set_image(fp) def set_image(self, buf): ''' buf is a file-like object ''' self.container = HPlotContainer() pd = ArrayPlotData(x=[0, 640], y=[0, 480]) padding = [30, 5, 5, 30] plot = Plot(data=pd, padding=padding, # default_origin='' ) self.plot = plot.plot(('x', 'y'),)[0] self.plot.index.sort_order = 'ascending' imo = ImageUnderlay(self.plot, padding=padding, path=buf) self.plot.overlays.append(imo) self._add_tools(self.plot) self.container.add(plot) self.container.request_redraw() def _add_tools(self, plot): inspector = XYInspector(plot) plot.tools.append(inspector) plot.overlays.append(XYInspectorOverlay(inspector=inspector, component=plot, align='ul', bgcolor=0xFFFFD2 ))
class ImageViewer(HasTraits): container = Instance(HPlotContainer, ()) plot = Any def load_image(self, path): if os.path.isfile(path): with open(path, 'r') as rfile: self.set_image(rfile) def set_image(self, buf): ''' buf is a file-like object ''' self.container = HPlotContainer() pd = ArrayPlotData(x=[0, 640], y=[0, 480]) padding = [30, 5, 5, 30] plot = Plot(data=pd, padding=padding, # default_origin='' ) self.plot = plot.plot(('x', 'y'),)[0] self.plot.index.sort_order = 'ascending' imo = ImageUnderlay(self.plot, padding=padding, path=buf) self.plot.overlays.append(imo) self._add_tools(self.plot) self.container.add(plot) self.container.request_redraw() def _add_tools(self, plot): inspector = XYInspector(plot) plot.tools.append(inspector) plot.overlays.append(XYInspectorOverlay(inspector=inspector, component=plot, align='ul', bgcolor=0xFFFFD2 ))
def _reconstruction_default(self): self.plot_data = ArrayPlotData(original=self.image, reconstruction=self.result) rows, cols = self.image.shape[:2] aspect = cols/float(rows) old = Plot(self.plot_data) old.img_plot('original', colormap=gray, origin='top left') old.title = 'Old' old.aspect_ratio = aspect self.new = Plot(self.plot_data) self.new.img_plot('reconstruction', colormap=gray, origin='top left') self.new.title = 'New' self.new.aspect_ratio = aspect container = HPlotContainer(bgcolor='none') container.add(old) container.add(self.new) 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) obj.spectrum_plot.plot(("frequency", "amplitude"), name="Spectrum", color="red") 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 spectrogram_data = zeros(( NUM_SAMPLES/2, SPECTROGRAM_LENGTH)) obj.spectrogram_plotdata = ArrayPlotData() obj.spectrogram_plotdata.set_data('imagedata', spectrogram_data) spectrogram_plot = Plot(obj.spectrogram_plotdata) max_time = float(SPECTROGRAM_LENGTH * NUM_SAMPLES) / SAMPLING_RATE max_freq = float(SAMPLING_RATE / 2) spectrogram_plot.img_plot('imagedata', name='Spectrogram', xbounds=(0, max_time), ybounds=(0, max_freq), colormap=jet, ) range_obj = spectrogram_plot.plots['Spectrogram'][0].value_mapper.range range_obj.high = 5 range_obj.low = 0.0 spectrogram_plot.title = 'Spectrogram' obj.spectrogram_plot = spectrogram_plot container = HPlotContainer() container.add(obj.spectrum_plot) container.add(obj.time_plot) container.add(spectrogram_plot) return container
def _reconstruction_default(self): self.plot_data = ArrayPlotData(original=self.image, reconstruction=self.result) rows, cols = self.image.shape[:2] aspect = cols / float(rows) old = Plot(self.plot_data) old.img_plot('original', colormap=gray, origin='top left') old.title = 'Old' old.aspect_ratio = aspect self.new = Plot(self.plot_data) self.new.img_plot('reconstruction', colormap=gray, origin='top left') self.new.title = 'New' self.new.aspect_ratio = aspect container = HPlotContainer(bgcolor='none') container.add(old) container.add(self.new) return container
def __init__(self): #The delegates views don't work unless we caller the superclass __init__ super(ImshowPlot, self).__init__() container = HPlotContainer(padding=0, spacing=20) self.plot = container #make some 2D data for a colourmap plot xy_range = (-5, 5) x = np.linspace(xy_range[0], xy_range[1] ,100) y = np.linspace(xy_range[0], xy_range[1] ,100) X,Y = np.meshgrid(x, y) Z = np.sin(X)*np.arctan2(Y,X) #easiest way to get a CMapImagePlot is to use the Plot class ds = ArrayPlotData() ds.set_data('img', Z) img = Plot(ds, padding=40) img.img_plot("img", xbounds = xy_range, ybounds = xy_range) container.add(img)
def _create_plot_component(obj, cqtkernel): # Scale plot scale_data = zeros((OCTAVES * BINS, FRAMES_PER_PLOT)) obj.scale_plotdata = ArrayPlotData() obj.scale_plotdata.set_data("scaleimagedata", scale_data) scale_plot = Plot(obj.scale_plotdata) max_time = float(FRAMES_PER_PLOT * 2 ** (OCTAVES - 1) * cqtkernel.FFTLen) / SAMPLING_RATE max_note_index = OCTAVES * BINS scale_plot.img_plot( "scaleimagedata", name="Scale", xbounds=(0, max_time), ybounds=(0, max_note_index), colormap=hot ) scale_range = scale_plot.plots["Scale"][0].value_mapper.range scale_range.high = 5 scale_range.low = 0.0 scale_plot.title = "Scale" obj.scale_plot = scale_plot # CQT plot cqt_data = zeros((OCTAVES * BINS, FRAMES_PER_PLOT)) obj.cqt_plotdata = ArrayPlotData() obj.cqt_plotdata.set_data("cqtimagedata", cqt_data) cqt_plot = Plot(obj.cqt_plotdata) max_time = float(FRAMES_PER_PLOT * 2 ** (OCTAVES - 1) * cqtkernel.FFTLen) / SAMPLING_RATE max_note_index = OCTAVES * BINS cqt_plot.img_plot("cqtimagedata", name="CQT", xbounds=(0, max_time), ybounds=(0, max_note_index), colormap=hot) cqt_range = cqt_plot.plots["CQT"][0].value_mapper.range cqt_range.high = 5 cqt_range.low = 0.0 cqt_plot.title = "CQT" obj.cqt_plot = cqt_plot container = HPlotContainer() container.add(obj.scale_plot) container.add(obj.cqt_plot) return container