def actionfunc(self, damage_type): # 损伤SpanSelector对象 self.span3_red = SpanSelector(self.ax3, self.onselect3, 'vertical', useblit=True, rectprops=dict(alpha=0.5, facecolor='red'), span_stays=True) # 结垢SpanSelector对象 self.span3_green = SpanSelector(self.ax3, self.onselect3, 'vertical', useblit=True, rectprops=dict(alpha=0.5, facecolor='green'), span_stays=True) # 变形SpanSelector对象 self.span3_yellow = SpanSelector(self.ax3, self.onselect3, 'vertical', useblit=True, rectprops=dict(alpha=0.5, facecolor='yellow'), span_stays=True) if damage_type == 'Penetration': print(damage_type) self.damage_Tag = 'Penetration' # del self.span3_red del self.span3_green del self.span3_yellow elif damage_type == 'Projection': print(damage_type) self.damage_Tag = 'Projection' del self.span3_red # del self.span3_green del self.span3_yellow elif damage_type == 'Transformation': print(damage_type) self.damage_Tag = 'Transformation' del self.span3_red del self.span3_green
def interactive_plot(data): global ax1 fig, ax1 = plt.subplots(1, figsize=(8, 6)) # ax1.set(facecolor='#FFFFCC') ax1.plot(data) ax1.set_title('Markiere mit der linken Maustaste einen Bereich') callback = Index() axprev = plt.axes([0.8, 0.01, 0.1, 0.075]) bclose = Button(axprev, 'Schließen') span1 = SpanSelector(ax=ax1, onselect=onselect, direction='horizontal', useblit=True, minspan=2, button=1, rectprops=dict(alpha=0.5, facecolor='red')) span2 = SpanSelector(ax=ax1, onselect=offselect, direction='horizontal', useblit=True, minspan=2, button=3, rectprops=dict(alpha=0.5, facecolor='red')) bclose.on_clicked(callback.close) plt.show() del span1, span2 return coords['min'], coords['max']
def __init__(self, data): # save reference to data and generate "time" for interpretable X-axis self.data = utils.check_physio(data, copy=True) fs = 1 if data.fs is None else data.fs self.time = np.arange(0, len(data.data) / fs, 1 / fs) # we need to create these variables in case someone doesn't "quit" # the plot appropriately (i.e., clicks X instead of pressing ctrl+q) self.deleted, self.rejected = set(), set() # make main plot objects self.fig, self.ax = plt.subplots(nrows=1, ncols=1, tight_layout=True) self.fig.canvas.mpl_connect('scroll_event', self.on_wheel) self.fig.canvas.mpl_connect('key_press_event', self.on_key) # two selectors for rejection (left mouse) and deletion (right mouse) reject = functools.partial(self.on_remove, reject=True) delete = functools.partial(self.on_remove, reject=False) self.span1 = SpanSelector(self.ax, reject, 'horizontal', button=1, useblit=True, rectprops=dict(facecolor='red', alpha=0.3)) self.span2 = SpanSelector(self.ax, delete, 'horizontal', button=3, useblit=True, rectprops=dict(facecolor='blue', alpha=0.3)) self.plot_signals(False)
def configure_selector(self,frange=False,peaks=False): self.peaks_selector = SpanSelector(self.axs[0], self.onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red')) self.peaks_selector.set_active(peaks) self.range_selector = SpanSelector(self.axs[0], self.onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='g')) self.range_selector.set_active(frange)
def convert_iq_and_plot_from_mem(in_file, number): """ remove GNSS data from the IQ file and plot it from memory. """ global TRIM_PROC, fig, a_x, span, span2 # Remove GNSS data from the IQ file old_f = open(in_file, 'rb') old_size = os.path.getsize(in_file) data_size = 2048 * ((old_size - 36) // 2074) new_f = BytesIO() new_f.write(old_f.read(36)) new_f.write(b'data') new_f.write(struct.pack('<i', data_size)) for i in range(62, old_size, 2074): old_f.seek(i) new_f.write(old_f.read(2048)) old_f.close() new_f.seek(0, 0) data = np.frombuffer(new_f.getvalue(), dtype='int16') data = data[0::2] + 1j * data[1::2] # Plot the IQ w/o GNSS data plt.rcParams['toolbar'] = 'None' fig, a_x = plt.subplots() plt.specgram(data, NFFT=1024, Fs=12000, window=lambda data: data * np.hanning(len(data)), noverlap=512, vmin=10, vmax=200, cmap=COLORMAP) plt.xlabel("Time (s)") ticks = FuncFormatter(lambda x, pos: FREQUENCY + (x // 1e3)) a_x.yaxis.set_major_formatter(ticks) a_x.set_ybound(-6000.0, 6000.0) if TRIM_PROC == 1: plt.title(in_file.rsplit("_", 2)[1] + " - [" + str(number) + "/" + str(TOTAL_FILES) + "]", fontsize=10) span = SpanSelector(a_x, onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.4, facecolor='red')) span2 = SpanSelector(a_x, onselect2, 'horizontal', useblit=True, rectprops=dict(alpha=0.4, facecolor='green')) fig.canvas.mpl_connect('motion_notify_event', on_mouse_move) fig.canvas.mpl_connect('button_press_event', on_mouse_click) else: plt.gcf().set_facecolor("yellow") fig.canvas.mpl_connect('button_press_event', on_press) plt.title(in_file.rsplit("_", 2)[1] + " - [" + str(number) + "/" + str(TOTAL_FILES) + "]" + " - [trimmed IQ preview]", fontsize=10) TRIM_PROC = 1 plt.show()
def reset_chart(self): self.track_axes.clear() self.track_figure.patch.set_visible(False) self.track_axes.patch.set_visible(False) self.xdata = [] self.ydata = [] self.idata = [] self.x_min = 0 self.x_max = 1 self.y_max = 1 self.bracket_set = False self.button_hold = False self.plot_zoom = False self.chart_range = None self.selector = None self.max_lock = True self.patch_x = 0 self.patch_x_last = 1 self.patch_width = 1 self.start_edge = 0 self.end_edge = 1 self.acc_plot = self.track_axes.plot([], [], 'o', color='#4575b4')[0] self.rej_plot = self.track_axes.plot([], [], 'o', color='#d73027')[0] self.idx_plot = self.track_axes.plot([], [], 'wo', ms=2)[0] self.bragg_line = self.track_axes.axhline(0, c='#4575b4', ls=':', alpha=0) self.highlight = self.track_axes.axvspan(0.5, 0.5, ls='--', alpha=0, fc='#deebf7', ec='#2171b5') self.track_axes.set_autoscaley_on(True) self.select_span = SpanSelector(ax=self.track_axes, onselect=self.onSelect, direction='horizontal', rectprops=dict(alpha=0.5, ls=':', fc='#deebf7', ec='#2171b5')) self.select_span.set_active(False) self.zoom_span = SpanSelector(ax=self.track_axes, onselect=self.onSelect, direction='horizontal', rectprops=dict(alpha=0.5, ls=':', fc='#ffffd4', ec='#8c2d04')) self.zoom_span.set_active(False)
def __init__(self, data, plot_method=PlotMethod.SCATTER, classes=[], ion=True, **kwargs): self.fig = fig = plt.figure(figsize=(15, 15)) data = data.astype({"class": str}, axis=1) self.classes = np.unique(data["class"].values.tolist() + classes) # Security check if "class" not in data: raise ValueError("You must have a class column in your data") # Create axes data_names = [i for i in data if i != "class"] self.gs = gs = gridspec.GridSpec(len(data_names), 1) self.axes = axes = [fig.add_subplot(i) for i in gs] self.data = data self.axe_zoom = axe_zoom = plt.axes((.15, .03, .84, .05)) self.span_zoom = SpanSelector(axe_zoom, self.select_zoom, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='green')) self.spans = [ SpanSelector(axe, self.onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red')) for axe in axes ] self.radio_axe = rax = plt.axes( (0.005, .1, .1, .03 * len(self.classes))) self.radio = radio = RadioButtons(rax, self.classes) radio.on_clicked(self.clicked_radio) self.current_class_index = 0 self.zoom = np.array( [np.min(data.index.values), np.max(data.index.values)]) self.zoom_ylim = None self.zoom_xlim = None self.zoom_fill = None self.plot_method = plot_method self.kwargs = kwargs self.ion = ion self.plot() self.running = False self.__create_legend()
def __init__(self, routine): super(VolumetricGraphWidget, self).__init__() logging.info("Volumetricgraph Window Started") self.routine = routine self.layout = QVBoxLayout(self) self.setWindowTitle("Graph and Flourescence (+Volumetric)") self.roiindex = 0 self.xmin = 0 self.xmax = 1 self.secondxmin = 0 self.secondxmax = 1 self.secondthreshold = 0.3 self.fig = plt.figure() self.canvas = FigureCanvas(self.fig) self.data = None self.shown = False self.showall = False self.secondchannelUI = 300 self.flags = QLineEdit() self.flagsSave = QPushButton("Save") self.flagsSave.clicked.connect(self.save) self.minimumslider = ValueSelector("Threshold", 0, 100, self.thresholdChanged, ismin=True) self.minimumslider.valueslider.setValue( int(self.routine.settings.threshold * 100)) self.dataCanvas = self.fig.add_subplot(513) self.data2Canvas = self.fig.add_subplot(515) self.pictureCanvas = self.fig.add_subplot(511) self.picture1Canvas = self.fig.add_subplot(512) self.picture2Canvas = self.fig.add_subplot(514) self.span = SpanSelector(self.data2Canvas, self.onsecondselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red')) self.span2 = SpanSelector(self.dataCanvas, self.onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red')) self.setUI() self.show()
def __init__(self, sme, segment=0, axes=None, show=True): self.wave = sme.wave self.spec = sme.spec self.mask = sme.mask self.smod = sme.synth self.segment = segment self.nsegments = len(self.wave) self.mode = "line/cont" self.lines = sme.linelist self.vrad = sme.vrad self.vrad = [v if v is not None else 0 for v in self.vrad] self.line_plot = None self.lock = False if axes is None: self.im = plt.subplots()[1] else: self.im = axes self.selector_line = SpanSelector( self.im, self.section_line_callback, direction="horizontal", useblit=True, button=(1, ), ) self.selector_cont = SpanSelector( self.im, self.section_continuum_callback, direction="horizontal", useblit=True, button=(3, ), ) self.im.figure.canvas.mpl_connect("key_press_event", self.key_event) self.im.callbacks.connect("xlim_changed", self.resize_event) ax_next = plt.axes([0.8, 0.025, 0.1, 0.04]) self.button_next = Button(ax_next, "-->") self.button_next.on_clicked(self.next_segment) ax_prev = plt.axes([0.7, 0.025, 0.1, 0.04]) self.button_prev = Button(ax_prev, "<--") self.button_prev.on_clicked(self.previous_segment) self.plot() if show: plt.show()
def __init__(self, parent=None): super(Window, self).__init__(parent) #self.setGeometry(300, 100, 800, 600) # distance from sx, from top, length, heigth self.showMaximized() self.figure, ((self.ax1, self.ax2), (self.ax3, self.ax4)) = plt.subplots(2, 2) self.canvas = FigureCanvas(self.figure) self.toolbar = NavigationToolbar(self.canvas, self) self.button = QtGui.QPushButton('Browse') self.button.clicked.connect(self.browse) # set the layout layout = QtGui.QVBoxLayout() layout.addWidget(self.toolbar) layout.addWidget(self.canvas) layout.addWidget(self.button) self.setLayout(layout) #self.ax = self.figure.add_subplot(111) self.span1 = SpanSelector(self.ax1, self.extremes1, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='green')) self.span2 = SpanSelector(self.ax2, self.extremes2, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='green')) self.span3 = SpanSelector(self.ax3, self.extremes3, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='green')) self.span4 = SpanSelector(self.ax4, self.extremes4, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='green'))
def _init_plot(self): self._figure = plt.figure(figsize=(9, 5)) axes = plt.subplot(1, 1, 1) plt.plot(self.wL, self.A, lw=3, color='k') axes.grid(which="both") self._axes = axes plt.xlabel(self.xlabel_str) plt.ylabel('Absorbance') if self._points: x, y = zip(*self._points.items()) self._line, = self._axes.plot(x, y, "r", marker="+", markersize=10, linestyle='None') self._axes.set_xlim(self.x_lim_min, self.x_lim_max) plt.show() def onrangeselect(xmin, xmax): indmin, indmax = np.searchsorted(x, (xmin, xmax)) indmax = min(len(x) - 1, indmax) self.x_lim_min = np.min([xmin, xmax]) self.x_lim_max = np.max([xmin, xmax]) self.set_range(xmin, xmax) self.span = SpanSelector(axes, onrangeselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red')) plt.show()
def create_canvas(self): self.fig = plt.figure() self.canvas = FigureCanvas(self.fig) self.axes = plt.subplot(111) self.axes.set_xlabel("Scans") self.axes.set_ylabel("Instensity") self.axes.set_title("Least Square Fitting(2D)", fontsize=9) self.axes.tick_params(axis='both', labelsize=8) plt.subplots_adjust(bottom=0.22, top=0.90, left=0.08, right=0.9) self.span = SpanSelector(self.axes, self.span_select_callback, 'horizontal', minspan=0.002, useblit=True, rectprops=dict(alpha=0.5, facecolor='red'), onmove_callback=None, button=[1]) axspan = plt.axes([0.09, 0.04, 0.08, 0.075]) axundo = plt.axes([0.2, 0.04, 0.08, 0.075]) axstar = plt.axes([0.31, 0.04, 0.08, 0.075]) self.btnspan = Button(axspan, 'span') self.btnundo = Button(axundo, 'undo') self.btnstar = Button(axstar, 'start') self.btnspan.on_clicked(self.span_mode) self.btnundo.on_clicked(self.undo_mode) self.btnstar.on_clicked(self.star_mode) self.span.set_active(True) self.redraw() ymino, ymaxo = self.axes.get_ylim() xmino, xmaxo = self.axes.get_xlim() self.oxy = [(xmino, xmaxo), (ymino, ymaxo)]
def setup_watertxt_plot(self): """ Setup the watertxt plot """ self.clear_watertxt_plot() # set up axes and its properties self.axes = self.figure.add_subplot(111) self.axes.grid(True) # create radio buttons self.axes_radio = self.figure.add_axes( [0.01, 0.02, 0.10, 0.15] ) # [left, bottom, width, height] = fractions of figure width and height self.figure.subplots_adjust(bottom=0.2) self.radio_buttons = RadioButtons(ax=self.axes_radio, labels=("Span On", "Span Off"), active=1, activecolor="r") self.radio_buttons.on_clicked(self.toggle_selector) # create SpanSelector; invisble at first unless activated with toggle selector self.span_selector = SpanSelector(self.axes, self.on_select_axes, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red')) self.span_selector.visible = False
def PlotContrastHistogram(self): self.summedimhist, self.summedimbins = np.histogram(self.summedim, bins = self.contrastbins) self.contrast_ax.cla() self.contrast_ax.plot(self.summedimbins[:-1], self.summedimhist, color = 'k') self.contrast_ax.set_axis_off() self.contrast_span = SpanSelector(self.contrast_ax, self.ContrastSpan, 'horizontal', span_stays = True, rectprops = dict(alpha = 0.5, facecolor = 'green'))
def draw_plot(self,event): self.figure.clear() self.axes = self.figure.add_subplot(211, axisbg='#FFFFCC') self.axes.clear() self.axes.grid(self.cb_grid.IsChecked()) x = np.arange(0.0, 5.0, 0.01) y = np.sin(2*np.pi*x) + 0.5*np.random.randn(len(x)) self.axes.plot(x, y, '-') self.axes.set_ylim(-2,2) self.axes.set_title('Press left mouse button and drag to test') self.axes2 = self.figure.add_subplot(212, axisbg='#FFFFCC') self.axes2.clear() self.axes2.grid(self.cb_grid.IsChecked()) line2, = self.axes2.plot(x, y, '-') def onselect(xmin, xmax): indmin, indmax = np.searchsorted(x, (xmin, xmax)) indmax = min(len(x)-1, indmax) thisx = x[indmin:indmax] thisy = y[indmin:indmax] line2.set_data(thisx, thisy) self.axes2.set_xlim(thisx[0], thisx[-1]) self.axes2.set_ylim(thisy.min(), thisy.max()) self.figure.canvas.draw() # set useblit True on gtkagg for enhanced performance self.span = SpanSelector(self.axes, onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red') ) self.figure.canvas.draw()
def _setup_ui(self): # Add a side menu for specifying the wavelength of the selected line panel = QtWidgets.QWidget() label = QtWidgets.QLabel("Enter wavelength [Å]:", panel) help_label = QtWidgets.QLabel("Enter a wavelength value, zoom in, then select the region " "containing the emission line at the specified wavelength.", panel) help_label.setStyleSheet("font-style: italic;") self._ui['textbox'] = QtWidgets.QLineEdit(parent=panel) panel.layout = QtWidgets.QGridLayout(panel) panel.layout.addWidget(label, 0, 0, 1, 1) panel.layout.addWidget(self._ui['textbox'], 0, 1, 1, 1) panel.layout.addWidget(help_label, 1, 0, 1, 2, Qt.AlignCenter) main_window = self.fig.canvas.manager.window dock = QtWidgets.QDockWidget("Enter wavelength:", main_window) main_window.addDockWidget(Qt.BottomDockWidgetArea, dock) dock.setWidget(panel) # A 1D span selector to highlight a given line span = SpanSelector(self.ax, self._on_select, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red')) span.set_active(False) def enable_span(): tb = self.fig.canvas.manager.toolbar if span.active: span.set_active(False) else: span.set_active(True) if tb._active == 'PAN': tb.pan() tb._actions['pan'].setChecked(False) if tb._active == 'ZOOM': tb.zoom() tb._actions['zoom'].setChecked(False) span_control = QtWidgets.QPushButton('λ') span_control.setCheckable(True) span_control.clicked.connect(enable_span) span_control.setStyleSheet("color: #de2d26; font-weight: bold;") self.fig.canvas.manager.toolbar.addWidget(span_control) # setup auto-identify button if self.line_list is not None: autoid_control = QtWidgets.QPushButton('auto-identify') autoid_control.clicked.connect(self.auto_identify) self.fig.canvas.manager.toolbar.addWidget(autoid_control) # add a button for "done" done_control = QtWidgets.QPushButton('done') done_control.clicked.connect(self._finish) self.fig.canvas.manager.toolbar.addWidget(done_control) plt.show()
def add_span_selector(self, name, callback, axes=None, **kwargs): axes = axes if axes else self.axes self.add_element( SpanSelector( axes, lambda min, max: self.__on_selected(name, callback, min, max), **kwargs), name)
def add_selector(self, listing): # We will be able to select X-frames and its boundaries # will be stored in the given list """ The SpanSelector is a mouse widget to select a xmin/xmax range and plot the detail view of the selected region in the lower axes """ def onselect(xmin, xmax): # indmin, indmax = np.searchsorted(x, (xmin, xmax)) # indmax = min(len(x)-1, indmax) indmin = xmin indmax = xmax onselect.listing.append([indmin, indmax]) print(onselect.listing) onselect.listing = listing # set useblit True on gtkagg for enhanced performance ax = self.axes span = SpanSelector(ax, onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red')) self.widget_list.append(span)
def edit_norm(_arg=None): # Only some backends pass in an argument. try: im, = images except ValueError: raise NotImplementedError from None array = im.get_array().ravel() sub_ax = plt.figure().subplots() sub_ax.hist(array, _hist_bins(im), histtype="stepfilled") if isinstance(im.norm, mpl.colors.LogNorm): sub_ax.set(xscale="log") def on_select(vmin, vmax): if vmin == vmax: im.set_clim((array.min(), array.max())) else: im.set_clim((vmin, vmax)) im.figure.canvas.draw() ss = sub_ax.__ss = SpanSelector(sub_ax, on_select, "horizontal", useblit=True, span_stays=True) ss.stay_rect.set(x=im.norm.vmin, width=im.norm.vmax - im.norm.vmin, visible=True) plt.show(block=False)
def __init__(self, data_list, title="Provide Title"): """ Parameters ---------- data_list: list List of 2-tuples of the form (xdata, ydata) where xdata and ydata are lists corresponding to x and y values to be plotted. xdata and ydata have the same length. title: string Title of plot """ self.data_list = data_list self.fig = plt.figure(figsize=(8, 6)) self.axes = self.fig.add_subplot(211) for data in self.data_list: self.axes.plot(data[0], data[1], '-o') self.axes.set_title(title) self.axes2 = self.fig.add_subplot(212) for data in self.data_list: line, = self.axes2.plot(data[0], data[1], '-o') self.span = SpanSelector(self.axes, self.onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red'))
def plot_zmap(self, zmap): self.zmap = zmap gs = gridspec.GridSpec(5, 1) self.fig = plt.figure(figsize=(8, 6)) self.ax1 = self.fig.add_subplot(gs[:4, :]) self.ax1.imshow(zmap) self.ax1.axes.get_xaxis().set_visible(False) self.ax1.axes.get_yaxis().set_visible(False) self.ax2 = self.fig.add_subplot(gs[4, :]) self.ax2.hist(zmap.flatten(), 100, range=(1, zmap.max()), fc='k', ec='k') self.ax2.axes.get_yaxis().set_visible(False) self.rect = Rectangle((0, 0), 0, self.ax2.get_ylim()[1], alpha=.2, color=(1, 0, 0)) self.ax2.add_patch(self.rect) self.span = SpanSelector(self.ax2, self.on_select, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red')) plt.show()
def __init__(self): QtGui.QMainWindow.__init__(self) self.title = ["Browse file"] slots = [self.browseFile] self.resize(200, 150) self.setWindowTitle('Align') self.segnali = [] self.picchi = [] self.ref = 0 self.fig, self.ax1 = plt.subplots(1, 1) self.shift = [] widget = QtGui.QWidget(self) grid = QtGui.QGridLayout(widget) grid.setVerticalSpacing(2) grid.setHorizontalSpacing(1) Browse_button = QtGui.QPushButton('Browse file', widget) self.connect(Browse_button, QtCore.SIGNAL('clicked()'), self.browseFile) self.span = SpanSelector(self.ax1, self.stp, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='green'))
def addRegion(self, _): self.index += 1 rangeselect.numRanges = self.index coordsList.append(rangeselect.coords.copy()) ax.patches[-1].set_facecolor('green') _ = SpanSelector(ax, rangeselect, 'horizontal', useblit=False, rectprops=dict(alpha=0.3, facecolor='red')) plt.draw()
def inspectLC(self): # create new window inspwin = tkinter.Tk() inspwin.title("Inspect Lightcurve") # information on selected bad data selectionsFrame = tkinter.Frame(inspwin) buttonsFrame = tkinter.Frame(selectionsFrame) self.inspClose = tkinter.Button(buttonsFrame, text="Save and Close", command=inspwin.destroy) self.inspClose.pack(side='left') self.inspDelete = tkinter.Button(buttonsFrame, text="Delete Selections", command=self.remove_spans) self.inspDelete.pack(side='left') buttonsFrame.pack(side='top', fill=tkinter.X) self.selectlistbox = tkinter.Listbox(selectionsFrame) self.selectlistbox.pack(side='bottom', fill=tkinter.Y) for item in self.lc_spans: self.selectlistbox.insert(tkinter.END, item) self.selectlistbox.bind('<<ListboxSelect>>', self.highlight_span) # plot of the lightcurve (above) and selected region (below) plottingFrame = tkinter.Frame(inspwin) self.baddataLabel = tkinter.Label(plottingFrame, text="Select Bad Data", font=('', 42)) self.baddataLabel.pack(side='top', fill=tkinter.BOTH) self.figInspLC, (self.axInspLC, self.selectedData) = plt.subplots(2, figsize=(12, 6)) self.axInspLC.plot(self.star_lc_all.time.value, self.star_lc_all.flux.value, 'k.') self.axInspLC.plot(self.star_lc.time.value[self.peaks], self.star_lc.flux[self.peaks], 'ob') self.axInspLC.grid() self.line2, = self.selectedData.plot(self.star_lc_all.time.value, self.star_lc_all.flux.value, 'r.') self.selectedData.grid() self.lcInspPlot = FigureCanvasTkAgg(self.figInspLC, plottingFrame) # add a toolbar for plot control toolbar = NavigationToolbar2Tk(self.lcInspPlot, plottingFrame) toolbar.update() self.lcInspPlot.get_tk_widget().pack(side='top', fill=tkinter.BOTH, expand=1) # selection tool for bad data self.spanSel = SpanSelector(self.axInspLC, self.onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red'), span_stays=True) self.lcInspPlot.mpl_connect('key_press_event', self.spanSel) self.lcInspPlot.mpl_connect('close_event', self.handle_close) plottingFrame.pack(side='left') selectionsFrame.pack(side='left')
def plot(self, channel): fig,ax = plt.subplots(nrows=1, ncols=1, figsize=(14,14)) ax[0].loglog(self.fb,self.Pb[channel]) ax[0].set(xlabel="Frequency (Hz)", ylabel="Power (V2/Hz)",); ax[0].set_xlim([1E-1, 1E4]) ax[0].set_ylim([1E-13, 1E-7]) fitplot, = ax[0].loglog(self.fb, self.Pfit[channel]) def onselect(xmin, xmax): #implement condition if range selected is not in fit range indmin, indmax = np.searchsorted(self.fb_fit, (xmin, xmax)) indmax = min(len(self.fb_fit) - 1, indmax) inds = np.arange(indmin, indmax+1, 1) thisx = self.fb_fit[indmin:indmax] thisy = self.Pb_fit[indmin:indmax] ax[0].loglog(thisx, thisy, c='r') fig.canvas.draw_idle() self.fb_fit = np.delete(self.fb_fit, inds) self.Pb_fit = np.delete(self.Pb_fit, inds) self.sorensen_fit() fitplot.set_data(self.fb, self.Pfit[2]) # save #np.savetxt("text.out", np.c_[thisx, thisy]) span = SpanSelector(ax[0], onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red')) plt.show()
def get_QT_interval(self, fig, ax, ax1, ax2, line2, qt_average_waveform, qt_all_spikes): """ This function allows the user to select the QT interval for a region of data. input: fig(plt.fig) ax, ax1, ax2(plt.fig.subplot) line2(plt.fig.subplot.plot([float])) qt_average_waveform([float]) qt_all_spikes([MCS_Spike]) """ ax.set_title(self.title) ax.plot(qt_average_waveform) for spike in qt_all_spikes: ax1.plot(spike.voltage_data) span = SpanSelector(ax, self.onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red')) plt.show(block=False) a = raw_input("Press any key... ") qt_start_point = self.indmin qt_end_point = self.indmax return qt_start_point, qt_end_point
def __init__(self, parent=None): super(Tdms_read, self).__init__(parent) self.setupUi(self) self.tdms_data = None self.figure_tdms = plt.figure(5) self.ax_tdms = self.figure_tdms.add_subplot(111) self.figure_tdms.subplots_adjust(left=0.1, right=0.9) self.canvas_tdms = FigureCanvas(self.figure_tdms) self.toolbar_tdms = NavigationToolbar(self.canvas_tdms, self) self.verticalLayout_tdms.addWidget(self.toolbar_tdms) self.verticalLayout_tdms.addWidget(self.canvas_tdms) self.tdms_is_view = False self.axs_tdms = self.ax_tdms.twinx() self.openfile.clicked.connect(self.loadtdms) self.plotdata.clicked.connect(self.plottdms) self.savedata.clicked.connect(self.savetdms) self.tdms_span = SpanSelector(self.axs_tdms, self.tdms_onselect, 'horizontal', useblit=True, button=3, rectprops=dict(alpha=0.3, facecolor='g'))
def plotFocusSelect(gui, guybrush, dataset, dataset2): def onselect(xmin, xmax): indmin, indmax = np.searchsorted(x, (xmin, xmax)) indmax = min(len(x) - 1, indmax) thisx = x[indmin:indmax] thisy = y[indmin:indmax] line2.set_data(thisx, thisy) ax2.set_xlim(thisx[0], thisx[-1]) ax2.set_ylim(thisy.min(), thisy.max()) gui.canvas.draw() gui.figure = plt.figure() gui.canvas = FigureCanvas(gui.figure) gui.toolbar = NavigationToolbar(gui.canvas, gui) gui.tabWidget_4.insertTab(0, gui.canvas, "Focus-Plot") x = [] for i in range(len(dataset)): x.append(i) y = np.asarray(dataset) ### PLOTTING #################################################### ax = gui.figure.add_subplot(211) ax.plot(x, y, color="black", lw=0.3, marker="+", label='Original') ax.plot(dataset2, color="grey", lw=1.0, linestyle=":", label='Smoothed Component', marker="p") #ax.plot(dataset2) ax.set_ylabel(guybrush.mst_labels[gui.comboBox_PI.currentIndex()]) ax.set_xlabel("t") ax.legend() ax2 = gui.figure.add_subplot(212) line2, = ax2.plot(x, y, label='Original', color="black", lw=0.3, marker="+") ax2.plot(dataset2, color='grey', label='Smoothed Component', lw=1.0, linestyle=":", marker="p") ax2.set_ylabel(guybrush.mst_labels[gui.comboBox_PI.currentIndex()]) ax2.set_xlabel("t") ax2.legend() # set useblit True on gtkagg for enhanced performance gui.figure.span = SpanSelector(ax, onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.3, facecolor='red'))
def __init__(self, master, path, toolitems): logging.basicConfig(filename='event_log.log', level=logging.INFO) FIGSIZE = (8, 3) self.window_id = next(self.id_generator) self.master = master self.toolitems = toolitems self.master.protocol("WM_DELETE_WINDOW", self.master.quit) master.title("BrainWave Visualization") master.state('zoomed') master.protocol("WM_DELETE_WINDOW", self.root_close) self.initialize_annotation_display() self.initialize_graph_display(FIGSIZE) self.project_path = path self.json_path = self.project_path + "annotations.json" try: self.data, self.timestamps, self.annotations = data.open_project( path) if self.annotations != []: if self.annotations[0] == -1: messagebox.showerror("Error: ", self.annotations[1]) self.annotations = [] self.draw_graph(self.data, self.timestamps, self.annotations) for id in self.annotations: id = id.id self.index_to_ids.append(id) for a in self.annotations: self.listb.insert(tkinter.END, a.title) except Exception as e: logging.error('Error during opening initial project') logging.error(e) messagebox.showerror("Error:", e) # put the plot with navbar on the tkinter window self.main_canvas.mpl_connect('button_release_event', self.butrelease) # add span selector to the axes but set it defaultly to not visible, # only activate it when the button annotate is pressed self.span = SpanSelector(self.main_graph_ax, self.onselect, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='red'), span_stays=True) self.span.set_visible(False) # create buttons for interaction self.annotate_button = Button(master, command=self.annotate) self.export_button = Button(master, command=self.export) self.close_button = Button(master, command=master.quit) # variables for storing min and max of the current span selection self.span_min = None self.span_max = None
def __init__(self, *args, **kwargs): MPLCanvas.__init__(self, *args, **kwargs) #inicijalizacija span selectora self.span = SpanSelector(self.axes, self.nakon_odabira, 'horizontal', useblit=True, rectprops=dict(alpha=0.4, facecolor='tomato'))