def test_reversed(self): ary = array([5.0, 6.0, 7.0, 8.0, 9.0, 10.0]) ds = ArrayDataSource(ary) r = DataRange1D(ds) mapper = LinearMapper(range=r, low_pos=100, high_pos=0) result = mapper.map_screen(ary) assert_equal(result , array([100, 80, 60, 40, 20, 0])) return
def test_update_high_pos_dont_stretch_data_with_zero(self): ary = array([5.0, 6.0, 7.0, 8.0, 9.0, 10.0]) ds = ArrayDataSource(ary) r = DataRange1D(ds) mapper = LinearMapper(range=r, stretch_data=False) # Initialize the bounds, then modify them. mapper.screen_bounds = (50.0, 100.0) mapper.high_pos = 100.0 result = mapper.map_screen(ary) assert_array_almost_equal(result, array([50, 60, 70, 80, 90, 100]))
def test_update_low_pos_stretch_data_with_reverse(self): ary = array([5.0, 6.0, 7.0, 8.0, 9.0, 10.0]) ds = ArrayDataSource(ary) r = DataRange1D(ds) mapper = LinearMapper(range=r, stretch_data=True) # Initialize the bounds, then modify them. mapper.screen_bounds = (50.0, 100.0) mapper.low_pos = 150.0 result = mapper.map_screen(ary) assert_array_almost_equal(result, array([150, 140, 130, 120, 110, 100]))
def test_reversed_update_high_pos_stretch_data(self): ary = array([5.0, 6.0, 7.0, 8.0, 9.0, 10.0]) ds = ArrayDataSource(ary) r = DataRange1D(ds) mapper = LinearMapper(range=r, stretch_data=True) # Initialize the bounds, then modify them. mapper.screen_bounds = (100.0, 50.0) mapper.high_pos = 40.0 result = mapper.map_screen(ary) assert_array_almost_equal(result, array([100, 88, 76, 64, 52, 40]))
def test_reversed_update_screen_bounds_stretch_data(self): ary = array([5.0, 6.0, 7.0, 8.0, 9.0, 10.0]) ds = ArrayDataSource(ary) r = DataRange1D(ds) mapper = LinearMapper(range=r, stretch_data=True) # Initialize the bounds, then modify them. mapper.screen_bounds = (100.0, 0.0) mapper.screen_bounds = (120.0, -10.0) result = mapper.map_screen(ary) assert_array_almost_equal( result, array([120.0, 94.0, 68.0, 42.0, 16.0, -10.0]))
def test_reversed_set_screen_bounds(self): ary = array([5.0, 6.0, 7.0, 8.0, 9.0, 10.0]) ds = ArrayDataSource(ary) r = DataRange1D(ds) mapper = LinearMapper(range=r) self.assertFalse(mapper._low_bound_initialized) self.assertFalse(mapper._high_bound_initialized) mapper.screen_bounds = (100.0, 0.0) self.assertTrue(mapper._low_bound_initialized) self.assertTrue(mapper._high_bound_initialized) result = mapper.map_screen(ary) assert_equal(result , array([100, 80, 60, 40, 20, 0])) return
def test_basic(self): ary = array([5.0, 6.0, 7.0, 8.0, 9.0, 10.0]) ds = ArrayDataSource(ary) r = DataRange1D(ds) mapper = LinearMapper(range=r) self.assertFalse(mapper._low_bound_initialized) self.assertFalse(mapper._high_bound_initialized) mapper.low_pos=50 self.assertTrue(mapper._low_bound_initialized) mapper.high_pos=100 self.assertTrue(mapper._high_bound_initialized) result = mapper.map_screen(ary) assert_equal(result , array([50, 60, 70, 80, 90, 100])) return
def test_reverse_construction(self): mapper = LinearMapper() r = DataRange1D() ds = ArrayDataSource() ary = array([1,2,3,4,5,6,7]) mapper.range = r mapper.low_pos = 1.0 mapper.high_pos = 7.0 r.add(ds) ds.set_data(ary) self.assertTrue(r.low == 1) self.assertTrue(r.high == 7) screen_pts = mapper.map_screen(array([1,3,7])) self.assertTrue(tuple(screen_pts) == (1.0, 3.0, 7.0)) return
def test_piecewise_construction(self): ary = array([1,2,3,4,5,6,7]) ds = ArrayDataSource() ds.set_data(ary) r = DataRange1D() r.add(ds) self.assert_(r.low_setting == "auto") self.assert_(r.high_setting == "auto") self.assert_(r.low == 1) self.assert_(r.high == 7) mapper = LinearMapper() mapper.range = r mapper.low_pos = 1.0 mapper.high_pos = 7.0 screen_pts = mapper.map_screen(array([1,3,7])) self.assert_(tuple(screen_pts) == (1.0, 3.0, 7.0)) return
def setUp(self): self.size = (250, 250) data_source = ArrayDataSource(arange(10)) index_range = DataRange1D() index_range.add(data_source) index_mapper = LinearMapper(range=index_range) self.scatterplot = LineScatterPlot1D( index=data_source, index_mapper=index_mapper, border_visible=False, ) self.scatterplot.outer_bounds = list(self.size)
def create_colorbar(colormap): colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, orientation='v', resizable='v', width=30, padding=20) colorbar.tools.append(RangeSelection(component=colorbar)) colorbar.overlays.append(RangeSelectionOverlay(component=colorbar, border_color="white", alpha=0.8, fill_color="lightgray")) return colorbar
def make_colorbar(self, plot, width=30, padding=20, orientation='v', resizable='v'): cm = gray(DataRange1D()) lm = LinearMapper() colorbar = ColorBar(orientation=orientation, resizable=resizable, width=width, padding=padding, index_mapper=lm, color_mapper=cm) if plot is not None: colorbar.trait_set( index_mapper=LinearMapper(range=plot.color_mapper.range), color_mapper=plot.color_mapper, plot=plot) return colorbar
def drawquiver(self, x1c, y1c, x2c, y2c, color, linewidth=1.0, scale=1.0): """ drawquiver draws multiple lines at once on the screen x1,y1->x2,y2 in the current camera window parameters: x1c - array of x1 coordinates y1c - array of y1 coordinates x2c - array of x2 coordinates y2c - array of y2 coordinates color - color of the line linewidth - linewidth of the line example usage: drawquiver ([100,200],[100,100],[400,400],[300,200],'red',linewidth=2.0) draws 2 red lines with thickness = 2 : 100,100->400,300 and 200,100->400,200 """ x1, y1, x2, y2 = self.remove_short_lines(x1c, y1c, x2c, y2c, min_length=0) if len(x1) > 0: xs = ArrayDataSource(x1) ys = ArrayDataSource(y1) quiverplot = QuiverPlot( index=xs, value=ys, index_mapper=LinearMapper(range=self._plot.index_mapper.range), value_mapper=LinearMapper(range=self._plot.value_mapper.range), origin=self._plot.origin, arrow_size=0, line_color=color, line_width=linewidth, ep_index=np.array(x2) * scale, ep_value=np.array(y2) * scale) self._plot.add(quiverplot) # we need this to track how many quiverplots are in the current # plot self._quiverplots.append(quiverplot)
def test_map_screen_with_null_data_range(self): r = DataRange1D() mapper = LinearMapper(range=r) low_pos = mapper.low_pos data = array([5.6]) result = mapper.map_screen(data) self.assertIsInstance(result, ndarray) self.assertEqual(result.shape, (1, )) assert_array_almost_equal(result, array([low_pos])) # Test support for lists and tuples data = [5.6] result = mapper.map_screen(data) self.assertIsInstance(result, ndarray) self.assertEqual(result.shape, (1, )) assert_array_almost_equal(result, array([low_pos])) data = (5.6, ) result = mapper.map_screen(data) self.assertIsInstance(result, ndarray) self.assertEqual(result.shape, (1, )) assert_array_almost_equal(result, array([low_pos]))
def test_errorbarplot(self): """ Coverage test to check basic case works """ size = (50, 50) x = np.array([1, 2]) y = np.array([5, 10]) errors = np.array([1, 2]) low = ArrayDataSource(y - errors) high = ArrayDataSource(y + errors) errorbar_plot = ErrorBarPlot( index=ArrayDataSource(x), values=ArrayDataSource(y), index_mapper=LinearMapper(range=DataRange1D(low=0, high=3)), value_mapper=LinearMapper(range=DataRange1D(low=0, high=15)), value_low=low, value_high=high, color='blue', line_width=3.0, ) errorbar_plot.outer_bounds = list(size) gc = PlotGraphicsContext(size) gc.render_component(errorbar_plot) actual = gc.bmp_array[:, :, :] self.assertFalse(alltrue(actual == 255))
def setUp(self): self.size = (250, 250) index_data_source = ArrayDataSource(arange(10)) index_range = DataRange1D() index_range.add(index_data_source) index_mapper = LinearMapper(range=index_range) value_data_source = ArrayDataSource(arange(1, 11)) value_range = DataRange1D() value_range.add(value_data_source) value_mapper = LinearMapper(range=value_range) text_data_source = ArrayDataSource( array(["one", "two", "three", "four", "five"])) self.text_plot = TextPlot( index=index_data_source, index_mapper=index_mapper, value=value_data_source, value_mapper=value_mapper, border_visible=False, text=text_data_source, ) self.text_plot.outer_bounds = list(self.size)
def line_plot(self, x, y, new_plot=True): if self.plot is None or new_plot: if isinstance(x, (float, int)): x = [x] if isinstance(y, (float, int)): y = [y] self.plot = LinePlot( index=ArrayDataSource(x), value=ArrayDataSource(y), index_mapper=LinearMapper(range=self.index_range), value_mapper=LinearMapper(range=self.value_range)) self.add(self.plot) else: datax = self.plot.index.get_data() datay = self.plot.value.get_data() nx = hstack((datax, [x])) ny = hstack((datay, [y])) self.plot.index.set_data(nx) self.plot.value.set_data(ny)
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 recompute_colorbar(self, plot): """ Create a colorbar for the image plot provided, and add to plot1_2d_container """ img_renderer = plot.plots["img_cost"][0] colormap = img_renderer.color_mapper # Constant mapper for the color bar so that the colors stay the same # even when different slices are selected-= index_mapper = LinearMapper(range=self.colorbar_range) self.colorbar = ColorBar(index_mapper=index_mapper, color_mapper=colormap, padding_top=plot.padding_top, padding_bottom=plot.padding_bottom, padding_right=20, resizable='v', orientation='v', width=30)
def setUp(self): self.size = (250, 250) data_source = ArrayDataSource(arange(10)) text_data = ArrayDataSource([ 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten' ]) index_range = DataRange1D() index_range.add(data_source) index_mapper = LinearMapper(range=index_range) self.scatterplot = TextPlot1D( index=data_source, index_mapper=index_mapper, value=text_data, border_visible=False, ) self.scatterplot.outer_bounds = list(self.size)
def _figure_image_default(self): plot = Plot(self.plot_data_image, width=100, height=100, padding=8, padding_left=48, padding_bottom=32) plot.img_plot('image', colormap=RdBu_r, name='image') plot.aspect_ratio = 1 plot.index_mapper.domain_limits = (self.imager.get_x_range()[0], self.imager.get_x_range()[1]) plot.value_mapper.domain_limits = (self.imager.get_y_range()[0], self.imager.get_y_range()[1]) plot_fit = Plot(self.plot_data_image, width=100, height=100, padding=8, padding_left=48, padding_bottom=32) plot_fit.img_plot('fit', colormap=RdBu_r, name='fit') plot_fit.aspect_ratio = 1 plot_fit.index_mapper.domain_limits = (self.imager.get_x_range()[0], self.imager.get_x_range()[1]) plot_fit.value_mapper.domain_limits = (self.imager.get_y_range()[0], self.imager.get_y_range()[1]) 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=16, height=320, padding=8, padding_left=32) container = HPlotContainer() container.add(plot) container.add(plot_fit) container.add(colorbar) container.overlays.append(self.image_label) container.tools.append(SaveTool(container)) 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 test_reverse_construction(self): mapper = LinearMapper() r = DataRange1D() ds = ArrayDataSource() ary = array([1, 2, 3, 4, 5, 6, 7]) mapper.range = r mapper.low_pos = 1.0 mapper.high_pos = 7.0 r.add(ds) ds.set_data(ary) self.assertTrue(r.low == 1) self.assertTrue(r.high == 7) screen_pts = mapper.map_screen(array([1, 3, 7])) self.assertTrue(tuple(screen_pts) == (1.0, 3.0, 7.0)) return
def test_piecewise_construction(self): ary = array([1, 2, 3, 4, 5, 6, 7]) ds = ArrayDataSource() ds.set_data(ary) r = DataRange1D() r.add(ds) self.assert_(r.low_setting == "auto") self.assert_(r.high_setting == "auto") self.assert_(r.low == 1) self.assert_(r.high == 7) mapper = LinearMapper() mapper.range = r mapper.low_pos = 1.0 mapper.high_pos = 7.0 screen_pts = mapper.map_screen(array([1, 3, 7])) self.assert_(tuple(screen_pts) == (1.0, 3.0, 7.0)) return
def _rebuild_plot(self): container = self.plot value_range = DataRange1D(low=-1, high=1.) index_range = DataRange1D(self.index_ds, high='track', tracking_amount=24 * 3600 * 365) color_mapper = cmap(range=value_range) # Remove old plots container.remove(*container.components) for val, row in zip(self.value_ds, self.rows): horizon = HorizonPlot( index=self.index_ds, value=val, index_mapper=LinearMapper(range=index_range, stretch_data=False), value_mapper=BandedMapper(range=DataRange1D(val)), color_mapper=cmap(range=DataRange1D(val)), #color_mapper, negative_bands=False, ) horizon.tools.append( PanTool(horizon, constrain=True, constrain_direction="x")) horizon.overlays.append( PlotLabel(component=horizon, hjustify='right', text=row, overlay_position='outside left')) container.add(horizon) bottom_axis = PlotAxis( horizon, orientation="bottom", tick_generator=ScalesTickGenerator(scale=CalendarScaleSystem())) container.overlays = [bottom_axis] container.request_redraw()
def create_plot(self): # Create the mapper, etc self._image_index = GridDataSource(array([]), array([]), sort_order=("ascending","ascending")) image_index_range = DataRange2D(self._image_index) self._image_index.on_trait_change(self._metadata_changed, "metadata_changed") self._image_value = ImageData(data=array([]), value_depth=1) image_value_range = DataRange1D(self._image_value) # Create the contour plots self.polyplot = ContourPolyPlot(index=self._image_index, value=self._image_value, index_mapper=GridMapper(range= image_index_range), color_mapper=\ self._cmap(image_value_range), levels=self.num_levels) self.lineplot = ContourLinePlot(index=self._image_index, value=self._image_value, index_mapper=GridMapper(range= self.polyplot.index_mapper.range), levels=self.num_levels) # Add a left axis to the plot left = PlotAxis(orientation='left', title= "y", mapper=self.polyplot.index_mapper._ymapper, component=self.polyplot) self.polyplot.overlays.append(left) # Add a bottom axis to the plot bottom = PlotAxis(orientation='bottom', title= "x", mapper=self.polyplot.index_mapper._xmapper, component=self.polyplot) self.polyplot.overlays.append(bottom) # Add some tools to the plot self.polyplot.tools.append(PanTool(self.polyplot, constrain_key="shift")) self.polyplot.overlays.append(ZoomTool(component=self.polyplot, tool_mode="box", always_on=False)) self.polyplot.overlays.append(LineInspector(component=self.polyplot, axis='index_x', inspect_mode="indexed", write_metadata=True, is_listener=True, color="white")) self.polyplot.overlays.append(LineInspector(component=self.polyplot, axis='index_y', inspect_mode="indexed", write_metadata=True, color="white", is_listener=True)) # Add these two plots to one container contour_container = OverlayPlotContainer(padding=20, use_backbuffer=True, unified_draw=True) contour_container.add(self.polyplot) contour_container.add(self.lineplot) # Create a colorbar cbar_index_mapper = LinearMapper(range=image_value_range) self.colorbar = ColorBar(index_mapper=cbar_index_mapper, plot=self.polyplot, padding_top=self.polyplot.padding_top, padding_bottom=self.polyplot.padding_bottom, padding_right=40, resizable='v', width=30) self.pd = ArrayPlotData(line_index = array([]), line_value = array([]), scatter_index = array([]), scatter_value = array([]), scatter_color = array([])) self.cross_plot = Plot(self.pd, resizable="h") self.cross_plot.height = 100 self.cross_plot.padding = 20 self.cross_plot.plot(("line_index", "line_value"), line_style="dot") self.cross_plot.plot(("scatter_index","scatter_value","scatter_color"), type="cmap_scatter", name="dot", color_mapper=self._cmap(image_value_range), marker="circle", marker_size=8) self.cross_plot.index_range = self.polyplot.index_range.x_range self.pd.set_data("line_index2", array([])) self.pd.set_data("line_value2", array([])) self.pd.set_data("scatter_index2", array([])) self.pd.set_data("scatter_value2", array([])) self.pd.set_data("scatter_color2", array([])) self.cross_plot2 = Plot(self.pd, width = 140, orientation="v", resizable="v", padding=20, padding_bottom=160) self.cross_plot2.plot(("line_index2", "line_value2"), line_style="dot") self.cross_plot2.plot(("scatter_index2","scatter_value2","scatter_color2"), type="cmap_scatter", name="dot", color_mapper=self._cmap(image_value_range), marker="circle", marker_size=8) self.cross_plot2.index_range = self.polyplot.index_range.y_range # Create a container and add components self.container = HPlotContainer(padding=40, fill_padding=True, bgcolor = "white", use_backbuffer=False) inner_cont = VPlotContainer(padding=0, use_backbuffer=True) inner_cont.add(self.cross_plot) inner_cont.add(contour_container) self.container.add(self.colorbar) self.container.add(inner_cont) self.container.add(self.cross_plot2)
def create_plot_component(self):# Create a scalar field to colormap # Create the plot self.pd = ArrayPlotData() self.pd.set_data("imagedata", self.fxydata()) plot = Plot(self.pd) cmap = default_colormaps.color_map_name_dict[self.colormap] if self.rev_cmap: cmap = default_colormaps.reverse(cmap) img_plot = plot.img_plot("imagedata", xbounds = self.xbounds, ybounds = self.ybounds, colormap=cmap, )[0] # Tweak some of the plot properties plot.title = self.title 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) csr = CursorTool(img_plot, drag_button='left', color='white', line_width=2.0 ) self.cursor = csr csr.current_position = np.mean(self.xbounds), np.mean(self.ybounds) img_plot.overlays.append(csr) 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) 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 + 10 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="transparent",) container.overlays.append(overlay) #self.plot = plot self.plot = container
def __init__(self, smaps, *args, **kwargs): super(MyPlot, self).__init__(*args, **kwargs) indexdata = [] startdata = [] stopdata = [] lastval = 0 for mem in smaps: if mem.size != 0: print mem.canread, mem.canwrite indexdata.append(mem.canread << 0 | mem.canwrite << 1 | mem.isprivate << 2) startdata.append(lastval) stopdata.append(lastval + mem.size) lastval += mem.size print mem.size indexsrc = ArrayDataSource(data=indexdata) startsrc = ArrayDataSource(data=startdata) stopsrc = ArrayDataSource(data=stopdata) idxrange = [min(indexdata), max(indexdata)] valrange = [min(startdata), max(stopdata)] indexmapper = LinearMapper( range=DataRange1D(ArrayDataSource(idxrange))) valuemapper = LinearMapper( range=DataRange1D(ArrayDataSource(valrange))) barlist = [] barlist.append( self.drawBar(indexsrc, indexmapper, startsrc, valuemapper, 0xc09090, stopsrc)) #barlist.append(self.drawBar(indexsrc, indexmapper, rsssrc, valuemapper, 0xffa0a0)) #barlist.append(self.drawBar(idxs, indexmapper, start, valuemapper, 0x0000ff, stop)) bottom_axis = PlotAxis(barlist[0], orientation='bottom', tick_label_formatter=lambda x: str(x)) barlist[0].underlays.append(bottom_axis) modelist = [] for i in range(8): mstr = "" mstr += ['r', '-'][i & 1 == 0] mstr += ['w', '-'][i & 2 == 0] mstr += ['p', 's'][i & 4 == 0] modelist.append(mstr) vaxis1 = LabelAxis(barlist[0], orientation='left', title="Mode", positions=range(len(modelist)), labels=modelist, tick_interval=1) #vaxis2 = LabelAxis(barlist[0], orientation='right', # title="Map Name", # positions = range(idx), # labels=["%s" % os.path.basename(x) for x in namedata]) barlist[0].underlays.append(vaxis1) #barlist[0].underlays.append(vaxis2) barlist[0].tools.append(ZoomTool(barlist[0])) barlist[0].tools.append(PanTool(barlist[0])) #add_default_axes(plot, orientation = 'v') add_default_grids(barlist[0], orientation='v') container = OverlayPlotContainer(bgcolor="white") for p in barlist: p.padding = [200, 200, 20, 30] p.bgcolor = "white" container.add(p) self.plot = 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=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
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/%(row)d/%(col)d.png' ) color_range = DataRange1D(color_ds, low_setting=0) #, high_setting=max_pop) 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 data and datasource objects numpoints = 500 index = arange(numpoints) returns = random.lognormal(0.01, 0.1, size=numpoints) price = 100.0 * cumprod(returns) volume = abs(random.normal(1000.0, 1500.0, size=numpoints) + 2000.0) time_ds = ArrayDataSource(index) vol_ds = ArrayDataSource(volume, sort_order="none") price_ds = ArrayDataSource(price, sort_order="none") xmapper = LinearMapper(range=DataRange1D(time_ds)) vol_mapper = LinearMapper(range=DataRange1D(vol_ds)) price_mapper = LinearMapper(range=DataRange1D(price_ds)) price_plot = FilledLinePlot(index=time_ds, value=price_ds, index_mapper=xmapper, value_mapper=price_mapper, edge_color="blue", face_color="paleturquoise", alpha=0.5, bgcolor="white", border_visible=True) add_default_grids(price_plot) price_plot.overlays.append(PlotAxis(price_plot, orientation='left')) price_plot.overlays.append(PlotAxis(price_plot, orientation='bottom')) price_plot.tools.append( PanTool(price_plot, constrain=True, constrain_direction="x")) price_plot.overlays.append( ZoomTool(price_plot, drag_button="right", always_on=True, tool_mode="range", axis="index")) vol_plot = BarPlot(index=time_ds, value=vol_ds, index_mapper=xmapper, value_mapper=vol_mapper, line_color="transparent", fill_color="black", bar_width=1.0, bar_width_type="screen", antialias=False, height=100, resizable="h", bgcolor="white", border_visible=True) add_default_grids(vol_plot) vol_plot.underlays.append(PlotAxis(vol_plot, orientation='left')) vol_plot.tools.append( PanTool(vol_plot, constrain=True, constrain_direction="x")) container = VPlotContainer(bgcolor="lightblue", spacing=20, padding=50, fill_padding=False) container.add(vol_plot) container.add(price_plot) container.overlays.append( PlotLabel( "Financial Plot", component=container, #font="Times New Roman 24")) font="Arial 24")) return container
def _create_plot(self): plot_data = ArrayPlotData(image=self.image) plot = Plot(plot_data, width=500, height=500, resizable='hv', aspect_ratio=1.0, padding=8, padding_left=32, padding_bottom=32) plot.img_plot('image', colormap=jet, xbounds=(self.X[0], self.X[-1]), ybounds=(self.Y[0], self.Y[-1]), name='image') image = plot.plots['image'][0] bwplot_data = ArrayPlotData(bwimage=self.bwimage) bwplot = Plot(bwplot_data, width=500, height=500, resizable='hv', aspect_ratio=1.0, padding=8, padding_left=32, padding_bottom=32) bwplot.img_plot('bwimage', colormap=jet, xbounds=(self.X[0], self.X[-1]), ybounds=(self.Y[0], self.Y[-1]), name='bwimage') bwimage = bwplot.plots['bwimage'][0] image.x_mapper.domain_limits = (self.confocal.scanner.getXRange()[0], self.confocal.scanner.getXRange()[1]) image.y_mapper.domain_limits = (self.confocal.scanner.getYRange()[0], self.confocal.scanner.getYRange()[1]) bwimage.x_mapper.domain_limits = (self.confocal.scanner.getXRange()[0], self.confocal.scanner.getXRange()[1]) bwimage.y_mapper.domain_limits = (self.confocal.scanner.getYRange()[0], self.confocal.scanner.getYRange()[1]) colormap = image.color_mapper colorbar = ColorBar(index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=plot, orientation='v', resizable='v', width=16, height=320, padding=8, padding_left=32) container = HPlotContainer() container.add(plot) container.add(colorbar) container.add(bwplot) container.tools.append(SaveTool(container)) self.plot_data = plot_data self.scan_plot = image self.figure = plot self.bwplot_data = bwplot_data self.bwscan_plot = bwimage self.bwfigure = bwplot self.figure_container = 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 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 list(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 list(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 new_series(self, x=None, y=None, plotid=0, **kw): ''' ''' plot, scatter, _line = super(ResidualsGraph, self).new_series(x=x, y=y, plotid=plotid, **kw) for underlay in plot.underlays: if underlay.orientation == 'bottom': underlay.visible = False underlay.padding_bottom = 0 plot.padding_bottom = 0 x, y, res = self.calc_residuals(plotid=plotid) ressplit = self._split_residual(x, res) resneg = ArrayDataSource(ressplit[1]) xneg = ArrayDataSource(ressplit[0]) respos = ArrayDataSource(ressplit[3]) xpos = ArrayDataSource(ressplit[2]) yrange = DataRange1D(ArrayDataSource(res)) ymapper = LinearMapper(range=yrange) container = self._container_factory(type='o', padding=[50, 15, 0, 30], height=75, resizable='h') bar = BarPlot( index=xneg, value=resneg, index_mapper=scatter.index_mapper, value_mapper=ymapper, bar_width=0.2, line_color='blue', fill_color='blue', border_visible=True, ) # left_axis = PlotAxis(bar, orientation = 'left') # bottom_axis=PlotAxis(bar,orientaiton='bottom') kw = dict(vtitle='residuals') if self.xtitle: kw['htitle'] = self.xtitle add_default_axes(bar, **kw) hgrid = PlotGrid(mapper=ymapper, component=bar, orientation='horizontal', line_color='lightgray', line_style='dot') bar.underlays.append(hgrid) # bar.underlays.append(left_axis) # bar.underlays.append(bottom_axis) bar2 = BarPlot( index=xpos, value=respos, index_mapper=scatter.index_mapper, value_mapper=ymapper, bar_width=0.2, line_color='green', fill_color='green', # bgcolor = 'green', resizable='hv', border_visible=True, # padding = [30, 5, 0, 30] ) bar2.overlays.append(GuideOverlay(bar2, value=0, color=(0, 0, 0))) bar2.underlays.append(hgrid) container.add(bar) container.add(bar2) # container.add(PlotLabel('foo')) self.residual_plots = [bar, bar2] self.plotcontainer.add(container)
def __init__(self, x, y, z): super(ImagePlot, self).__init__() self.pd_all = ArrayPlotData(imagedata=z) #self.pd_horiz = ArrayPlotData(x=x, horiz=z[4, :]) #self.pd_vert = ArrayPlotData(y=y, vert=z[:,5]) self._imag_index = GridDataSource(xdata=x, ydata=y, sort_order=("ascending", "ascending")) index_mapper = GridMapper(range=DataRange2D(self._imag_index)) self._imag_index.on_trait_change(self._metadata_changed, "metadata_changed") self._image_value = ImageData(data=z, value_depth=1) color_mapper = jet(DataRange1D(self._image_value)) self.color_plot = CMapImagePlot(index=self._imag_index, index_mapper=index_mapper, value=self._image_value, value_mapper=color_mapper, padding=20, use_backbuffer=True, unified_draw=True) #Add axes to image plot left = PlotAxis(orientation='left', title="Frequency (GHz)", mapper=self.color_plot.index_mapper._ymapper, component=self.color_plot) self.color_plot.overlays.append(left) bottom = PlotAxis(orientation='bottom', title="Time (us)", mapper=self.color_plot.index_mapper._xmapper, component=self.color_plot) self.color_plot.overlays.append(bottom) self.color_plot.tools.append( PanTool(self.color_plot, constrain_key="shift")) self.color_plot.overlays.append( ZoomTool(component=self.color_plot, tool_mode="box", always_on=False)) #Add line inspector tool for horizontal and vertical self.color_plot.overlays.append( LineInspector(component=self.color_plot, axis='index_x', inspect_mode="indexed", write_metadata=True, is_listener=True, color="white")) self.color_plot.overlays.append( LineInspector(component=self.color_plot, axis='index_y', inspect_mode="indexed", write_metadata=True, color="white", is_listener=True)) myrange = DataRange1D(low=amin(z), high=amax(z)) cmap = jet self.colormap = cmap(myrange) # Create a colorbar cbar_index_mapper = LinearMapper(range=myrange) self.colorbar = ColorBar(index_mapper=cbar_index_mapper, plot=self.color_plot, padding_top=self.color_plot.padding_top, padding_bottom=self.color_plot.padding_bottom, padding_right=40, resizable='v', width=30) #, ytitle="Magvec (mV)") #create horizontal line plot self.horiz_cross_plot = Plot(self.pd_horiz, resizable="h") self.horiz_cross_plot.height = 100 self.horiz_cross_plot.padding = 20 self.horiz_cross_plot.plot(("x", "horiz")) #, #line_style="dot") # self.cross_plot.plot(("scatter_index","scatter_value","scatter_color"), # type="cmap_scatter", # name="dot", # color_mapper=self._cmap(image_value_range), # marker="circle", # marker_size=8) self.horiz_cross_plot.index_range = self.color_plot.index_range.x_range #create vertical line plot self.vert_cross_plot = Plot(self.pd_vert, width=140, orientation="v", resizable="v", padding=20, padding_bottom=160) self.vert_cross_plot.plot(("y", "vert")) #, # line_style="dot") # self.vert_cross_plot.xtitle="Magvec (mV)" # self.vertica_cross_plot.plot(("vertical_scatter_index", # "vertical_scatter_value", # "vertical_scatter_color"), # type="cmap_scatter", # name="dot", # color_mapper=self._cmap(image_value_range), # marker="circle", # marker_size=8) self.vert_cross_plot.index_range = self.color_plot.index_range.y_range # Create a container and add components self.container = HPlotContainer(padding=40, fill_padding=True, bgcolor="white", use_backbuffer=False) inner_cont = VPlotContainer(padding=0, use_backbuffer=True) inner_cont.add(self.horiz_cross_plot) inner_cont.add(self.color_plot) self.container.add(self.colorbar) self.container.add(inner_cont) self.container.add(self.vert_cross_plot)
def create_gridded_scatter_plot(x, y, orientation="h", color="red", width=1.0, fill_color="red", marker="square", marker_size=2, value_mapper_class=LinearMapper, padding=30): assert len(x) == len(y) # If you know it is monotonically increasing, sort_order can # be set to 'ascending' index = ArrayDataSource(x, sort_order='none') value = ArrayDataSource(y, sort_order="none") index_range = DataRange1D(tight_bounds=False) index_range.add(index) index_mapper = LinearMapper(range=index_range) value_range = DataRange1D(tight_bounds=False) value_range.add(value) value_mapper = value_mapper_class(range=value_range) plot = ScatterPlot( index=index, value=value, index_mapper=index_mapper, value_mapper=value_mapper, orientation=orientation, color=color, fill_color=fill_color, marker=marker, marker_size=marker_size, padding=[40, 15, 15, 20], # left, right, top, bottom border_visible=True, border_width=1, bgcolor="white", use_backbuffer=True, backbuffer_padding=False, unified_draw=True, draw_layer="plot", overlay_border=True) vertical_grid = PlotGrid(component=plot, mapper=index_mapper, orientation='vertical', line_color="gray", line_style='dot', use_draw_order=True) horizontal_grid = PlotGrid(component=plot, mapper=value_mapper, orientation='horizontal', line_color="gray", line_style='dot', use_draw_order=True) vertical_axis = PlotAxis(orientation='left', mapper=plot.value_mapper, use_draw_order=True) horizontal_axis = PlotAxis(orientation='bottom', title='Time (s)', mapper=plot.index_mapper, use_draw_order=True) plot.underlays.append(vertical_grid) plot.underlays.append(horizontal_grid) # Have to add axes to overlays because we are backbuffering the main plot, # and only overlays get to render in addition to the backbuffer. plot.overlays.append(vertical_axis) plot.overlays.append(horizontal_axis) return plot
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