def set_maximums_and_minimums(self): x, y, z = zip(*self.plot) self.x = numpy.array(x) self.y = numpy.array(y) self.base = peakutils.baseline(self.y, 2) self.indices = peakutils.indexes(numpy.subtract(self.y,self.base), thres=0.3, min_dist=10) self.polar_side_maximums = [] for i in range(len(self.indices)): self.polar_side_maximums.append(self.plot[self.indices[i]]) # invert plot to find minimums radius_range = self.y.max()-self.y.min() inverted_y_plot = [] for i in range(len(self.y)): difference_from_range = radius_range - self.y[i] inverted_y_plot.append(difference_from_range + self.y.min()) self.inverted_y_plot = numpy.array(inverted_y_plot) self.min_base = peakutils.baseline(self.inverted_y_plot, 2) self.min_indices = peakutils.indexes(numpy.subtract(self.inverted_y_plot,self.min_base), thres=0.3, min_dist=10) self.polar_side_minimums = [] for i in range(len(self.min_indices)): self.polar_side_minimums.append(self.plot[self.min_indices[i]])
def set_maximums_and_minimums(self): x, y, z = zip(*self.plot) self.x = numpy.array(x) self.y = numpy.array(y) self.base = peakutils.baseline(self.y, 2) self.indices = peakutils.indexes(numpy.subtract(self.y, self.base), thres=0.3, min_dist=10) self.polar_side_maximums = [] for i in range(len(self.indices)): self.polar_side_maximums.append(self.plot[self.indices[i]]) # invert plot to find minimums radius_range = self.y.max() - self.y.min() inverted_y_plot = [] for i in range(len(self.y)): difference_from_range = radius_range - self.y[i] inverted_y_plot.append(difference_from_range + self.y.min()) self.inverted_y_plot = numpy.array(inverted_y_plot) self.min_base = peakutils.baseline(self.inverted_y_plot, 2) self.min_indices = peakutils.indexes(numpy.subtract( self.inverted_y_plot, self.min_base), thres=0.3, min_dist=10) self.polar_side_minimums = [] for i in range(len(self.min_indices)): self.polar_side_minimums.append(self.plot[self.min_indices[i]])
def calculate_ideal_baseline(np_array): p = [] for i in range(20): b = peakutils.baseline(np_array, i) res = np_array - b p += [calcProbability_conservative_np(res)] best = np.array(p).argmax() + 1 baseline = peakutils.baseline(np_array, best) return baseline
def root_baseline_correction(self, square=False): left, right = self.split_y_into_halfs() left = SfgSpectrum.remove_nan_and_negative(np.sqrt(left)) right = SfgSpectrum.remove_nan_and_negative(np.sqrt(right)) left_base = peakutils.baseline(left, deg=1) right_base = peakutils.baseline(right, deg=1) # todo: the general shape concat(left - left_base, right - right_base) may be abstracted return np.concatenate([left - left_base, right - right_base])
def find_peaks(x, thresh_from_baseline, min_dist=1): """ Algorithm for detecting peaks above the baseline. A peak should be `thresh_from_baseline` above the baseline to be detected. Parameters ---------- x : array Input array thresh_from_baseline : float Threshold for detecting peaks from the baseline, in dB min_dist : int Minimum distance between peak indices - Default : 1 Returns ------- peak_indexes_sel : array Peak indices peak_amp : array Peak amplitudes """ if not HAS_PEAKUTILS: raise ImportError('peakutils is not installed/available') x_scaled, old_range = peakutils.prepare.scale(x, (0, 1)) x_baseline = peakutils.baseline(x_scaled) thresh_norm = thresh_from_baseline / np.diff(old_range) x_corrected = (x_scaled - x_baseline) # thresh_norm_scaled = thresh_norm * (x_corrected.max() - x_corrected.min()) peak_indexes = peakutils.indexes(x_corrected, min_dist=min_dist) peak_indexes_sel = peak_indexes[x_corrected[peak_indexes] > thresh_norm] peak_amp = x[peak_indexes_sel] return peak_indexes_sel, peak_amp
def background_poly(separation: Separation, poly_order=3, skip_start=0, skip_end=0): """ Calculates a polynomial fit of the electropherogram :param separation: separation to analyze :param poly_order: polynomial order to use for the background :param skip_start: number of points to skip at start of separation :param skip_end: number of points to skip at the end of the separation :return: rfu_adjusted background, baseline :rtype: tuple """ # If polynomial is too large GigaCE freezes, this is a catch to prevent freezing assert poly_order < 10, "Poly Order to Large, please select reasonable polynomial" assert skip_end >= 0 and skip_start >= 0, "Skip parameters must be greater than 0" if skip_end == 0: skip_end_neg = None else: skip_end_neg = -skip_end base = peakutils.baseline( np.array(separation.rfu[skip_start:skip_end_neg]), poly_order) x_total = np.linspace(0, len(base) + skip_start + skip_end, len(base) + skip_end + skip_start) fit = np.polyfit(x_total[skip_start:skip_end_neg], base, poly_order) p = np.poly1d(fit) base = p(x_total) baseline = list(base) return np.subtract(separation.rfu, baseline), baseline
def processRecording(data): z = scipy.signal.savgol_filter(data, 11, 3) data2 = np.asarray(z,dtype=np.float32) a = len(data) base = peakutils.baseline(data2, 2) #x = np.linspace(0,a-1, dtype ='int', num = a) y = data2 - base #y=data directory = tk.filedialog.asksaveasfilename(defaultextension=".xls", filetypes=(("Excel Sheet", "*.xls"),("All Files", "*.*") )) if directory is None: # asksaveasfile return `None` if dialog closed with "cancel". return book = xlwt.Workbook(encoding="utf-8") sheet1 = book.add_sheet("Sheet 1") for i in range(a): sheet1.write(i,0,i) sheet1.write(i,1,y[i]) book.save(directory)
def get_baseline(s, var="radiance", Iunit=None): """Calculate and returns a baseline Parameters ---------- s: Spectrum Spectrum which needs a baseline var: str on which spectral quantity to read the baseline. Default ``'radiance'``. See :py:data:`~radis.spectrum.utils.SPECTRAL_QUANTITIES` Returns ------- baseline: Spectrum Spectrum object where intenisity is the baseline of s is computed by peakutils See Also -------- :py:func:`~radis.spectrum.operations.sub_baseline` """ import peakutils w1, I1 = s.get(var=var, Iunit=Iunit) baseline = peakutils.baseline(I1, deg=1, max_it=500) baselineSpectrum = Spectrum.from_array(w1, baseline, var, unit=Iunit, name=s.get_name() + "_baseline") return baselineSpectrum
def generate_standard_curve(file, ladder): #Finds peaks in ladder lane and calculates STD curve. #This can then be used to calculate the molecular weight of samples x= pandas.read_csv(file, delim_whitespace=True) x = x.ix[1:] np_array = np.array(x["Y"]) base = peakutils.baseline(np_array,2) indexes = peakutils.indexes(np_array,thres=0.1, min_dist=25) #Adjust these if peak calling fails for ladder lane! #plt.plot(np_array) #plt.show() print indexes if len(indexes) == len(ladder): #If we have found the wrong number of peaks max_STD = len(np_array) rf = indexes/len(np_array) ladder = np.array(ladder) ladder = np.log(ladder) #gets logs for log(molecular weights) vs distance linear regression. slope, intercept, r_value, pvalue, std_err = stats.linregress(rf,ladder) #Do some linear regression to get line statistics return [slope, intercept, r_value, max_STD] else: return "Error"
def get_peaks(file, thres_num, minimum, max_STD): #This function finds the peaks in data given to it. #Only used on sample lanes not ladder lane. #Variables thres_num and minimum cam be adjusted if neccecary. x= pandas.read_csv(file, delim_whitespace=True) x = x.ix[1:] #First row in bad so remove np_array = np.array(x["Y"]) plt.plot(np_array) plt.show() base = peakutils.baseline(np_array,2) #remove baseline to get better peak calling indexes = peakutils.indexes(np_array,thres=thres_num, min_dist=minimum) # find peaks #print indexes rf = indexes/max_STD return rf
def baseline(values, min_max="min", deg=7, ema_window=7, roll_window=7, max_it=200, tol=1e-4): """ Args: values (iterable(int)): min_max (str): Whether to calculate an upper or lower baseline. deg (int): The degree of the polynomial fitting. ema_window (int): Window for the exponential moving average. roll_window (int): Window for the simple moving average. max_it (int): Number of iterations for `peakutils.baseline`. tol (float): Least amount of change before termination of fitting \ in `peakutils.baseline`. Returns: np.array: the baseline. """ if min_max == "min": bound = np.min elif min_max == "max": bound = np.max else: raise NotImplementedError ema_baseline = _ema_baseline(values, bound, ema_window, roll_window) peakutils_baseline = peakutils.baseline(values, deg=deg, max_it=max_it, tol=tol) # Give double the weight to peakutil's values return (2/3 * np.mean([peakutils_baseline * 4/3, ema_baseline * 2/3], 0) + 1/3 * _als_baseline(values))
def get_baseline(s, var='radiance', wunit='nm', medium='air', Iunit=None): '''Calculate and returns a baseline Parameters ---------- s: Spectrum Spectrum which needs a baseline Returns ------- baseline: Spectrum Spectrum object where intenisity is the baseline of s is computed by peakutils See Also -------- :py:func:`~radis.spectrum.operations.sub_baseline` ''' import peakutils w1, I1 = s.get(var=var, Iunit=Iunit, wunit=wunit, medium=medium) baseline = peakutils.baseline(I1, deg=1, max_it=500) baselineSpectrum = Spectrum.from_array(w1, baseline, var, waveunit=wunit, unit=Iunit, conditions={'medium': medium}, name=s.get_name() + '_baseline') return baselineSpectrum
def __init__(self, w, u, thresh, window): """ AutoPeakSelector constructor. Parameters ---------- w : ndarray Array of frequency data. u : ndarray Array of the real component of the frequency response. thresh : float Threshold for minimum amplitude cutoff in peak selection. window : float Window size for local non-maximum supression. """ self.thresh = thresh self.window = window f = sp.interpolate.interp1d(w, u) self.w = np.linspace(w.min(), w.max(), int(len(w) * 100)) # arbitrary upsampling self.u = f(self.w) self.u_smoothed = sp.signal.savgol_filter(self.u, 11, 4) self.baseline = peakutils.baseline(self.u_smoothed, 0)[0] self.peaks = Peaks()
def get_spike_times_for_cc(abfdata, sweep_num, refrac=0.015, cleanup=True): spike_times = [] for channel in range(abfdata.channelCount): abfdata.setSweep(sweep_num, channel=channel) thresholds = [np.mean(peakutils.baseline(abfdata.sweepY[int(len(abfdata.sweepY)/10): int(len(abfdata.sweepY)*2/3)])) + 25, -50] peaks, _ = find_peaks(abfdata.sweepY, height=max(thresholds)) spike_times = spike_times + [abfdata.sweepX[point] for point in peaks] spike_times = sorted(spike_times) if not cleanup: return spike_times for p in range(10): to_remove = [] next_pass = True for i, t in enumerate(spike_times): if next_pass: next_pass = False pass else: if t - spike_times[i-1] < refrac: to_remove.append(i) next_pass = True for r in reversed(to_remove): spike_times.pop(r) return spike_times
def PPG_Peaks(data, freq, plot=False, remove_extreme=False): ''' Performs the peak detection in steps. filtering (lowpass and cubic), peak detections (adaptive treshold and minimum distance) and lastly find the amplitudes for each peak, from the baseline removed signal. ''' # filters _data = data _data = lowpass_butter_filter(_data) _data = extreme_removal(_data) if remove_extreme else _data _data = cubing_filter(_data) # peak detection provided by peakutils package, it uses adaptive treshold and minimum distance slice = 1/3 _peaks = indexes(_data, min_dist=freq*slice) peaks = [softTemplate(data, i, freq) for i in _peaks] # peak amps from filtered data amps = [_data[i] for i in peaks] if plot: b_data = data-baseline(data, 2) plot_data([data+10, b_data], labels=['PPG', 'PPG Baselined'], normalization=True, indice=(0,len(data))) #plot_data([None, b_data], peaksIndexs=[None,peaks], labels=[None,'PPG Baselined'], normalization=False, indice = (0,len(data))) #plot_data([None, None, _data], peaksIndexs=[None, None, _peaks], labels=[None,'PPG Baselined', 'PPG Filtered'], normalization=False, indice = (0,len(data))) #plot_data([data, None, _data], peaksIndexs=[peaks, None, _peaks], labels=['PPG', 'PPG Baselined','PPG Filtered'], normalization=False, indice = (0,len(data))) return peaks, amps
def filterRAW_by_fetures(self): # Filter Raw file with the theoretical chirp - Match filter convPk = convolve(self.raw_record, TheoreticalChirp[::-1]) convPk = convPk[2500:] # Crop the burst chirp r = arange(0, len(convPk)).dot( Cs / (2.0 * Fs)) #Calculate radius per sample number decay = convPk * r # inverse-square law # Locate peaks filtered = smooth(decay, window_len=11, window='hanning') #LPF base = baseline(abs(filtered), 10) #baseline fitting (bias) signal = abs(filtered) - base #The normal data th = C * mean((signal / max(signal))) # dynamic threshold pkslocs = indexes(signal, thres=th, min_dist=300) # Peak detection features = [] flag = 0 # Genrate features for loc in pkslocs: if loc < 100: continue r_for_peak = r[loc] # The raduis a = abs(fft(decay[loc - 60:loc + 60])).astype( float32) # The FFT computation with 120 samples window features.append(SonarFeature(r_for_peak, a[:len(a) / 2])) # Packing flag += 1 return features
def subtract_baseline_series(series, deg): """ Subtracts baseline from plot. :param series: Pandas Series, to be manipulated :param deg: Degree of polynomial degree for the baseline correction :return: Pandas Series, after correction """ return series - peakutils.baseline(series, deg)
def calc_baseline(self, order=0): """ Get Baseline :param order: polynomial order :return: baseline array np.ndarray() """ self.baseline = np.zeros(self.y.shape) self.baseline = peakutils.baseline(self.y, deg=order)
def get_baseline(intense, time, smooth_window=7, smooth_poly=1, baseline_poly=1, signal_weight=0.9, title='TIC', pola=''): # Savitzky–Golay滤波平滑 # 获得底部baseline smooth = signal.savgol_filter(intense, smooth_window, smooth_poly, mode='nearest') baseline_normal = peakutils.baseline(smooth, baseline_poly) # 获得顶部baseline intense_reverse = [-i for i in intense] smooth_reversed = signal.savgol_filter(intense_reverse, smooth_window, smooth_poly, mode='nearest') baseline_reversed = peakutils.baseline(smooth_reversed, baseline_poly) # 获得切割线,底部基线权重较大 midline = (baseline_normal - signal_weight * baseline_reversed) / 2 # 绘图 plot_detect_result(intense, time, smooth, baseline_normal, baseline_reversed, midline, title, pola) return smooth, midline
def calc_baseline(y): """ Calculate baseline of the well. Used for peak identification. """ try: baseline = peakutils.baseline(y) return baseline except Exception: return np.NaN
def update_baseline(self, val): # Remove the baseline from the data, plot the data without the baseline Mag = self.Mag freqSmooth = self.freqSmooth base = peakutils.baseline(1/Mag, polyOrder) plot2.set_data(freqSmooth/1e6, 20*np.log10(Mag*base)) ax2.relim() ax2.autoscale_view() fig.canvas.draw_idle() self.base = base
def plotit(self): i = self.getTic() base = pandas.DataFrame() base['retention_time'] = i['retention_time'] base['abundance'] = peakutils.baseline(i['abundance'], deg=6) #i['abundance'] = i['abundance'] - base['abundance'] mat, mit = putil.PUtil.peaksfr(i, 'abundance', 'retention_time') fig, ax = plt.subplots() ax.plot(i.get('retention_time'), i.get('abundance')) #mat = pandas.DataFrame(np.array(maxtab), columns=['retention_time', 'abundance']) #mit = pandas.DataFrame(np.array(mintab), columns=['retention_time', 'abundance']) ax.scatter(mat['retention_time'], mat['abundance'], color='blue') ax.scatter(mit['retention_time'], mit['abundance'], color='green') #base = pandas.DataFrame((i['retention_time'], peakutils.baseline(i['abundance'],deg=6)) , columns=['retention_time', 'abundance']) #print(base) #tot = mat.append(mit) areas = [] n = 0 cls = ['yellow', 'cyan'] for m in mat['retention_time']: nearest = putil.PUtil.strad(mit, 'retention_time', m) strt = nearest['retention_time'].min() end = nearest['retention_time'].max() #print (m, strt, end) istrt = putil.PUtil.nearest(i, 'retention_time', strt).iloc[0].name iend = putil.PUtil.nearest(i, 'retention_time', end).iloc[0].name #print (istrt, iend) #print(i['retention_time'][istrt:iend]) ax.fill_between(i['retention_time'][istrt:iend], i['abundance'][istrt:iend], color=cls[n % 2]) #print (m, nearest) #print (base.index.get_loc(nearest[0].index)) #nearest.iloc[0]['abundance'] - base.loc[nearest.iloc[0].name]['abundance'] #nearest.iloc[1]['abundance'] - base.loc[nearest.iloc[1].name]['abundance'] areas.append( scipy.integrate.trapz(i['abundance'][istrt:iend], i['retention_time'][istrt:iend])) n += 1 aread = pandas.DataFrame(np.array(areas), columns=['area']) mat['area'] = aread['area'] ax.plot(base['retention_time'], base['abundance'], color='red') mat['area'] = mat['area'] / mat['area'].max() ax.set(xlabel='time', ylabel='abundance', title='Ions') for idx, r in mat.iterrows(): ax.annotate('%.3f' % r['area'], xy=(r['retention_time'] + 0.05, r['abundance'] + 10000)) ax.grid() #fig.savefig("test.png") plt.show() return ax
def find_peaks(x, thresh_from_baseline, min_dist=1): x_scaled, old_range = peakutils.prepare.scale(x, (0, 1)) x_baseline = peakutils.baseline(x_scaled) thresh_norm = thresh_from_baseline / np.diff(old_range) x_corrected = (x_scaled - x_baseline) # thresh_norm_scaled = thresh_norm * (x_corrected.max() - x_corrected.min()) peak_indexes = peakutils.indexes(x_corrected, min_dist=min_dist) peak_indexes_sel = peak_indexes[x_corrected[peak_indexes] > thresh_norm] peak_amp = x[peak_indexes_sel] return peak_indexes_sel, peak_amp
def qrs_peak_detect(seg, qonset, soffset): base = peakutils.baseline(seg, 2) qrs_seg = seg[qonset:soffset + 1] pos_indexs = peakutils.peak.indexes(qrs_seg, thres=0.5, min_dist=20) + qonset neg_indexs = peakutils.peak.indexes(-qrs_seg, thres=0.3, min_dist=5) + qonset pos_indexs = [x for x in pos_indexs if seg[x] > base[x]] neg_indexs = [x for x in neg_indexs if seg[x] < base[x]] return pos_indexs, neg_indexs, base
def background(x, n=2, type='poly', max_it=100, tol=0.001): """Apply baseline reduction using baseline polynomial fitting or SNIP algorithm. This is a wrapper around peakutils.baseline and silx.math.fit.snip1d. """ if type not in ['poly', 'snip']: raise ValueError("type must be 'poly' or 'snip'") elif type == 'poly': return baseline(x, deg=n, max_it=max_it, tol=tol) else: return snip1d(x, snip_width=n)
def test_conditioning(self): data = data = load('exp') y = data[:, 1] mult = 1e-6 while mult < 100001: ny = y * mult base = peakutils.baseline(ny, 9) / mult self.assertTrue(0.8 < base.max() < 1.0) self.assertTrue(-0.1 <= base.min() < 0.1) mult *= 10
def remove_baseline(x, degree=3): """ Use the baseline function from peakutils to remove base line of x. which iteratively performs a polynomial fitting. deg (int (default: 3)) – Degree of the polynomial that will estimate the data baseline """ baseline_values = peakutils.baseline(x, deg=degree) x_removed = x - baseline_values return baseline_values, x_removed
def remove_baseline(xs, ys, return_xs=False, degree=5): ##Returns just ys unless otherwise specified ###Remove baseline with polynomial y2 = ys + np.polyval([0.001, -0.08, degree], xs) # y2 = ys base = peakutils.baseline(y2, 2) if return_xs: return (xs, y2 - base) else: return y2 - base
def correct_uv_baseline(self, plot=False): "Returns a baseline corrected UV trace. Requires peakutils and numpy." import peakutils import numpy as np time, step_no, numpy_uv = np.array( self.get_data('TIME_MS', 'STEP_NO', 'UV_VIS')) baseline = peakutils.baseline(numpy_uv, 3) numpy_uv_corrected = numpy_uv - baseline return list(zip(step_no, time, numpy_uv_corrected))
def subtract_baseline(df, deg, key=None, model=None): """ Takes DataFrame of spectrum, and correct its baseline by changing the values. :param df: DataFrame :param deg: int :param window: int :return: DataFrame """ df = df.copy() if key == LABELS['SINGLE']: df[LABELS['COR']] = df[model] - peakutils.baseline( df[LABELS['BS']], deg) elif key == LABELS['MS']: df[LABELS['COR']] = df[model] - peakutils.baseline( df[LABELS['BS']], deg) df.dropna(inplace=True) # TODO: why? else: for col in range(len(df.columns)): df.iloc[:, col] = df.iloc[:, col] - peakutils.baseline( df.iloc[:, col], deg) return df
def baseline_search(voltage, pol_degree): """ Uses PeakUtil package to find the baseline of the signal and returns it as a value. : params voltage : 1D array containing the input signal : params voltage : polynomial degree used in base line fitting : returns base : baseline of the signal """ min = np.min(voltage) base = peakutils.baseline(voltage-min, pol_degree, 10000, 0.05) base = base+min return base
def __init__(self, w, u, n, one_click=False): """ PeakSelector constructor. Parameters ---------- w : ndarray Array of frequency data. u, v : ndarray Arrays of the real and imaginary components of the frequency response. n : int Number of peaks to select. one_click : bool, optional Specify whether a single click will be used to select peaks (as opposed to two) """ self.u = u self.w = w self.n = n self.one_click = one_click # peak container self.peaks = Peaks() # empty list to store point information from clicks self.points = [] # initialize plot self.fig = plt.figure(1, figsize=(10, 8), dpi=150) ax = plt.subplot('111') plt.plot(w, u, linewidth=1, color='black') ax.spines['top'].set_color('none') ax.spines['left'].set_color('none') ax.spines['right'].set_color('none') ax.set_yticklabels([]) ax.tick_params(top='off', left='off', right='off') ax.set_xlabel('ppm', fontsize=16, fontweight='bold') ax.set_xlim((self.w.max(), self.w.min())) self.fig.tight_layout() # start event listener self.cid = self.fig.canvas.mpl_connect('button_press_event', self) self.baseline = peakutils.baseline(self.u, 0)[0] # display the plot plt.show()
def fit_gaus(self, y, baseline_deg=0): if baseline_deg != 0: import peakutils base = 1.0 * peakutils.baseline(y, baseline_deg) y = y - base y -= y.min() n = len(y) x = np.arange(n) #pixels p0 = [y.max(), y.argmax(), 10] popt, pcov = curve_fit(gaus, x, y, p0=p0) return popt #a,mean,sigma
def test_peaks(self): data = load('baseline') x, y = data[:, 0], data[:, 1] n_peaks = 2 prepared = y - peakutils.baseline(y, 3) idx = peakutils.indexes(prepared, thres=0.03, min_dist=5) for p in range(idx.size, 1): self.assertGreater(idx[p], 0) self.assertLess(idx[p], idx.size - 1) self.assertGreater(idx[p], idx[p - 1]) self.assertEqual(idx.size, n_peaks) assert_array_almost_equal(x[idx], numpy.array([1527.3, 1529.77]))
def benchit(): tests = [("Small - Low noise", make_data(200, 1.), 100), ("Small - High noise", make_data(200, 3.), 100), ("Big - Low noise", make_data(20000, 1), 5), ("Big - High noise", make_data(20000, 2.), 5)] for name, data, rep in tests: begin = timer() for _ in range(rep): y = data[1] - peakutils.baseline(data[1]) i = peakutils.indexes(y, thres=0.4, min_dist=y.size // 5) end = timer() each = (end - begin) / rep print("*{}* test took {:.3f} seconds each rep".format(name, each))
def change_vgram(): global peak_current, noise_filter, name, files, file_index, canvas, ax global vgramfwd, vgrambslrm, vgrambwd, vgrambsl, bsl_poly_box, first global dyn, x_pts, y_pts, fwdbwd_i, bsl_i, bsl_poly, rescale files = glob('*.csv') file = files[file_index] name = file[0:-4] df = read_csv(file) peak_current = 0 # check if data are filtered or not (column names change after filtering from the original KStat output if 'Potential' in df.columns: df.CurrentFiltered = df.CurrentFiltered * -1 potential_col = 'Potential' else: potential_col = 'potential' if 'CurrentFiltered' in df.columns: current_col = 'CurrentFiltered' else: current_col = 'current' df.current = df.current *-1 if noise_filter: df['CurrentIIR'] = iir_noise_filter(name, df, current_col) current_col = 'CurrentIIR' #split scan into forward and backward scans fwd = df[1:df[potential_col].idxmin()+1] bwd = df[df[potential_col].idxmin():] # remove previous current & baseline plots if existing and clear points, lines etc created by user # not executed in first iteration if not first: try: vgramfwd.remove() except: pass try: vgrambwd.remove() except: pass try: vgrambsl.remove() except: pass try: vgrambslrm.remove() except: pass for element in dyn: element.remove() dyn = [] x_pts = [] y_pts = [] # set plot parameters else: ax.invert_xaxis() plt.xlabel('Potential [mV]') plt.ylabel('Current [nA]') # update plot title to current name plt.title(name) # Plot current according to forward/backward mode if not in baseline subtraction mode if (fwdbwd_i == 0 or fwdbwd_i == 1) and bsl_i != 2: vgramfwd, = ax.plot(fwd[potential_col], fwd[current_col]*1000000000, color= '#0039ca') if (fwdbwd_i == 0 or fwdbwd_i == 2) and bsl_i != 2: vgrambwd, = ax.plot(bwd[potential_col], bwd[current_col]*1000000000, color = '#6487e1') # baseline plotting: if bsl_i != 0: # get polynomial degree from text box try: bsl_poly = int(bsl_poly_box.get()) except: pass #compute baseline bsl_df = Series(baseline(fwd[current_col], deg=bsl_poly, max_it=100, tol=.0000001)) # plot baseline with current or subtract it from current depending on baseline mode if bsl_i == 1: vgrambsl, = ax.plot(fwd[potential_col], bsl_df*1000000000, color= '#be6b12') if bsl_i == 2: bslrmvd = (fwd[current_col] - bsl_df).drop(0) vgrambslrm, = ax.plot(fwd[potential_col], bslrmvd*1000000000, color= '#0039ca') if rescale: # rescale the axes to fit the data (normally automatic but does not work fully in all instances) ax.relim() ax.autoscale() rescale = False first = False canvas.draw()
for y in y_axis: mean.append(float(basel)) highcut = basel + ((variance-basel)/15) lowcut = basel - ((variance-basel)/15) for a in range (0,len(two)): if two[a][1] > lowcut and two[a][1] < highcut: cut.append(two[a]) for m in range (0, len(cut)): cutx.append(cut[m][0]) cuty.append(cut[m][1]) base = peakutils.baseline(y_axis, 2) cutbase = peakutils.baseline(asarray(cuty), 2) pyplot.figure(figsize=(10,6)) pyplot.plot(x_axis, y_axis, label="data") pyplot.plot(x_axis, base, label = "baseline") pyplot.plot(x_axis, mean, label= "mean") pyplot.plot(cutx, cuty, label= "cut") pyplot.plot(cutx, asarray(cutbase), label = "cut baseline") pyplot.plot() pyplot.legend() pyplot.show()
# low, up, area = findArea(peak,x_axis,y_axis,basel) # peaknum = peaknum + 1 cutx, cuty = cutdata(x_axis, y_axis,15) mean = meanarray(y_axis) x_axis = asarray(x_axis) y_axis = asarray(y_axis) cutx = asarray(cutx) cuty = asarray(cuty) mean = asarray(mean) withoutpeaksx = asarray(withoutpeaksx) withoutpeaksy = asarray(withoutpeaksy) base = peakutils.baseline(y_axis, 2) cutbase = peakutils.baseline(cuty, 2) pyplot.figure(figsize=(10,6)) pyplot.plot(x_axis, y_axis, label="data") pyplot.plot(x_axis, base, label = "baseline") pyplot.plot(x_axis, mean, label= "mean") pyplot.plot(cutx, cuty, label= "cut") pyplot.plot(cutx, asarray(cutbase), label = "cut baseline") pyplot.plot(withoutpeaksx, withoutpeaksy, label = "without peaks") pyplot.plot() pyplot.legend()