def initialiseData(self): """sets up data arrays and fills arrayPlotData """ self.currentPosition = 0 self.xs = scipy.linspace(0.0, self.numberOfPoints * self.resolution, self.numberOfPoints) self.cursorXS = self.getCurrentPositionArray() self.cursorVertical = scipy.array([self.verticalLimit, 0.0]) self.array0 = scipy.zeros(self.numberOfPoints) self.array1 = scipy.zeros(self.numberOfPoints) self.array2 = scipy.zeros(self.numberOfPoints) self.array3 = scipy.zeros(self.numberOfPoints) self.array4 = scipy.zeros(self.numberOfPoints) self.array5 = scipy.zeros(self.numberOfPoints) self.array6 = scipy.zeros(self.numberOfPoints) self.array7 = scipy.zeros(self.numberOfPoints) self.channels = [ self.array0, self.array1, self.array2, self.array3, self.array4, self.array5, self.array6, self.array7 ] self.arrayPlotData = chaco.ArrayPlotData( xs=self.xs, channel0=self.array0, channel1=self.array1, channel2=self.array2, channel3=self.array3, channel4=self.array4, channel5=self.array5, channel6=self.array6, channel7=self.array7, cursorXS=self.cursorXS, cursorVertical=self.cursorVertical ) #will be the ArrayPlotData We need
def change_plot(self, indices, x_scale=None, y_scale=None): global XY_DATA self.plot_indices = indices self.container = self.create_container() self.high_step = 1 #float(max(self.plot_data[0][:, 0])) self.low_step = 0 self.container.data = capi.ArrayPlotData() self.time_data_labels = {} if len(indices) == 0: return self._refresh = 1 XY_DATA = [] x_scale, y_scale = self.get_axis_scales(x_scale, y_scale) # loop through plot data and plot it overlays_plotted = False fnams = [] for d in range(len(self.plot_data)): if not self.runs_shown[d]: continue # The legend entry for each file is one of the following forms: # 1) [file basename] VAR # 2) [file basename:] VAR variables # depending on if variabes were perturbed for this run. variables = self.variables[d] if len(variables) > 30: variables = ", ".join(variables.split(",")[:-1]) if variables: variables = ": {0}".format(variables) self.time_data_labels[d] = [] ti = self.find_time_index() mheader = self._mheader() xname = mheader[self.x_idx] self.y_idx = getidx(mheader, mheader[indices[0]]) # indices is an integer list containing the columns of the data to # be plotted. The indices are wrt to the FIRST file in parsed, not # necessarily the same for every file. Here, we loop through the # indices, determine the name from the first file's header and # find the x and y index in the file of interest fnam, header = self.get_info(d) if fnam in fnams: fnam += "-{0}".format(len(fnams)) fnams.append(fnam) for i, idx in enumerate(indices): yname = mheader[idx] # get the indices for this file xp_idx = getidx(header, xname) yp_idx = getidx(header, yname) if xp_idx is None or yp_idx is None: continue # tjfulle: x and y should always be x and disp, z is the color x = self.plot_data[d][:, xp_idx] * x_scale y = self.plot_data[d][:, yp_idx] * y_scale z = self.plot_data[d][:, yp_idx] if self.nfiles() - 1 or self.overlay_plot_data: entry = "({0}) {1}{2}".format(fnam, yname, variables) else: entry = "{0} {1}".format(yname, variables) self.create_plot(x, y, z, entry) XY_DATA.append( Namespace(key=fnam, xname=xname, x=x, yname=yname, y=y, lw=1)) # create point marker xp = self.plot_data[d][ti, xp_idx] * x_scale yp = self.plot_data[d][ti, yp_idx] * y_scale #self.create_data_label(xp, yp, d, yp_idx) if not overlays_plotted: # plot the overlay data overlays_plotted = True ii = i + 1 for fnam, head in self.overlay_headers.items(): # get the x and y indeces corresponding to what is # being plotted xo_idx = getidx(head, xname) yo_idx = getidx(head, yname) if xo_idx is None or yo_idx is None: continue xo = self.overlay_plot_data[fnam][:, xo_idx] * x_scale zo = self.overlay_plot_data[fnam][:, yo_idx] * y_scale # legend entry entry = "({0}) {1}".format(fnam, head[yo_idx]) _i = d + len(self.plot_data) + 3 self.create_plot(xo, y, zo, entry) XY_DATA.append( Namespace(key=fnam, xname=xname, x=xo, yname=yname, y=yo, lw=3)) ii += 1 continue capi.add_default_grids(self.container) capi.add_default_axes(self.container, htitle=mheader[self.x_idx]) self.container.index_range.tight_bounds = False self.container.index_range.refresh() self.container.value_range.tight_bounds = False self.container.value_range.refresh() self.container.tools.append(ctapi.PanTool(self.container)) zoom = ctapi.ZoomTool(self.container, tool_mode="box", always_on=False) self.container.overlays.append(zoom) dragzoom = ctapi.DragZoom(self.container, drag_button="right") self.container.tools.append(dragzoom) self.container.legend.visible = True self.container.invalidate_and_redraw() return
def create_plot(self): # Create the mapper, etc self._image_index = chaco.GridDataSource(scipy.array([]), scipy.array([]), sort_order=("ascending", "ascending")) image_index_range = chaco.DataRange2D(self._image_index) self._image_index.on_trait_change(self._metadata_changed, "metadata_changed") self._image_value = chaco.ImageData(data=scipy.array([]), value_depth=1) image_value_range = chaco.DataRange1D(self._image_value) # Create the contour plots #self.polyplot = ContourPolyPlot(index=self._image_index, self.polyplot = chaco.CMapImagePlot( index=self._image_index, value=self._image_value, index_mapper=chaco.GridMapper(range=image_index_range), color_mapper=self._cmap(image_value_range)) # Add a left axis to the plot left = chaco.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 = chaco.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( tools.PanTool(self.polyplot, constrain_key="shift", drag_button="middle")) self.polyplot.overlays.append( tools.ZoomTool(component=self.polyplot, tool_mode="box", always_on=False)) self.lineInspectorX = clickableLineInspector.ClickableLineInspector( component=self.polyplot, axis='index_x', inspect_mode="indexed", write_metadata=True, is_listener=False, color="white") self.lineInspectorY = clickableLineInspector.ClickableLineInspector( component=self.polyplot, axis='index_y', inspect_mode="indexed", write_metadata=True, color="white", is_listener=False) self.polyplot.overlays.append(self.lineInspectorX) self.polyplot.overlays.append(self.lineInspectorY) self.boxSelection2D = boxSelection2D.BoxSelection2D( component=self.polyplot) self.polyplot.overlays.append(self.boxSelection2D) # Add these two plots to one container self.centralContainer = chaco.OverlayPlotContainer(padding=0, use_backbuffer=True, unified_draw=True) self.centralContainer.add(self.polyplot) # Create a colorbar cbar_index_mapper = chaco.LinearMapper(range=image_value_range) self.colorbar = chaco.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.plotData = chaco.ArrayPlotData( line_indexHorizontal=scipy.array([]), line_valueHorizontal=scipy.array([]), scatter_indexHorizontal=scipy.array([]), scatter_valueHorizontal=scipy.array([]), scatter_colorHorizontal=scipy.array([]), fitLine_indexHorizontal=scipy.array([]), fitLine_valueHorizontal=scipy.array([])) self.crossPlotHorizontal = chaco.Plot(self.plotData, resizable="h") self.crossPlotHorizontal.height = 100 self.crossPlotHorizontal.padding = 20 self.crossPlotHorizontal.plot( ("line_indexHorizontal", "line_valueHorizontal"), line_style="dot") self.crossPlotHorizontal.plot( ("scatter_indexHorizontal", "scatter_valueHorizontal", "scatter_colorHorizontal"), type="cmap_scatter", name="dot", color_mapper=self._cmap(image_value_range), marker="circle", marker_size=4) self.crossPlotHorizontal.index_range = self.polyplot.index_range.x_range self.plotData.set_data("line_indexVertical", scipy.array([])) self.plotData.set_data("line_valueVertical", scipy.array([])) self.plotData.set_data("scatter_indexVertical", scipy.array([])) self.plotData.set_data("scatter_valueVertical", scipy.array([])) self.plotData.set_data("scatter_colorVertical", scipy.array([])) self.plotData.set_data("fitLine_indexVertical", scipy.array([])) self.plotData.set_data("fitLine_valueVertical", scipy.array([])) self.crossPlotVertical = chaco.Plot(self.plotData, width=140, orientation="v", resizable="v", padding=20, padding_bottom=160) self.crossPlotVertical.plot( ("line_indexVertical", "line_valueVertical"), line_style="dot") self.crossPlotVertical.plot( ("scatter_indexVertical", "scatter_valueVertical", "scatter_colorVertical"), type="cmap_scatter", name="dot", color_mapper=self._cmap(image_value_range), marker="circle", marker_size=4) self.crossPlotVertical.index_range = self.polyplot.index_range.y_range # Create a container and add components self.container = chaco.HPlotContainer(padding=40, fill_padding=True, bgcolor="white", use_backbuffer=False) inner_cont = chaco.VPlotContainer(padding=40, use_backbuffer=True) inner_cont.add(self.crossPlotHorizontal) inner_cont.add(self.centralContainer) self.container.add(self.colorbar) self.container.add(inner_cont) self.container.add(self.crossPlotVertical)
def contour_plot(measurements, levels=[0.5, 0.95], axContour=None, wxtext=False, square=True): """Plot contour for two axes of an RT-DC measurement Parameters ---------- measurement : RTDCBase Contains measurement data. levels : float or list of floats in interval (0,1) Plot the contour at that particular level from the maximum (1). axContour : instance of matplotlib `Axis` Plotting axis for the contour. square : bool The plot has square shape. """ mm = measurements[0] xax = mm.config["plotting"]["axis x"].lower() yax = mm.config["plotting"]["axis y"].lower() # Commence plotting if axContour is not None: raise NotImplementedError("Tell Chaco to reuse plots?") pd = ca.ArrayPlotData() contour_plot = ca.Plot(pd) contour_plot.id = "ShapeOut_contour_plot" scalex = mm.config["plotting"]["scale x"].lower() scaley = mm.config["plotting"]["scale y"].lower() ## Add isoelastics isoel = plot_common.get_isoelastics(mm) if isoel: for ii, data in enumerate(isoel): x_key = 'isoel_x' + str(ii) y_key = 'isoel_y' + str(ii) pd.set_data(x_key, data[:, 0]) pd.set_data(y_key, data[:, 1]) contour_plot.plot((x_key, y_key), color="gray", index_scale=scalex, value_scale=scaley) #colors = [ "".join(map(chr, np.array(c[:3]*255,dtype=int))).encode('hex') for c in colors ] if not isinstance(levels, list): levels = [levels] set_contour_data(contour_plot, measurements, levels=levels) # Axes left_axis = ca.PlotAxis(contour_plot, orientation='left', title=dfn.feature_name2label[yax], tick_generator=plot_common.MyTickGenerator()) bottom_axis = ca.PlotAxis(contour_plot, orientation='bottom', title=dfn.feature_name2label[xax], tick_generator=plot_common.MyTickGenerator()) # Show log scale only with 10** values (#56) contour_plot.index_axis.tick_generator = plot_common.MyTickGenerator() contour_plot.value_axis.tick_generator = plot_common.MyTickGenerator() contour_plot.overlays.append(left_axis) contour_plot.overlays.append(bottom_axis) contour_plot.title = "Contours" contour_plot.title_font = "modern 12" # zoom tool zoom = cta.ZoomTool(contour_plot, tool_mode="box", color="beige", minimum_screen_delta=50, border_color="black", border_size=1, always_on=True, drag_button="right", enable_wheel=True, zoom_factor=1.1) contour_plot.tools.append(zoom) contour_plot.aspect_ratio = 1 contour_plot.use_downsampling = True # pan tool pan = cta.PanTool(contour_plot, drag_button="left") contour_plot.tools.append(pan) return contour_plot
def scatter_plot(measurement, axScatter=None, square=True, panzoom=True, select=True): """Plot scatter plot for two axes of an RT-DC measurement Parameters ---------- measurement : RTDCBase Contains measurement data. axScatter : instance of matplotlib `Axis` Plotting axis for the scatter data. square : bool The plot has square shape. panzoom : bool Add panning and zooming tools. select : bool Add point selection tool. """ mm = measurement xax = mm.config["plotting"]["axis x"].lower() yax = mm.config["plotting"]["axis y"].lower() # Plotting area plotfilters = mm.config.copy()["plotting"] marker_size = plotfilters["scatter marker size"] # Commence plotting if axScatter is not None: raise NotImplementedError("Tell Chaco to reuse plots?") scalex = mm.config["plotting"]["scale x"].lower() scaley = mm.config["plotting"]["scale y"].lower() pd = ca.ArrayPlotData() sc_plot = ca.Plot(pd) sc_plot.id = mm.identifier ## Add isoelastics isoel = plot_common.get_isoelastics(mm) if isoel: for ii, data in enumerate(isoel): x_key = 'isoel_x' + str(ii) y_key = 'isoel_y' + str(ii) pd.set_data(x_key, data[:, 0]) pd.set_data(y_key, data[:, 1]) sc_plot.plot((x_key, y_key), color="gray", index_scale=scalex, value_scale=scaley) # Display numer of events elabel = ca.PlotLabel(text="", component=sc_plot, vjustify="bottom", hjustify="right", name="events") elabel.id = "event_label_" + mm.identifier sc_plot.overlays.append(elabel) # Set content of scatter plot set_scatter_data(sc_plot, mm) plot_kwargs = { "name": "scatter_events", "marker": "square", #"fill_alpha": 1.0, "marker_size": int(marker_size), "outline_color": "transparent", "line_width": 0, "bgcolor": "white", "index_scale": scalex, "value_scale": scaley, } # Create the KDE plot if plotfilters["KDE"].lower() == "none": # Single-color plot plot_kwargs["data"] = ("index", "value") plot_kwargs["type"] = "scatter" plot_kwargs["color"] = "black" else: # Plots with density plot_kwargs["data"] = ("index", "value", "color") plot_kwargs["type"] = "cmap_scatter" plot_kwargs["color_mapper"] = ca.jet # Excluded events plot_kwargs_excl = plot_kwargs.copy() plot_kwargs_excl["name"] = "excluded_events" plot_kwargs_excl["data"] = ("excl_index", "excl_value") plot_kwargs_excl["type"] = "scatter" plot_kwargs_excl["color"] = 0x929292 if pd.get_data("excl_index") is not None: sc_plot.plot(**plot_kwargs_excl) # Plot colored points on top of excluded events if pd.get_data("index") is not None: sc_plot.plot(**plot_kwargs) # Axes left_axis = ca.PlotAxis(sc_plot, orientation='left', title=dfn.feature_name2label[yax], tick_generator=plot_common.MyTickGenerator()) bottom_axis = ca.PlotAxis(sc_plot, orientation='bottom', title=dfn.feature_name2label[xax], tick_generator=plot_common.MyTickGenerator()) # Show log scale only with 10** values (#56) sc_plot.index_axis.tick_generator = plot_common.MyTickGenerator() sc_plot.value_axis.tick_generator = plot_common.MyTickGenerator() sc_plot.overlays.append(left_axis) sc_plot.overlays.append(bottom_axis) sc_plot.title = mm.title sc_plot.title_font = "modern 12" if plotfilters["Scatter Title Colored"]: mmlabelcolor = plotfilters["contour color"] else: mmlabelcolor = "black" sc_plot.title_color = mmlabelcolor # zoom tool if panzoom: zoom = cta.ZoomTool(sc_plot, tool_mode="box", color="beige", minimum_screen_delta=50, border_color="black", border_size=1, always_on=True, drag_button="right", enable_wheel=True, zoom_factor=1.1) sc_plot.tools.append(zoom) sc_plot.aspect_ratio = 1 sc_plot.use_downsampling = True # pan tool pan = cta.PanTool(sc_plot, drag_button="left") sc_plot.tools.append(pan) # select tool if select: my_plot = sc_plot.plots["scatter_events"][0] my_plot.tools.append( cta.ScatterInspector(my_plot, selection_mode="single", persistent_hover=False)) my_plot.overlays.append( ca.ScatterInspectorOverlay(my_plot, hover_color="transparent", hover_marker_size=int(marker_size * 4), hover_outline_color="black", hover_line_width=1, selection_marker_size=int(marker_size * 1.5), selection_outline_color="black", selection_line_width=1, selection_color="purple")) return sc_plot
from flowersdata import FlowerData import chaco.api as chacoapi import chaco.tools.api as toolsapi from traits.api import HasTraits, Instance from enable.api import Component, ComponentEditor from traitsui.api import Item, Group, View, Handler, Action size = (700, 700) pd = chacoapi.ArrayPlotData() def _create_plot_component(): varnames = FlowerData['traits'] species_map = {} for idx, spec in enumerate(FlowerData['species']): species_map[spec] = idx container = chacoapi.GridContainer(padding=40, fill_padding=True, bgcolor="lightgray", use_backbuffer=True, shape=(4, 4), spacing=(20, 20)) for varname in varnames: pd.set_data(varname, [x[varname] for x in FlowerData['values']]) pd.set_data('species', [species_map[x['species']] for x in FlowerData['values']]) for x in range(4): for y in range(4): xname = varnames[x] yname = varnames[y]
def CreateScatterPlot(measurement, xax="Area", yax="Defo", axScatter=None, isoel=None, square=True, downsampling=None, downsample_events=None, panzoom=True, select=True): """ Plot scatter plot for two axes of an RTDC measurement Parameters ---------- measurement : instance of RTDS_DataSet Contains measurement data. xax : str x-Axis to plot (see `librtdc.dfn.cfgmap`) yax : str y-Axis to plot (see `librtdc.dfn.cfgmap`) axScatter : instance of matplotlib `Axis` Plotting axis for the scatter data. isoel : list for line plot Manually selected isoelastics to plot. Defaults to None. If no isoelastics are found, then a warning is raised. square : bool The plot has square shape. downsampling : int or None Filter events that are overdrawn by others (saves time). If set to None then Configuration["Plotting"]["Downsampling"] is used. Chaco does not yet have this implemented. downsample_events : int or None Number of events to draw in the down-sampled plot. This number is either - >=1: limit total number of events drawn - <1: only perform 1st downsampling step with grid If set to None, then Configuration["Plotting"]["Downsample Events"] will be used. panzoom : bool Add panning and zooming tools. select : bool Add point selection tool. """ mm = measurement # Plotting area plotfilters = mm.Configuration["Plotting"].copy() marker_size = plotfilters["Scatter Marker Size"] if downsampling is None: downsampling = plotfilters["Downsampling"] if downsample_events is None: downsample_events = plotfilters["Downsample Events"] # We will pretend as if we are plotting circularity vs. area areamin = plotfilters[xax+" Min"] areamax = plotfilters[xax+" Max"] circmin = plotfilters[yax+" Min"] circmax = plotfilters[yax+" Max"] if areamin == areamax: areamin = getattr(mm, dfn.cfgmaprev[xax]).min() areamax = getattr(mm, dfn.cfgmaprev[xax]).max() if circmin == circmax: circmin = getattr(mm, dfn.cfgmaprev[yax]).min() circmax = getattr(mm, dfn.cfgmaprev[yax]).max() # Commence plotting if axScatter is not None: raise NotImplementedError("Tell Chaco to reuse plots?") #plt.figure(1) #axScatter = plt.axes() if mm.Configuration["Filtering"]["Enable Filters"]: x = getattr(mm, dfn.cfgmaprev[xax])[mm._filter] y = getattr(mm, dfn.cfgmaprev[yax])[mm._filter] else: # filtering disabled x = getattr(mm, dfn.cfgmaprev[xax]) y = getattr(mm, dfn.cfgmaprev[yax]) if downsampling: lx = x.shape[0] x, y = mm.GetDownSampledScatter( downsample_events=downsample_events ) positions = np.vstack([x.ravel(), y.ravel()]) print("Downsampled from {} to {}".format(lx, x.shape[0])) else: positions = None density = mm.GetKDE_Scatter(yax=yax, xax=xax, positions=positions) scalex = mm.Configuration["Plotting"]["Scale X"].lower() scaley = mm.Configuration["Plotting"]["Scale Y"].lower() pd = ca.ArrayPlotData() scatter_plot = ca.Plot(pd) ## Add isoelastics if mm.Configuration["Plotting"]["Isoelastics"]: if isoel is None: chansize = mm.Configuration["General"]["Channel Width"] #plotdata = list() # look for isoelastics: for key in list(isoelastics.keys()): if float(key.split("um")[0]) == chansize > 0: plotdict = isoelastics[key] for key2 in list(plotdict.keys()): if key2 == "{} {}".format(xax, yax): isoel = plotdict[key2] if isoel is None: warnings.warn("Could not find matching isoelastics for"+ " Setting: x={} y={}, Channel width: {}". format(xax, yax, chansize)) else: for ii, data in enumerate(isoel): x_key = 'isoel_x'+str(ii) y_key = 'isoel_y'+str(ii) # # # Crop data points outside of the plotting area # #data = crop_linear_data(data, areamin, areamax, circmin, circmax) # pd.set_data(x_key, data[:,0]) pd.set_data(y_key, data[:,1]) scatter_plot.plot((x_key, y_key), color="gray", index_scale=scalex, value_scale=scaley) pd.set_data("index", x) pd.set_data("value", y) pd.set_data("color", density) plot_kwargs = { "name": "my_plot", "marker": "square", #"fill_alpha": 1.0, "marker_size": int(marker_size), "outline_color": "transparent", "line_width": 0, "bgcolor": "white", "index_scale": scalex, "value_scale": scaley, } # Plot filtered data in grey if (plotfilters["Scatter Plot Excluded Events"] and mm._filter.sum() != mm.time.shape[0]): # determine the number of points we are allowed to add if downsampling: # respect the maximum limit of plotted events excl_num = int(downsample_events - np.sum(mm._filter)) else: # plot all excluded events excl_num = np.sum(~mm._filter) if excl_num > 0: excl_x = getattr(mm, dfn.cfgmaprev[xax])[~mm._filter][:excl_num] excl_y = getattr(mm, dfn.cfgmaprev[yax])[~mm._filter][:excl_num] pd.set_data("excl_index", excl_x) pd.set_data("excl_value", excl_y) plot_kwargs_excl = plot_kwargs.copy() plot_kwargs_excl["data"] = ("excl_index", "excl_value") plot_kwargs_excl["type"] = "scatter" plot_kwargs_excl["color"] = 0x929292 scatter_plot.plot(**plot_kwargs_excl) # Create the KDE plot if plotfilters["KDE"].lower() == "none": # Single-color plot plot_kwargs["data"] = ("index", "value") plot_kwargs["type"] = "scatter" plot_kwargs["color"] = "black" else: # Plots with density plot_kwargs["data"] = ("index", "value", "color") plot_kwargs["type"] = "cmap_scatter" plot_kwargs["color_mapper"] = ca.jet scatter_plot.plot(**plot_kwargs) # Set x-y limits xlim = scatter_plot.index_mapper.range ylim = scatter_plot.value_mapper.range xlim.low = areamin xlim.high = areamax ylim.low = circmin ylim.high = circmax # Axes left_axis = ca.PlotAxis(scatter_plot, orientation='left', title=dfn.axlabels[yax], tick_generator=misc.MyTickGenerator()) bottom_axis = ca.PlotAxis(scatter_plot, orientation='bottom', title=dfn.axlabels[xax], tick_generator=misc.MyTickGenerator()) # Show log scale only with 10** values (#56) scatter_plot.index_axis.tick_generator=misc.MyTickGenerator() scatter_plot.value_axis.tick_generator=misc.MyTickGenerator() scatter_plot.overlays.append(left_axis) scatter_plot.overlays.append(bottom_axis) scatter_plot.title = mm.title scatter_plot.title_font = "modern 12" if plotfilters["Scatter Title Colored"]: mmlabelcolor = plotfilters["Contour Color"] else: mmlabelcolor = "black" scatter_plot.title_color = mmlabelcolor # Display numer of events if plotfilters["Show Events"]: elabel = ca.PlotLabel(text="{} events".format(np.sum(mm._filter)), component=scatter_plot, vjustify="bottom", hjustify="right") scatter_plot.overlays.append(elabel) # zoom tool if panzoom: zoom = cta.ZoomTool(scatter_plot, tool_mode="box", color="beige", minimum_screen_delta=50, border_color="black", border_size=1, always_on=True, drag_button="right", enable_wheel=True, zoom_factor=1.1) scatter_plot.tools.append(zoom) scatter_plot.aspect_ratio = 1 scatter_plot.use_downsampling = True # pan tool pan = cta.PanTool(scatter_plot, drag_button="left") scatter_plot.tools.append(pan) if select: my_plot = scatter_plot.plots["my_plot"][0] my_plot.tools.append( cta.ScatterInspector( my_plot, selection_mode="single", persistent_hover=False)) my_plot.overlays.append( ca.ScatterInspectorOverlay( my_plot, hover_color = "transparent", hover_marker_size = int(marker_size*4), hover_outline_color = "black", hover_line_width = 1, selection_marker_size = int(marker_size*1.5), selection_outline_color = "black", selection_line_width = 1, selection_color = "purple") ) return scatter_plot
def CreateContourPlot(measurements, xax="Area", yax="Defo", levels=.5, axContour=None, isoel=None, wxtext=False, square=True): """ Plot contour for two axes of an RTDC measurement Parameters ---------- measurement : instance of RTDS_DataSet Contains measurement data. xax : str x-Axis to plot (see `librtdc.dfn.cfgmap`) yax : str y-Axis to plot (see `librtdc.dfn.cfgmap`) levels : float or list of floats in interval (0,1) Plot the contour at that particular level from the maximum (1). axContour : instance of matplotlib `Axis` Plotting axis for the contour. isoel : list for line plot Manually selected isoelastics to plot. Defaults to None. If no isoelastics are found, then a warning is raised. square : bool The plot has square shape. """ mm = measurements[0] # Plotting area plotfilters = mm.Configuration["Plotting"] # We will pretend as if we are plotting circularity vs. area areamin = plotfilters[xax+" Min"] areamax = plotfilters[xax+" Max"] circmin = plotfilters[yax+" Min"] circmax = plotfilters[yax+" Max"] if areamin == areamax: areamin = getattr(mm, dfn.cfgmaprev[xax]).min() areamax = getattr(mm, dfn.cfgmaprev[xax]).max() if circmin == circmax: circmin = getattr(mm, dfn.cfgmaprev[yax]).min() circmax = getattr(mm, dfn.cfgmaprev[yax]).max() # Commence plotting if axContour is not None: raise NotImplementedError("Tell Chaco to reuse plots?") pd = ca.ArrayPlotData() contour_plot = ca.Plot(pd) scalex = mm.Configuration["Plotting"]["Scale X"].lower() scaley = mm.Configuration["Plotting"]["Scale Y"].lower() ## Add isoelastics if mm.Configuration["Plotting"]["Isoelastics"]: if isoel is None: chansize = mm.Configuration["General"]["Channel Width"] #plotdata = list() # look for isoelastics: for key in list(isoelastics.keys()): if float(key.split("um")[0]) == chansize > 0: plotdict = isoelastics[key] for key2 in list(plotdict.keys()): if key2 == "{} {}".format(xax, yax): isoel = plotdict[key2] if isoel is None: warnings.warn("Could not find matching isoelastics for"+ " Setting: x={} y={}, Channel width: {}". format(xax, yax, chansize)) else: for ii, data in enumerate(isoel): x_key = 'isoel_x'+str(ii) y_key = 'isoel_y'+str(ii) # # # Crop data events outside of the plotting area # #data = crop_linear_data(data, areamin, areamax, circmin, circmax) # pd.set_data(x_key, data[:,0]) pd.set_data(y_key, data[:,1]) contour_plot.plot((x_key, y_key), color="gray", index_scale=scalex, value_scale=scaley) #colors = [ "".join(map(chr, np.array(c[:3]*255,dtype=int))).encode('hex') for c in colors ] if not isinstance(levels, list): levels = [levels] for mm, ii in zip(measurements, range(len(measurements))): (X,Y,density) = mm.GetKDE_Contour(yax=yax, xax=xax) cname = "con_{}_{}_{}".format(mm.name, mm.file_hashes[0][1], ii) pd.set_data(cname, density) #plt.contour(x,y,density,1,colors=[c],label=name,linewidths=[2.5],zorder=5) plev = [np.max(density)*i for i in levels] if len(plev) == 2: styles = ["dot", "solid"] else: styles = "solid" # contour widths if "Contour Width" in mm.Configuration["Plotting"]: cwidth = mm.Configuration["Plotting"]["Contour Width"] else: cwidth = 1.2 contour_plot.contour_plot(cname, type="line", xbounds = (X[0][0], X[0][-1]), ybounds = (Y[0][0], Y[-1][0]), levels = plev, colors = mm.Configuration["Plotting"]["Contour Color"], styles = styles, widths = [cwidth*.7, cwidth], # make outer lines slightly smaller ) # Set x-y limits xlim = contour_plot.index_mapper.range ylim = contour_plot.value_mapper.range xlim.low = areamin xlim.high = areamax ylim.low = circmin ylim.high = circmax contour_plot.index_scale = scalex contour_plot.value_scale = scaley # Axes left_axis = ca.PlotAxis(contour_plot, orientation='left', title=dfn.axlabels[yax], tick_generator=misc.MyTickGenerator()) bottom_axis = ca.PlotAxis(contour_plot, orientation='bottom', title=dfn.axlabels[xax], tick_generator=misc.MyTickGenerator()) # Show log scale only with 10** values (#56) contour_plot.index_axis.tick_generator=misc.MyTickGenerator() contour_plot.value_axis.tick_generator=misc.MyTickGenerator() contour_plot.overlays.append(left_axis) contour_plot.overlays.append(bottom_axis) contour_plot.title = "Contours" contour_plot.title_font = "modern 12" # zoom tool zoom = cta.ZoomTool(contour_plot, tool_mode="box", color="beige", minimum_screen_delta=50, border_color="black", border_size=1, always_on=True, drag_button="right", enable_wheel=True, zoom_factor=1.1) contour_plot.tools.append(zoom) contour_plot.aspect_ratio = 1 contour_plot.use_downsampling = True # pan tool pan = cta.PanTool(contour_plot, drag_button="left") contour_plot.tools.append(pan) return contour_plot
def __init__(self, parent, frame): ScrolledPanel.__init__(self, parent, -1) self.frame = frame self.parent = parent self.SetupScrolling(scroll_y=True, scroll_x=True) ## draw event selection tools # dropdown for plot selection self.WXCB_plot = wx.ComboBox(self, style=wx.CB_DROPDOWN|wx.CB_READONLY, size=(250,-1)) # spin control for event selection self.WXSP_plot = wx.SpinCtrl(self, min=1, max=10000000) ctrlsizer = wx.BoxSizer(wx.HORIZONTAL) ctrlsizer.Add(wx.StaticText(self, label="Event:"),0, wx.ALIGN_CENTER) ctrlsizer.Add(self.WXCB_plot) ctrlsizer.Add(self.WXSP_plot) # Bindings self.Bind(wx.EVT_COMBOBOX, self.OnShowEvent, self.WXCB_plot) self.Bind(wx.EVT_SPINCTRL, self.OnShowEvent, self.WXSP_plot) ## Image panel with chaco don't work. I get a segmentation fault ## with Ubuntu 14.04 ## ## See the bug at launchpad ## https://bugs.launchpad.net/ubuntu/+source/python-chaco/+bug/1145575 #self.plot_window = ea.Window(self) #self.vbox = wx.BoxSizer(wx.VERTICAL) #self.vbox.Add(self.plot_window.control, 1, wx.EXPAND) #self.SetSizer(self.vbox) #self.vbox.Fit(self) #self.pd = ca.ArrayPlotData() #x = np.arange(100).reshape(10,10) #a = ca.ImageData() #a.set_data(x) #self.pd.set_data("cellimg", a) #implot = ca.Plot(self.pd) #implot.img_plot("cellimg") #container = ca.GridPlotContainer( # shape = (1,1), # spacing = (0,0), # padding = (0,0,0,0), # valign = 'top', # bgcolor = 'white', # fill_padding = True, # use_backbuffer = True) #container.add(implot) # CAUSE SEGMENTATION FAULT #self.plot_window.component = container #self.plot_window.redraw() # Draw image with wxPython instead self.startSizeX = 250 self.startSizeY = 77 self.img = wx.EmptyImage(self.startSizeX, self.startSizeY) self.imageCtrl = wx.StaticBitmap(self, wx.ID_ANY, wx.BitmapFromImage(self.img)) #self.mainSizer = wx.BoxSizer(wx.VERTICAL|wx.ALIGN_TOP|wx.ALIGN_LEFT) #self.mainSizer.Add(self.imageCtrl, 1, wx.ALIGN_TOP|wx.ALIGN_LEFT) #self.SetSizer(self.mainSizer) #self.mainSizer.Fit(self) self.PlotImage() ## draw manual filtering options self.WXChB_exclude = wx.CheckBox(self, label="Exclude event") exclsizer = wx.BoxSizer(wx.HORIZONTAL) exclsizer.Add(self.WXChB_exclude, 0, wx.ALIGN_CENTER_VERTICAL) self.Bind(wx.EVT_CHECKBOX, self.OnChBoxExclude, self.WXChB_exclude) # Update Plot button updbutton = wx.Button(self, label="Update plot") self.Bind(wx.EVT_BUTTON, self.OnUpdatePlot, updbutton) #exclsizer.AddSpacer(self.imageCtrl.GetSize()[0]-updbutton.GetSize()[0]-self.WXChB_exclude.GetSize()[0]) exclsizer.Add(updbutton, 0, wx.ALIGN_RIGHT) ## Add traces plot # set initial values x = np.linspace(-np.pi, np.pi, 50) y = np.cos(x)+1 plotkwargs = {} for trid in dclab.definitions.FLUOR_TRACES: plotkwargs[trid] = y self.trace_data = ca.ArrayPlotData(x=x, **plotkwargs) self.trace_plot = ca.Plot(self.trace_data, padding=0, spacing=0) for trid in dclab.definitions.FLUOR_TRACES: if trid.count("raw"): color = "gray" elif trid == "fl1_median": color = "green" elif trid == "fl2_median": color = "orange" elif trid == "fl3_median": color = "red" self.trace_plot.plot(("x", trid), type="line", color=color) # convert wx color to something chaco understands bgcolor = list(np.array(self.GetBackgroundColour()) / 255) container = ca.HPlotContainer(spacing=70, padding=50, bgcolor=bgcolor, fill_padding=True,)#) container.add(self.trace_plot) self.plot_window = Window(self, component=container) sizer = wx.GridBagSizer(5,5) sizer.Add(ctrlsizer, (0,0)) sizer.Add(self.imageCtrl, (1,0)) sizer.Add(exclsizer, (2,0)) self.plot_window.control.SetMinSize((300, 300)) sizer.Add(self.plot_window.control, (3,0), span=(2,2), flag=wx.EXPAND) self.SetSizer(sizer) sizer.Fit(self) self.sizer = sizer
def __init__(self, x, y): ymin = y - 1 ymax = y + 1 self.plotdata = chaco.ArrayPlotData(x=x, y=y, ymin=ymin, ymax=ymax) self.figure = None
def __ds_default(self): return ch.ArrayPlotData(t=self.t, y=self.data[:, self.channel], yf=self.filter.yf)