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 create_timechart_container(project): """ create a vplotcontainer which connects all the inside plots to synchronize their index_range """ # find index limits low = 1<<64 high = 0 for i in xrange(len(project.c_states)): if len(project.c_states[i].start_ts): low = min(low,project.c_states[i].start_ts[0]) high = max(high,project.c_states[i].end_ts[-1]) if len(project.p_states[i].start_ts): low = min(low,project.p_states[i].start_ts[0]) high = max(high,project.p_states[i].start_ts[-1]) for tc in project.processes: if len(tc.start_ts): low = min(low,tc.start_ts[0]) high = max(high,tc.end_ts[-1]) project.process_stats(low,high) if low > high: low=0 high=1 # we have the same x_mapper/range for each plots index_range = DataRange1D(low=low, high=high) index_mapper = LinearMapper(range=index_range,domain_limit=(low,high)) value_range = DataRange1D(low=0, high=project.num_cpu*2+project.num_process) value_mapper = LinearMapper(range=value_range,domain_limit=(0,project.num_cpu*2+project.num_process)) index = ArrayDataSource(array((low,high)), sort_order="ascending") plot = tcPlot(index=index, proj=project, bgcolor="white",padding=(0,0,0,40), use_backbuffer = True, fill_padding = True, value_mapper = value_mapper, index_mapper=index_mapper, line_color="black", render_style='hold', line_width=1) plot.lowest_i = low plot.highest_i = high project.on_trait_change(plot.invalidate, "plot_redraw") project.on_trait_change(plot.invalidate, "selected") max_process = 50 if value_range.high>max_process: value_range.low = value_range.high-max_process # Attach some tools plot.tools.append(tools.myPanTool(plot,drag_button='left')) zoom = tools.myZoomTool(component=plot, tool_mode="range", always_on=True,axis="index",drag_button=None, zoom_to_mouse=True,x_max_zoom_factor=float("inf"),x_min_zoom_factor=float("-inf")) plot.tools.append(zoom) plot.range_selection = tools.myRangeSelection(plot,resize_margin=3) plot.tools.append(plot.range_selection) plot.overlays.append(RangeSelectionOverlay(component=plot,axis="index",use_backbuffer=True)) axe = PlotAxis(orientation='bottom',title='time',mapper=index_mapper,component=plot) plot.underlays.append(axe) plot.options.connect(plot) plot.range_tools.connect(plot) return plot
def _create_TracePlot_component(self): plot = DataView(border_visible=True) line = LinePlot(value=ArrayDataSource(self.Trace), index=ArrayDataSource(numpy.arange(len(self.Trace))), color='blue', index_mapper=LinearMapper(range=plot.index_range), value_mapper=LinearMapper(range=plot.value_range)) plot.index_range.sources.append(line.index) plot.value_range.sources.append(line.value) plot.add(line) plot.index_axis.title = 'index' plot.value_axis.title = 'Fluorescence [ counts / s ]' plot.tools.append(PanTool(plot)) plot.overlays.append(ZoomTool(plot)) self.TraceLine = line return plot
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.assert_(r.low == 1) self.assert_(r.high == 7) screen_pts = mapper.map_screen(array([1,3,7])) self.assert_(tuple(screen_pts) == (1.0, 3.0, 7.0)) return
def _create_colorbar(self): cmap = self.plot.color_mapper self._colorbar = ColorBar(index_mapper=LinearMapper(range=cmap.range), color_mapper=cmap, orientation='v', resizable='v', width=30, padding=30)
def __init__(self, **kwargs): super(VariableMeshPannerView, self).__init__(**kwargs) # Create the plot self.add_trait("field", DelegatesTo("vm_plot")) plot = self.vm_plot.plot img_plot = self.vm_plot.img_plot if self.use_tools: plot.tools.append(PanTool(img_plot)) zoom = ZoomTool(component=img_plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) imgtool = ImageInspectorTool(img_plot) img_plot.tools.append(imgtool) overlay = ImageInspectorOverlay(component=img_plot, image_inspector=imgtool, bgcolor="white", border_visible=True) img_plot.overlays.append(overlay) image_value_range = DataRange1D(self.vm_plot.fid) cbar_index_mapper = LinearMapper(range=image_value_range) self.colorbar = ColorBar(index_mapper=cbar_index_mapper, plot=img_plot, padding_right=40, resizable='v', width=30) self.colorbar.tools.append( PanTool(self.colorbar, constrain_direction="y", constrain=True)) zoom_overlay = ZoomTool(self.colorbar, axis="index", tool_mode="range", always_on=True, drag_button="right") self.colorbar.overlays.append(zoom_overlay) # create a range selection for the colorbar range_selection = RangeSelection(component=self.colorbar) self.colorbar.tools.append(range_selection) self.colorbar.overlays.append( RangeSelectionOverlay(component=self.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(img_plot) self.full_container = HPlotContainer(padding=30) self.container = OverlayPlotContainer(padding=0) self.full_container.add(self.colorbar) self.full_container.add(self.container) self.container.add(self.vm_plot.plot)
def _create_HistPlot_component(self): plot = DataView(border_visible=True) line = LinePlot( index=ArrayDataSource(self.HistogramBins), value=ArrayDataSource(self.HistogramN), color='blue', #fill_color='blue', index_mapper=LinearMapper(range=plot.index_range), value_mapper=LinearMapper(range=plot.value_range)) plot.index_range.sources.append(line.index) plot.value_range.sources.append(line.value) plot.add(line) plot.index_axis.title = 'Fluorescence counts' plot.value_axis.title = 'number of occurences' plot.tools.append(PanTool(plot)) plot.overlays.append(ZoomTool(plot)) self.HistLine = line return plot
def draw_colorbar(self): scatplot = self.scatplot cmap_renderer = scatplot.plots["my_plot"][0] selection = ColormappedSelectionOverlay(cmap_renderer, fade_alpha=0.35, selection_type="range") cmap_renderer.overlays.append(selection) if self.thresh is not None: cmap_renderer.color_data.metadata['selections'] = self.thresh cmap_renderer.color_data.metadata_changed = { 'selections': self.thresh } # Create the colorbar, handing in the appropriate range and colormap colormap = scatplot.color_mapper colorbar = ColorBar( index_mapper=LinearMapper(range=DataRange1D(low=0.0, high=1.0)), orientation='v', resizable='v', width=30, padding=20) colorbar_selection = RangeSelection(component=colorbar) colorbar.tools.append(colorbar_selection) ovr = colorbar.overlays.append( RangeSelectionOverlay(component=colorbar, border_color="white", alpha=0.8, fill_color="lightgray", metadata_name='selections')) #ipshell('colorbar, colorbar_selection and ovr available:') self.cbar_selection = colorbar_selection self.cmap_renderer = cmap_renderer colorbar.plot = cmap_renderer colorbar.padding_top = scatplot.padding_top colorbar.padding_bottom = scatplot.padding_bottom self.colorbar = colorbar return colorbar
def _create_plot_component(self): # Create a plot data object and give it this data self.pd = ArrayPlotData() self.pd.set_data("imagedata", self.data[self.data_name]) # Create the plot self.tplot = Plot(self.pd, default_origin="top left") self.tplot.x_axis.orientation = "top" self.tplot.img_plot( "imagedata", name="my_plot", #xbounds=(0,10), #ybounds=(0,10), colormap=jet) # Tweak some of the plot properties self.tplot.title = "Matrix" self.tplot.padding = 50 # Right now, some of the tools are a little invasive, and we need the # actual CMapImage object to give to them self.my_plot = self.tplot.plots["my_plot"][0] # Attach some tools to the plot self.tplot.tools.append(PanTool(self.tplot)) zoom = ZoomTool(component=self.tplot, tool_mode="box", always_on=False) self.tplot.overlays.append(zoom) # my custom tool to get the connection information self.custtool = CustomTool(self.tplot) self.tplot.tools.append(self.custtool) # Create the colorbar, handing in the appropriate range and colormap colormap = self.my_plot.color_mapper self.colorbar = ColorBar( index_mapper=LinearMapper(range=colormap.range), color_mapper=colormap, plot=self.my_plot, orientation='v', resizable='v', width=30, padding=20) self.colorbar.padding_top = self.tplot.padding_top self.colorbar.padding_bottom = self.tplot.padding_bottom # create a range selection for the colorbar self.range_selection = RangeSelection(component=self.colorbar) self.colorbar.tools.append(self.range_selection) self.colorbar.overlays.append( RangeSelectionOverlay(component=self.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 self.range_selection.listeners.append(self.my_plot) # Create a container to position the plot and the colorbar side-by-side container = HPlotContainer(use_backbuffer=True) container.add(self.tplot) container.add(self.colorbar) container.bgcolor = "white" return container
def __init__(self,xdata=None,ydata=None,weights=None,model=None, include_models=None,exclude_models=None,fittype=None,**traits): """ :param xdata: the first dimension of the data to be fit :type xdata: array-like :param ydata: the second dimension of the data to be fit :type ydata: array-like :param weights: The weights to apply to the data. Statistically interpreted as inverse errors (*not* inverse variance). May be any of the following forms: * None for equal weights * an array of points that must match `ydata` * a 2-sequence of arrays (xierr,yierr) such that xierr matches the `xdata` and yierr matches `ydata` * a function called as f(params) that returns an array of weights that match one of the above two conditions :param model: the initial model to use to fit this data :type model: None, string, or :class:`pymodelfit.core.FunctionModel1D` instance. :param include_models: With `exclude_models`, specifies which models should be available in the "new model" dialog (see `models.list_models` for syntax). :param exclude_models: With `include_models`, specifies which models should be available in the "new model" dialog (see `models.list_models` for syntax). :param fittype: The fitting technique for the initial fit (see :class:`pymodelfit.core.FunctionModel`). :type fittype: string kwargs are passed in as any additional traits to apply to the application. """ self.modelpanel = View(Label('empty'),kind='subpanel',title='model editor') self.tmodel = TraitedModel(model) if model is not None and fittype is not None: self.tmodel.model.fittype = fittype if xdata is None or ydata is None: if not hasattr(self.tmodel.model,'data') or self.tmodel.model.data is None: raise ValueError('data not provided and no data in model') if xdata is None: xdata = self.tmodel.model.data[0] if ydata is None: ydata = self.tmodel.model.data[1] if weights is None: weights = self.tmodel.model.data[2] self.on_trait_change(self._paramsChanged,'tmodel.paramchange') self.modelselector = NewModelSelector(include_models,exclude_models) self.data = [xdata,ydata] if weights is None: self.weights = np.ones_like(xdata) self.weighttype = 'equal' else: self.weights = np.array(weights,copy=True) self.savews = True weights1d = self.weights while len(weights1d.shape)>1: weights1d = np.sum(weights1d**2,axis=0) pd = ArrayPlotData(xdata=self.data[0],ydata=self.data[1],weights=weights1d) self.plot = plot = Plot(pd,resizable='hv') self.scatter = plot.plot(('xdata','ydata','weights'),name='data', color_mapper=_cmapblack if self.weights0rem else _cmap, type='cmap_scatter', marker='circle')[0] self.errorplots = None if not isinstance(model,FunctionModel1D): self.fitmodel = True self.updatemodelplot = False #force plot update - generates xmod and ymod plot.plot(('xmod','ymod'),name='model',type='line',line_style='dash',color='black',line_width=2) del plot.x_mapper.range.sources[-1] #remove the line plot from the x_mapper source so only the data is tied to the scaling self.on_trait_change(self._rangeChanged,'plot.index_mapper.range.updated') self.pantool = PanTool(plot,drag_button='left') plot.tools.append(self.pantool) self.zoomtool = ZoomTool(plot) self.zoomtool.prev_state_key = KeySpec('a') self.zoomtool.next_state_key = KeySpec('s') plot.overlays.append(self.zoomtool) self.scattertool = None self.scatter.overlays.append(ScatterInspectorOverlay(self.scatter, hover_color = "black", selection_color="black", selection_outline_color="red", selection_line_width=2)) self.colorbar = colorbar = ColorBar(index_mapper=LinearMapper(range=plot.color_mapper.range), color_mapper=plot.color_mapper.range, plot=plot, orientation='v', resizable='v', width = 30, padding = 5) colorbar.padding_top = plot.padding_top colorbar.padding_bottom = plot.padding_bottom colorbar._axis.title = 'Weights' self.plotcontainer = container = HPlotContainer(use_backbuffer=True) container.add(plot) container.add(colorbar) super(FitGui,self).__init__(**traits) self.on_trait_change(self._scale_change,'plot.value_scale,plot.index_scale') if weights is not None and len(weights)==2: self.weightsChanged() #update error bars
def setup_plots(self): ''' Args: Returns: Raises: ''' ext = self.extension if ext == "S2": color = "green" else: color = "blue" self.create_plot("AAE " + ext, ylabel="[ ]", color=color) self.create_plot("ARE " + ext, ylabel="[ ]", color=color) self.create_plot("Jerk " + ext, ylabel="[m/s2/s]", color=color) self.create_plot("SI " + ext, ylabel="[ ]", color=color) self.create_plot("VI " + ext, ylabel="[ ]", color=color) p = self.plots["VI " + ext] null_ds = ArrayDataSource([]) self.time_plot = LinePlot( index=self.time_src, value=null_ds, index_mapper=LinearMapper(range=DataRange1D(self.time_src)), value_mapper=LinearMapper(range=DataRange1D(null_ds)), color="black", border_visible=True, bgcolor="white", height=10, resizable="h", padding_top=50, padding_bottom=40, padding_left=50, padding_right=20) self.ticker = ScalesTickGenerator() self.x_axis = LabelAxis(self.time_plot, orientation="bottom", title="Time [sec]", label_rotation=0) #self.x_axis = PlotAxis(self.time_plot, orientation="bottom", tick_generator = self.ticker, title="Time [sec]") self.time_plot.underlays.append(self.x_axis) self.container.add(self.time_plot) # Add a range overlay to the miniplot that is hooked up to the range # of the main price_plot range_tool = RangeSelection(self.time_plot) self.time_plot.tools.append(range_tool) range_overlay = RangeSelectionOverlay(self.time_plot, metadata_name="selections") self.time_plot.overlays.append(range_overlay) range_tool.on_trait_change(self._range_selection_handler, "selection") self.range_tool = range_tool p.plot_conactory.index_range.on_trait_change(self._plot_range_handler, "updated") self.zoom_overlay = ZoomOverlay(source=self.time_plot, destination=p.plot_conactory) self.container.overlays.append(self.zoom_overlay)