def find_extrema(band, start_idx, end_idx, thresh): moda = [] # ищем положительные максимумы pos = start_idx + find_peaks(band[start_idx:end_idx+1], height=thresh)[0] for i in pos: moda.append((i, band[i])) # ищем отрицательные минимумы neg = start_idx + find_peaks(-band[start_idx:end_idx+1], height=thresh)[0] for i in neg: moda.append((i, band[i])) moda.sort() return moda
def findPeaksOneCase(binHeightL,indexToBinCenterL,binWidth,peakWidth,widthRelHeight,requiredProminence,leftPeakLimit,rightPeakLimit): '''Make one call to find_peaks. Peaks must be wider than peakWidth (which is given in units of score) and more prominent than requiredProminence, and fall between leftPeakLimit and rightPeakLimit. Returns tuple (peakHeight,peakPos,leftExtremeOfPeakPos,rightExtremeOfPeakPos) of any peaks that meet criteria. All position values are returned in units of score. ''' peakWidthInBins = peakWidth / binWidth # we always measure width widthRelHeight down from peak toward base peakIndL, propertiesD = find_peaks(binHeightL, width = peakWidthInBins, rel_height = widthRelHeight, prominence = requiredProminence) # make sure they are to the right of leftPeakLimit peakPosInScoreUnitsL = [] for i in range(len(peakIndL)): peakInd = peakIndL[i] peakHeight = binHeightL[peakInd] peakPos = indexToBinCenterL[peakInd] if leftPeakLimit < peakPos <= rightPeakLimit: # peak falls between the specified limits leftExtremeOfPeakPosInd = int(round(propertiesD["left_ips"][i])) leftExtremeOfPeakPos = indexToBinCenterL[leftExtremeOfPeakPosInd] rightExtremeOfPeakPosInd = int(round(propertiesD["right_ips"][i])) rightExtremeOfPeakPos = indexToBinCenterL[rightExtremeOfPeakPosInd] peakPosInScoreUnitsL.append((peakHeight,peakPos,leftExtremeOfPeakPos,rightExtremeOfPeakPos)) return peakPosInScoreUnitsL
def smooth_and_dering(outskyflux): outskyflux[np.isnan(outskyflux)] = 0. smthd_outflux = medfilt(outskyflux, 3) peak_inds, peak_props = find_peaks(outskyflux, height=(1500, 100000), width=(0, 20)) heights = peak_props['peak_heights'] ringing_factor = 1 + (heights // 1000) ring_lefts = (peak_inds - ringing_factor * (peak_inds - peak_props['left_bases'])).astype(int) peak_lefts = (peak_props['left_bases']).astype(int) ring_rights = (peak_inds + ringing_factor * (peak_props['right_bases'] - peak_inds)).astype(int) peak_rights = (peak_props['right_bases']).astype(int) corrected = smthd_outflux.copy() for rleft, pleft in zip(ring_lefts, peak_lefts): corrected[rleft:pleft] = smthd_outflux[rleft:pleft] for rright, pright in zip(ring_rights, peak_rights): corrected[pright:rright] = smthd_outflux[pright:rright] return corrected
def find_anchors(pos, min_count=3, min_dis=20000, wlen=800000, res=10000): from collections import Counter from scipy.signal import find_peaks, peak_widths min_dis = max(min_dis//res, 1) wlen = min(wlen//res, 20) count = Counter(pos) refidx = range(min(count)-1, max(count)+2) # extend 1 bin signal = np.r_[[count[i] for i in refidx]] summits = find_peaks(signal, height=min_count, distance=min_dis)[0] sorted_summits = [(signal[i],i) for i in summits] sorted_summits.sort(reverse=True) # sort by peak count peaks = set() records = {} for _, i in sorted_summits: tmp = peak_widths(signal, [i], rel_height=1, wlen=wlen)[2:4] li, ri = int(np.round(tmp[0][0])), int(np.round(tmp[1][0])) lb = refidx[li] rb = refidx[ri] if not len(peaks): peaks.add((refidx[i], lb, rb)) for b in range(lb, rb+1): records[b] = (refidx[i], lb, rb) else: for b in range(lb, rb+1): if b in records: # merge anchors m_lb = min(lb, records[b][1]) m_rb = max(rb, records[b][2]) summit = records[b][0] # always the highest summit peaks.remove(records[b]) break else: # loop terminates normally m_lb, m_rb, summit = lb, rb, refidx[i] peaks.add((summit, m_lb, m_rb)) for b in range(m_lb, m_rb+1): records[b] = (summit, m_lb, m_rb) return peaks
def __init__(self, wm, fm, f_x, coefs, all_wms, bounds=None,edge_line_distance=0.,initiate=True, fibname=''): self.bounds = bounds self.coefs = np.asarray(coefs,dtype=np.float64) p_x = np.arange(len(f_x)).astype(np.float64) self.p_x = p_x xspectra = fifth_order_poly(p_x,*coefs) deviation = edge_line_distance good_waves = ((wm>(xspectra[0]-deviation))&(wm<(xspectra[-1]+deviation))) wm,fm = wm[good_waves],fm[good_waves] good_waves = ((all_wms>(xspectra[0]-deviation))&(all_wms<(xspectra[-1]+deviation))) all_wms = all_wms[good_waves] del good_waves fydat = f_x - signal.medfilt(f_x, 171) fyreal = (f_x - f_x.min()) / 10.0 peaks,properties = signal.find_peaks(fydat) # find peaks fxpeak = xspectra[peaks] # peaks in wavelength fxrpeak = p_x[peaks] # peaks in pixels fypeak = fydat[peaks] # peaks heights (for noise) fyrpeak = fyreal[peaks] # peak heights noise = np.std(np.sort(fydat)[: (fydat.size //2)]) # noise level significant_peaks = fypeak > noise peaks = peaks[significant_peaks] fxpeak = fxpeak[significant_peaks] # significant peaks in wavelength fxrpeak = fxrpeak[significant_peaks] # significant peaks in pixels fypeak = fyrpeak[significant_peaks] # significant peaks height line_matches = {'lines': [], 'peaks_p': [], 'peaks_w': [], 'peaks_h': []} for j in range(wm.size): line_matches['lines'].append(wm[j]) # line positions line_matches['peaks_p'].append(fxrpeak[np.argsort(np.abs(wm[j] - fxpeak))][0]) # closest peak (in pixels) line_matches['peaks_w'].append( fxpeak[np.argsort(np.abs(wm[j] - fxpeak))][0]) # closest peak (in wavelength) line_matches['peaks_h'].append(fypeak[np.argsort(np.abs(wm[j] - fxpeak))][0]) # closest peak (height) yspectra = fyreal self.lastind = 0 self.j = 0 self.px = p_x self.all_wms = all_wms self.wm = wm self.fm = fm self.xspectra = xspectra self.yspectra = yspectra self.peaks = peaks self.peaks_w = fxpeak self.peaks_p = fxrpeak self.peaks_h = fypeak self.line_matches = line_matches self.mindist_el, = np.where(self.peaks_w == self.line_matches['peaks_w'][self.j]) self.fibname = fibname self.last = {'j':[],'lines':[],'peaks_h':[],'peaks_w':[],'peaks_p':[],'vlines':[],'wm':[],'fm':[]} if initiate: self.initiate_browser()
def run_automated_calibration(coarse_comp, complinelistdict, last_obs=None, print_itters = True, only_use_peaks = True): precision = 1e-4 convergence_criteria = 1.0e-5 # change in correlation value from itteration to itteration waves, fluxes = generate_synthetic_spectra(complinelistdict, compnames=['HgAr', 'NeAr','Xe'],precision=precision,\ maxheight=10000.,minwave=3400,maxwave=7500) ## Make sure the information is in astropy table format coarse_comp = Table(coarse_comp) # for fib in ['r209','r711','r808']: # if fib in coarse_comp.colnames: # coarse_comp.remove_column(fib) ## Define loop params counter = 0 ## Initiate arrays/dicts for later appending inside loop (for keeping in scope) all_coefs = {} all_flags = {} ## Loop over fiber names (strings e.g. 'r101') ##hack! cam = coarse_comp.colnames[0][0] if cam =='b': numerics = np.asarray([(16 * (9 - int(fiber[1]))) + int(fiber[2:]) for fiber in coarse_comp.colnames]) else: numerics = np.asarray([(16 * int(fiber[1])) + int(fiber[2:]) for fiber in coarse_comp.colnames]) sorted = np.argsort(numerics) fibernames = np.array(coarse_comp.colnames)[sorted] if cam == 'r' and int(fibernames[0][1]) > 3: fibernames = fibernames[::-1] elif cam =='b' and int(fibernames[0][1]) < 6: fibernames = fibernames[::-1] burnin = 6; fibernames = np.concatenate([fibernames[:burnin], fibernames[1:burnin - 1][::-1], fibernames]) for counter,fiber_identifier in enumerate(fibernames):#['r101','r408','r409','r608','r816']: #print("\n\n", fiber_identifier) ## Get the spectra (column with fiber name as column name) comp_spec = np.asarray(coarse_comp[fiber_identifier]) if only_use_peaks: ## Find just the peaks in the calibration spectrum c_peak_inds, c_peak_props = find_peaks(comp_spec, height=(400, None), width=(0.1, 20), \ threshold=(None, None), prominence=(200, None), wlen=101) ## create pixel array for mapping to wavelength c_peak_inds = np.asarray(c_peak_inds) # randoms = np.random.randint(low=0,high=len(comp_spec),size=120) randoms = np.arange(len(comp_spec))[::2] pix1 = np.concatenate((c_peak_inds,c_peak_inds-1,c_peak_inds+1,c_peak_inds-2,c_peak_inds+2,randoms)) pix1 = np.unique(np.sort(pix1)) pix1 = pix1[pix1<len(comp_spec)] comp_spec = comp_spec[pix1] #comp_spec[pix1<400] *= 100. else: pix1 = np.arange(len(comp_spec)) abest, bbest, cbest, corrbest = 0., 0., 0., 0. alow, ahigh = 3000, 8000 awidth, bwidth, cwidth = 12, 0.005, 5.0e-6 if last_obs is None or fiber_identifier not in last_obs.keys(): if counter == 0: avals = (alow, ahigh+1, 1) bvals = (1.0,1.01,0.1) cvals = (0, 1.0, 2) if print_itters: print("\nItter 1 results, (fixing c to 0.):") abest, trashb, trashc, corrbest = fit_using_crosscorr(pixels=pix1, raw_spec=comp_spec, comp_highres_fluxes=fluxes, \ avals=avals, bvals=bvals, cvals=cvals, \ calib_wave_start=waves[0], flux_wave_precision=precision,\ print_itters=print_itters) avals = (abest-40, abest+41, 0.5) bvals = (0.96,1.04,0.005) cvals = (-1.0e-5, 1.0e-5, 1.0e-6) if print_itters: print("\nItter 1 results, (fixing c to 0.):") abest, bbest, cbest, corrbest = fit_using_crosscorr(pixels=pix1, raw_spec=comp_spec, comp_highres_fluxes=fluxes, \ avals=avals, bvals=bvals, cvals=cvals, \ calib_wave_start=waves[0], flux_wave_precision=precision,\ print_itters=print_itters) elif counter < 3: compare_fiber = fibernames[counter - 1] [trasha, bbest, cbest, trash1, trash2, trash3] = all_coefs[compare_fiber] if (bbest < 0.96) or (bbest>1.04): bbest = 1.0 cbest = 0. astep,bstep,cstep = 0.5, 0.04, 8.0e-6 avals = (alow, ahigh+astep, astep) bvals = (bbest , bbest+bstep , bstep) cvals = (cbest , cbest+cstep , cstep) if print_itters: print("\nItter 1 results, (fixing b and c to past vals):") abest, trashb, trashc, corrbest = fit_using_crosscorr(pixels=pix1, raw_spec=comp_spec, comp_highres_fluxes=fluxes, \ avals=avals, bvals=bvals, cvals=cvals, \ calib_wave_start=waves[0], flux_wave_precision=precision,\ print_itters=print_itters) else: compare_fiber1 = fibernames[counter - 1] [a1, b1, c1, trash1, trash2, trash3] = all_coefs[compare_fiber1] compare_fiber2 = fibernames[counter - 2] [a2, b2, c2, trash1, trash2, trash3] = all_coefs[compare_fiber2] compare_fiber3 = fibernames[counter - 3] [a3, b3, c3, trash1, trash2, trash3] = all_coefs[compare_fiber3] abest = np.median([a1, a2, a3]) bbest = np.median([b1, b2, b3]) cbest = np.median([c1, c2, c3]) if (bbest < 0.96) or (bbest>1.04): bbest = 1.0 cbest = 0. astep,bstep,cstep = 0.5, 0.04, 8.0e-6 aw = 30 avals = (abest-aw, abest+aw+astep, astep) bvals = (bbest , bbest+bstep , bstep) cvals = (cbest , cbest+cstep , cstep) if print_itters: print("\nItter 1 results, (fixing b and c to past vals):") abest, trashb, trashc, corrbest = fit_using_crosscorr(pixels=pix1, raw_spec=comp_spec, comp_highres_fluxes=fluxes, \ avals=avals, bvals=bvals, cvals=cvals, \ calib_wave_start=waves[0], flux_wave_precision=precision,\ print_itters=print_itters) #awidth, bwidth, cwidth = 10,\ # max([ min([ bwidth,np.max(bbest)-np.min(bbest) ]), 1.0e-3 ]),\ # max([ min([ cwidth,np.max(cbest)-np.min(cbest) ]), 1.0e-7 ]) else: [abest, bbest, cbest, trash1, trash2, trash3] = last_obs[fiber_identifier] awidth, bwidth, cwidth = awidth/2., bwidth/2., cwidth/2. if print_itters: print("\nItter 1 results:") print("--> Using previous obs value of: a={:.2f}, b={:.5f}, c={:.2e}".format(abest, bbest, cbest)) astep,bstep,cstep = 0.5, bwidth/10., cwidth/10. dcorr = 1. for itter in range(100): if print_itters: print("\nItter {:d} results:".format(itter+2)) last_corrbest = corrbest incremental_res_div = 4. astep, bstep, cstep = astep/incremental_res_div, bstep/incremental_res_div, cstep/incremental_res_div awidth,bwidth,cwidth = awidth/incremental_res_div,bwidth/incremental_res_div,cwidth/incremental_res_div avals = ( abest-awidth, abest+awidth+astep, astep ) bvals = ( bbest-bwidth, bbest+bwidth+bstep, bstep ) cvals = ( cbest-cwidth, cbest+cwidth+cstep, cstep ) abest_itt, bbest_itt, cbest_itt, corrbest = fit_using_crosscorr(pixels=pix1, raw_spec=comp_spec, comp_highres_fluxes=fluxes, \ avals=avals, bvals=bvals, cvals=cvals, \ calib_wave_start=waves[0], flux_wave_precision=precision,\ print_itters=print_itters) if corrbest > last_corrbest: abest,bbest,cbest = abest_itt, bbest_itt, cbest_itt dcorr = np.abs(corrbest-last_corrbest) if dcorr < convergence_criteria: break print("\n\n", fiber_identifier) print("--> Results: a={:.2f}, b={:.5f}, c={:.2e}".format(abest, bbest, cbest)) all_coefs[fiber_identifier] = [abest, bbest, cbest, 0., 0., 0.] all_flags[fiber_identifier] = corrbest return Table(all_coefs)
def find_peaks(xn, min_prominence=30, min_spacing=2): peaks, props = signal.find_peaks(y, prominence=min_prominence, distance=min_spacing) return peaks
plt.plot(t, phi, label='Numerical Result') #plotting numerical result plt.plot(t_test, phi_test, label='Analytical Result') #plotting test case plt.title('Numerical vs. Analytical Pendulum Motion') plt.xlabel('Time (s)') plt.ylabel('Pendulum Angle (radians)') plt.grid(True) plt.legend() #%% Find pendulum frequency as a function of initial angle from scipy.signal import find_peaks #we will use this to find peaks phi0s = np.linspace(0.01, 3, 25) #a range of initial angles freqs = [] #list to contain frequencies tmax = 30 #maximum time for integration for phi0 in phi0s: #loop through every initial angle t, phi = integrate(phi0) #integrate the diff. eq. for each angle peaks = find_peaks(phi) #find the peaks of the solution curve period = t[peaks[0][1]] - t[peaks[0][0]] #subtract adjacent peaks to find period freq = 1/period #calculate frequency from period freqs.append(freq) #add frequency to list plt.figure(2) #plot frequency vs. initial angle plt.plot(phi0s, freqs) plt.title('Frequency of Pendulum vs. Initial Angle') plt.xlabel('Initial angle (radians)') plt.ylabel(r'Frequency $(s^{-1})$') #%% Damped pendulum motion dt = 0.001 #step size t0 = 0 #initial condition for t phi0 = 0.1 #initial condition for the solution curve f(x) dfdt0 = 0 #initial condition for the derivative of phi
def collect_peaks(self, voiced_list, windowed_data, window_length): import numpy as np x = float(self.N.text()) N = int(x) all_peaks = [] peak_frames = [] for i, frame in enumerate(windowed_data): if i in (voiced_list): dft_frame = np.fft.fft(frame, N) ceps_frame = np.real( np.fft.ifft(np.log10(np.abs(np.fft.fft(frame, N))))).reshape( (N, 1)).ravel() total = [] total = np.array(total) ones = np.ones((1, 15)) zeros = np.zeros((1, (1024 - (2 * 15)))) lif = np.concatenate((ones, zeros, ones), axis=1).ravel() ceps_frame = ceps_frame * lif dft_frame = np.fft.fft(ceps_frame, N) dft_frame = abs(dft_frame) peaks, _ = find_peaks(dft_frame[:int(len(dft_frame) / 2)], height=0) all_peaks.append(peaks) """zeros = np.zeros((1,1024)).ravel() for peak in list(peaks): zeros[peak]=10000 total = zeros + dft_frame peak_frames.append(total)""" smooth_peaks = self.makeSmooth(all_peaks, window_length) #print("smooth_peaks",smooth_peaks) peak_frames = [] k = 0 for i, frame in enumerate(windowed_data): if i in (voiced_list): #print("frame:",i) dft_frame = np.fft.fft(frame, N) ceps_frame = np.real( np.fft.ifft(np.log10(np.abs(np.fft.fft(frame, N))))).reshape( (N, 1)).ravel() total = [] total = np.array(total) ones = np.ones((1, 15)) zeros = np.zeros((1, (1024 - (2 * 15)))) lif = np.concatenate((ones, zeros, ones), axis=1).ravel() ceps_frame = ceps_frame * lif dft_frame = np.fft.fft(ceps_frame, N) dft_frame = abs(dft_frame) peaks = smooth_peaks[k] #print("Peaks:", peaks) k = k + 1 zeros = np.zeros((1, 1024)).ravel() for peak in list(peaks): zeros[peak] = 1000000 total = zeros + dft_frame peak_frames.append(total) return peak_frames
theta = find_tilt_y(x_acc, y_acc, z_acc) figs, axs = plt.subplots(3, 1) axs[0].plot(time, y_acc) axs[0].set_title('18 inch pendulum') axs[0].set_ylabel('y acc (in/s^2)') axs[1].plot(time, x_acc) axs[1].set_ylabel('x acc (in/s^2)') axs[2].plot(time, theta) axs[2].set_ylabel('theta (degrees)') axs[2].set_xlabel('time (s)') return plt.show() #script x_acc_filt = sig.medfilt(x_acc) x_pks, _ = sig.find_peaks(x_acc_filt) new_time = time[x_pks] period = [] for x in range(len(new_time) - 1): y = new_time[x + 1] - new_time[x] period += [y] period_18 = np.average(period) #plots()
def analyze_gsr(self, threshold): # create list to store analysis result gsr_result = [] gsr_result.append([]) # for plesant gsr_result.append([]) # for neutral gsr_result.append([]) # for unplesant # If not initial user, applay adpative threhold & increase signal by adaptive threshold if self.user_order != 1: threshold = self.find_adaptiveT() # Increase signal of user2 using adaptive threshold for i in range(len(self.videoGSR)): for j in range(len(self.videoGSR[i])): for m in range(len(self.videoGSR[i][j])): self.videoGSR[i][j][ m] = self.videoGSR[i][j][m] * threshold threshold = emotional_analysis.initialT / threshold else: emotional_analysis.initialT = threshold # Analyize for i in range(len(self.videoGSR)): if i == 0: print("**************** Neutral ****************\n") elif i == 1: print("**************** Pleasant ****************\n") else: print("**************** Unpleasant ****************\n") for j in range(len(self.videoGSR[i])): _peaks, _ = find_peaks(self.videoGSR[i][j], height=threshold) # Find Max Peak if len(_peaks) != 0: # When there is more than one peak peak_value = [] # list for peak's y value for peak_index in _peaks: peak_value.append( self.videoGSR[i][j][peak_index]) # peak's y value max_peak = np.max(peak_value) max_peak_index = _peaks[peak_value.index(max_peak)] print("max_peak :", max_peak) print("max_peak_index :", max_peak_index) # Exclude peak that do not affect to result for better accuracy if max_peak_index > 9900 and max_peak_index < 12000 and ( max_peak >= 0.036 and max_peak < 0.037) or ( max_peak < 0.35 and max_peak > 0.3): _peaks = [] if (len(_peaks) >= 1): print("Emotion : pleasant or unpleasant") gsr_result[i].append(1) else: print("Emotion : neutral") gsr_result[i].append(0) plt.ylim(-1, 1) plt.axis(option='auto') plt.plot(self.videoGSR[i][j]) plt.show() print("\n") self.gsr_result = gsr_result print("Neutral: ", gsr_result[0].count(0)) print("Pleasant:", gsr_result[1].count(1)) print("Unpleasant:", gsr_result[2].count(1))
directory = 'wrspice_data/constant_drive/from_saeed/4jj/' # directory = 'wrspice_data/fitting_data' # dend_cnst_drv_Llft08.00pH_Lrgt22.00pH_Ide78.00uA_Idrv30.00uA_Ldi0077.50nH_taudi0775ms_dt00.1ps.dat I_drive = I_drive_list[ii] file_name = 'dend_cnst_drv_Llft{:05.2f}pH_Lrgt{:05.2f}pH_Ide{:05.2f}uA_Idrv{:05.2f}uA_Ldi0077.50nH_taudi0775ms_dt00.1ps.dat'.format( L_left_list[pp], L_right_list[pp], I_de_list[qq], I_drive) data_dict = read_wr_data(directory + '/' + file_name) # find peaks for each jj time_vec = data_dict['time'] j_di = data_dict['v(4)'] # j_di = data_dict['v(5)'] # j_di_peaks, _ = find_peaks(j_di, height = jph[pp][qq][ii]) j_di_peaks, _ = find_peaks(j_di, height=min_peak_height, distance=min_peak_distance) initial_ind = (np.abs(time_vec - 2.0e-9)).argmin() final_ind = j_di_peaks[-1] * 2 * downsample_factor # if len(j_di_peaks) > 1: # final_ind = j_di_peaks[-1]*2*downsample_factor # else: # final_ind = initial_ind+downsample_factor*window_size time_vec = time_vec[initial_ind:final_ind] j_di = j_di[initial_ind:final_ind] # find fluxon generation rate I_di = data_dict['i(L4)'] I_di = I_di[initial_ind:final_ind]
def split(self, plot=False): ''' split returns a dataframe of the original array which excludes all arrays belonging to ELM's. It also returns a hot array with 0 for all intra-elm indices and 1 for all elm indices (the ones that were excluded from the dataframe. ''' if hasattr(self, 'elmdf'): return self.elmdf pm = self.arr[1].T stop = self.stop_height # default 1500 pm_norm = (pm[:, stop:] - np.amin(pm[:, stop:])) / ( np.amax(pm[:, stop:]) - np.amin(pm[:, stop:])) sums = np.sum(pm_norm, axis=1) peaks, props = find_peaks(sums, distance=10, prominence=(0.5, None), width=(10, 50), rel_height=0.95) l_elms = props['left_ips'] r_elms = props['right_ips'] r_elms = np.asarray([*map(np.ceil, r_elms)]).astype(int) l_elms = np.asarray([*map(np.floor, l_elms)]).astype(int) l_elms_time = self.arr[0][l_elms] r_elms_time = self.arr[0][r_elms] if plot: fig, ax = plt.subplots(1, 1) self.heatmap2d(ax=ax) for t in l_elms_time: ax.axvline(t, ymin=stop / self.arr[1].shape[0], c='red') for t in r_elms_time: ax.axvline(t, ymin=stop / self.arr[1].shape[0], c='green') plt.show() # make dict with keys, values, times elm_cycles = {} elms = list(zip(l_elms_time, r_elms_time)) for elm_no, _ in enumerate(elms[:-1]): if elms[elm_no + 1][0] - elms[elm_no][ 1] <= self.min_elm_window: # default min_elm_window = 50 continue start_ielm = index_match(self.arr[0], elms[elm_no][1]) stop_ielm = index_match(self.arr[0], elms[elm_no + 1][0]) for ielm_time in self.arr[0][start_ielm:stop_ielm]: ielm_index = np.argwhere(self.arr[0] == ielm_time)[0][0] elm_cycles[(elm_no, ielm_index, ielm_time, self.arr[0][stop_ielm] - ielm_time)] = self.arr[1].T[ielm_index] # elm_cycles[(elm_no, ielm_index, ielm_time, (ielm_time - self.arr[0][start_ielm]) / # (self.arr[0][stop_ielm] - self.arr[0][start_ielm]))] = self.arr[1].T[ielm_index] index = pd.MultiIndex.from_tuples( elm_cycles.keys(), names=['ELM_No', 'Index', 'Time (ms)', 'T - ELM (ms)']) # index = pd.MultiIndex.from_tuples(elm_cycles.keys(), names=['ELM_No', 'Index', 'Time (ms)', '% ELM']) self.elmdf = pd.DataFrame(elm_cycles.values(), index=index) return self.elmdf
def threshold_protocol(f, fi, Vm_trail, sampling_rate, trace_unit, protocol_unit): global Threshold_voltage fig = plt.figure(figsize=(16, 5)) ax1 = fig.add_subplot(121) ax2 = fig.add_subplot(122) thresh_state = 0 iter_num = 0 trace_num = 0 for v in enumerate(Vm_trail): iter_num += 1 trace_number = v[0] trace = v[1][0] time = v[1][1] v = np.copy(trace) t = np.copy(time) if thresh_state == 0: Vm = str(np.around(np.mean(v[0:299]), decimals=2)) del_Vm = str( np.around( (np.mean(v[len(v) - 300:len(v)]) - np.mean(v[0:299])), decimals=2)) v_lowercut = v t = time v_lowercut[v_lowercut < -50] = -50 v_smooth = butter_bandpass_filter(v_lowercut, 1, 500, sampling_rate, order=1) peaks = signal.find_peaks(x=v_smooth, height=None, threshold=None, distance=None, prominence=5, width=None, wlen=None, rel_height=0.5, plateau_size=None) v_cut = butter_bandpass_filter(v_smooth, 50, 500, sampling_rate, order=1) v_peaks = v_smooth t_peaks = t thr_peak = 3 if trace[peaks[0]].any() > 0: thresh_state = 1 dv = np.diff(v_smooth) dt = np.diff(t) dv_dt = dv / dt dv_dt_max = np.max(dv / dt) v_dt_max = np.where(dv_dt == dv_dt_max)[0] - 20 t_dt_max = np.where(dv_dt == dv_dt_max)[0] - 20 ax1.scatter(time[peaks[0] - 10], trace[peaks[0] - 10], color='r', label='spike') ax1.plot(t, v, alpha=0.5, label='smoothened') ax1.plot(time, trace, alpha=0.5, label=f'raw trace no. {iter_num}') ax1.scatter(time[t_dt_max], trace[v_dt_max], label="threshold", color='k') Threshold_voltage = "firing threshold = " + str( np.around(trace[v_dt_max][0], decimals=2)) trace_num = iter_num plt.figtext(0.10, 0.0, Threshold_voltage + "mV", fontsize=12, va="top", ha="left") plt.figtext(0.10, -0.05, "membrane voltage = " + Vm + "mV", fontsize=12, va="top", ha="left") plt.figtext(0.10, -0.10, "membrane voltage difference = " + del_Vm + "mV", fontsize=12, va="top", ha="left") P_traces = protocols[0] iter_num_p = 0 Threshold_injection = "NA" for p in P_traces: iter_num_p += 1 if iter_num_p == 1: for i in p: t_ = len(i) / sampling_rate t = np.linspace(0, float(t_), len(i)) ax2.plot(i, color='g') elif iter_num_p == trace_num: c_inj = [] for i in p: t_ = len(i) / sampling_rate t = np.linspace(0, float(t_), len(i)) ax2.plot(i, color='k') c_inj.append(i) Threshold_injection = "Injected current at threshold = " + str( np.max(c_inj)) elif iter_num_p == len(P_traces): for i in p: t_ = len(i) / sampling_rate t = np.linspace(0, float(t_), len(i)) ax2.plot(i, color='r') First_inj = mpatches.Patch(color='green', label='First injection') Thres_inj = mpatches.Patch(color='black', label='Threshold injection') Last_inj = mpatches.Patch(color='red', label='Final injection') ax2.legend(handles=[First_inj, Thres_inj, Last_inj]) plt.figtext(0.55, 0.0, Threshold_injection + "pA", fontsize=12, va="top", ha="left") ax1.set_title('Recording') ax1.set_ylabel(trace_unit) ax1.set_xlabel('time(s)') ax1.legend() ax2.set_title('Protocol trace') ax2.set_ylabel(protocol_unit) ax2.set_xlabel('time(s)') # ax2.legend() plt.suptitle(f'Protocol type: {protocol_type} - {protocol_used}', fontsize=15) plt.figtext(0.10, -0.15, f"sampling rate = {sampling_rate}", fontsize=12, va="top", ha="left") plt.figtext(0.10, -0.20, f"total recording time = {total_time}", fontsize=12, va="top", ha="left") outfile = str(outdir) + "/" + str(f.stem) + f" {protocol_used}_{fi}.png" plt.savefig(outfile, bbox_inches='tight') print("-----> Saved to %s" % outfile) fig = plt.close()
def visualize_om_prod_overlap(prod_df, om_df, prod_col_dict, om_col_dict, prod_fldr, e_cumu, be_cumu, samp_freq="H", pshift=0.0, baselineflag=True): """ Creates Plotly figures of performance data overlaid with coinciding O&M tickets. A separate figure for each site in the production data frame (prod_df) is generated. Parameters ---------- prod_df: DataFrame A data frame corresponding to the performance data after (ideally) having been processed by the perf_om_NA_qc and overlappingDFs functions. This data frame needs to contain the columns specified in prod_col_dict. om_df: DataFrame A data frame corresponding to the O&M data after (ideally) having been processed by the perf_om_NA_qc and overlappingDFs functions. This data frame needs to contain the columns specified in om_col_dict. prod_col_dict: dict of {str : str} A dictionary that contains the column names relevant for the production data - **siteid** (*string*), should be assigned to associated site-ID column name in prod_df - **timestamp** (*string*), should be assigned to associated time-stamp column name in prod_df - **energyprod** (*string*), should be assigned to associated production column name in prod_df - **irradiance** (*string*), should be assigned to associated irradiance column name in prod_df. Data should be in [W/m^2]. om_col_dict: dict of {str : str} A dictionary that contains the column names relevant for the O&M data - **siteid** (*string*), should be assigned to column name for user's site-ID - **datestart** (*string*), should be assigned to column name for user's O&M event start-date - **dateend** (*string*), should be assigned to column name for user's O&M event end-date - **workID** (*string*), should be assigned to column name for user's O&M unique event ID - **worktype** (*string*), should be assigned to column name for user's O&M ticket type (corrective, predictive, etc) - **asset** (*string*), should be assigned to column name for affected asset in user's O&M ticket prod_fldr: str Path to directory where plots should be saved. e_cumu: bool Boolean flag that specifies whether the production (energy output) data is input as cumulative information ("True") or on a per time-step basis ("False"). be_cumu: bool Boolean that specifies whether the baseline production data is input as cumulative information ("True") or on a per time-step basis ("False"). samp_freq: str Specifies how the performance data should be resampled. String value is any frequency that is valid for pandas.DataFrame.resample(). For example, a value of 'D' will resample on a daily basis, and a value of 'H' will resample on an hourly basis. pshift: float Value that specifies how many hours the performance data should be shifted by to help align performance data with O&M data. Mostly necessary when resampling frequencies are larger than an hour baselineflag: bool Boolean that specifies whether or not to display the baseline (i.e., expected production profile) as calculated with the irradiance data using the baseline production data. A value of 'True' will display the baseline production profile on the generated Plotly figures, and a value of 'False' will not. Returns ------- list List of Plotly figure handles generated by function for each site within prod_df. """ # assigning dictionary items to local variables for cleaner code om_site = om_col_dict["siteid"] om_date_s = om_col_dict["datestart"] om_date_e = om_col_dict["dateend"] om_wo_id = om_col_dict["workID"] om_wtype = om_col_dict["worktype"] om_asset = om_col_dict["asset"] prod_site = prod_col_dict["siteid"] prod_ts = prod_col_dict["timestamp"] prod_ener = prod_col_dict["energyprod"] prod_baseline = prod_col_dict[ "baseline"] # if none is provided, using iec_calc() is recommended # creating local dataframes to not modify originals prod_df = prod_df.copy() om_df = om_df.copy() # Setting multi-indices for ease of plotting prod_df.set_index([prod_site, prod_ts], inplace=True) prod_df.sort_index(inplace=True) om_df.set_index([om_site, om_date_s], inplace=True) om_df.sort_index(inplace=True) figs = [] for i in prod_df.index.get_level_values(0).unique(): # Resampling the performance data to obtain daily energy production # (different between cumulative and non-cumulative energy output) if e_cumu: # energy data is cumulative over time, so take difference between # largest and smallest value on any given day tstep = np.diff(prod_df.loc[i].index)[2] / np.timedelta64(1, "s") if samp_freq == "H" and tstep >= 3599: # 3599 to consider roundoff error enrg_site = prod_df.loc[i, prod_ener].diff() elif samp_freq == "T" and tstep >= 59.9: enrg_site = prod_df.loc[i, prod_ener].diff() else: enrg_site = (prod_df.loc[i, prod_ener].resample( samp_freq, label="left").max() - prod_df.loc[i, prod_ener].resample( samp_freq, label="left").min()) else: # energy data is given on a per TIMESTEP basis, therefore... enrg_site = (prod_df.loc[i, prod_ener].resample(samp_freq, label="left").sum()) # Resampling baselineE and assigning to separate variable to not resample entire data frame. if be_cumu: # baseline energy cumulative over time baseline_site = (prod_df.loc[i, prod_baseline].resample( samp_freq, label="left").max() - prod_df.loc[i, prod_baseline].resample( samp_freq, label="left").min()) else: # baseline energy is on a per time-step basis baseline_site = (prod_df.loc[i, prod_baseline].resample( samp_freq, label="left").sum()) # shifting time for prod_df and baseline baseline_site.index += pd.Timedelta(hours=pshift) enrg_site.index += pd.Timedelta(hours=pshift) # finding where energy dips: first by location/index (by integer, not # index location => use iloc), and then by converting to dates using original index edips_all = find_peaks(enrg_site * -1)[0] edips_all_dates = enrg_site.index[edips_all] # Finding the corresponding closest dip to each OM om_date_s for # each ticket: first by location/index, and then by converting those # indices to dates edips_nearom_indices = [ np.argmin(abs(edips_all_dates - xx)) for xx in om_df.loc[i].index ] edips_nearom_dates = edips_all_dates[edips_nearom_indices] # Adding the nearest performance-dip-date to the OM data frame om_df.loc[i, "corr_perfDip"] = edips_nearom_dates # Taking largest value of daily output(perf-data) to create a [ficticious] # plot-value/column for OM-data => "_h" implies hover text om_df.loc[i, "perfval_plotcol"] = enrg_site.max() om_start_h = 0.75 # To place StartDate points in visible region om_end_h = 0.5 # To place EndDate points below the StartDate points om_reg_h = 1.05 # To make the om-region slightly higher than the perf data # Correction for om-region if baseline for production data is plotted if baselineflag: om_reg_hcorr = baseline_site.max() / enrg_site.max() else: om_reg_hcorr = 1.0 # initializing plotly-figure fig = plotly.graph_objects.Figure( layout_yaxis_range=[-5, enrg_site.max() * om_reg_h * om_reg_hcorr]) # plotting all Perf data for i-th site (captured in enrg_site) if samp_freq == "D": perf_name = "Daily Energy" baseline_name = "Daily Baseline" elif samp_freq == "H": perf_name = "Hourly Energy" baseline_name = "Hourly Baseline" fig.add_trace( plotly.graph_objects.Scatter(x=enrg_site.index, y=enrg_site.values, name=perf_name)) if baselineflag: fig.add_trace( plotly.graph_objects.Scatter(x=baseline_site.index, y=baseline_site.values, name=baseline_name)) # For loop to add shaded regions for each ticket, where left side of the region corresponds # to the EventStart (index of om data in this case), and right side of region corresponds # to the EventEnd. These two dates make the edges of the region, x below. for j in range(len(om_df.loc[i])): fig.add_trace( dict( type="scatter", x=[om_df.loc[i].index[j], om_df.loc[i, om_date_e][j]], y=om_df.loc[i, "perfval_plotcol"].values[0:2] * om_reg_h * om_reg_hcorr, mode="markers+lines", line=dict(width=0), marker=dict(size=[0, 0]), fill="tozeroy", fillcolor="rgba(190,0,0,.15)", hoverinfo="none", showlegend=False, name="OM Ticket", )) # Adding EventStart Points with hover-text fig.add_trace( plotly.graph_objects.Scatter( x=om_df.loc[i].index, y=om_df.loc[i, "perfval_plotcol"].values * om_start_h, mode="markers", hovertemplate="Start: " + "%{x} <br>" + "WO#: " + om_df.loc[i, om_wo_id].astype(str) + "<br>" + "Type: " + om_df.loc[i, om_wtype].astype(str) + "<br>" + "Asset: " + om_df.loc[i, om_asset].fillna("Asset_NA").astype(str) + "<br>" + "Nearest Prod Dip: " + om_df.loc[i, "corr_perfDip"].dt.strftime("%b %d, %Y"), name="OM_start", )) # Adding EventEnd Points with hover-text fig.add_trace( plotly.graph_objects.Scatter( x=om_df.loc[i, om_date_e], y=om_df.loc[i, "perfval_plotcol"].values * om_end_h, mode="markers", hovertemplate="End: " + "%{x} <br>" + "WO#: " + om_df.loc[i, om_wo_id].astype(str) + "<br>" + "Type: " + om_df.loc[i, om_wtype].astype(str) + "<br>" + "Asset: " + om_df.loc[i, om_asset].fillna("Asset_NA").astype(str), name="OM_end", )) # Setting y-axes and title fig.update_yaxes(title_text="Energy Delivered (kWh)") fig.update_layout(title_text="Site: " + i) # appending fig object to figs list figs.append(fig) # Saving Figure fig.write_html(prod_fldr + "/" + i + ".html") # Resetting index before completion of function since DFs are mutable prod_df.reset_index(inplace=True) om_df.reset_index(inplace=True) return figs
import numpy as np import matplotlib.pyplot as plt from scipy.signal import find_peaks x = (np.sin(2 * np.pi * (2**np.linspace(2, 10, 1000)) * np.arange(1000) / 48000) + np.random.normal(0, 1, 1000) * 0.15) print(x) peaks, _ = find_peaks(x, distance=20) peaks2, _ = find_peaks(x, prominence=1) # BEST! peaks3, paek3_property = find_peaks(x, height=0, prominence=1) peaks4, _ = find_peaks( x, threshold=0.4 ) # Required vertical distance to its direct neighbouring samples, pretty useless print(paek3_property["peak_heights"]) print(paek3_property["prominences"]) print(paek3_property["left_bases"]) left_bases = paek3_property["left_bases"] bottom_values = x[left_bases] print("peaks", x[peaks3]) print("bottom val", bottom_values) peak_heights = x[peaks3] - bottom_values print("peak hieight", peak_heights, " mean ", peak_heights.mean()) plt.subplot(2, 2, 1) plt.plot(peaks, x[peaks], "xr") plt.plot(x) plt.legend(["distance"])
def MUSIC(inputs, options, log=logging): """MUSIC implementation of Multiple SIgnal Classification (MUSIC) algorithm as described in [3]. Inputs: in: in.array: String containing array name: 'eigenmike', 'dicit', 'dummy', 'benchmark2' in.y: Data matrix in.fs: Sampling frequency [Hz] in.timestamps: Vector of timestamps at which DoA estimates must be PROVIDED in.time: 6xT matrix of system clock times in.array.rotation: Rotation matrix describing array orientation in 3D for each timestamp in.array.mic: Matrix describing microphone positions for each timestamp opts: Settings structure generated by init() Outputs: out: out.source: N x 1 struct array, one element for each N estimated sources. In this function: N = 1 (single-source) out.source(src_idx).azimuth: Tx1 vector of azimuth estimates, where T is the number of timestamps in in.timestamps out.source(src_idx).elevation: Tx1 vector of elevation estimates out.source(src_idx).time: Tx1 vector of system time values of estimates (must be identical to in.time!) out.source(src_idx).timestamps: Tx1 vector of timestamps of estimates (must be identical to in.timestamps!) References: [1] J. Benesty, C. Jingdong, and I. Cohen, Design of Circular Differential Microphone Arrays. Springer, 2015. [2] I. Cohen, J. Benesty, and S. Gannot, Speech Processing in Modern Communication, vol. 3. Berlin, Heidelberg: Springer Science & Business Media, 2009. [3] H. L. Van Trees, Detection, Estimation, and Modulation Theory, Optimum Array Processing. John Wiley & Sons, 2004. """ az = np.linspace(-np.pi, np.pi, 73) # Resolution of azimuth: 5 dg el = np.linspace(0, np.pi, 19) # Resolution of elevation: 10 dg if inputs.array_name == 'dicit': subarray = np.array([6, 7, 9]) ref_mic = 1 elif inputs.array_name == 'benchmark2': subarray = np.arange(12).astype(np.int) ref_mic = 1 elif inputs.array_name == 'eigenmike': subarray = np.arange(32).astype(np.int) ref_mic = 1 elif inputs.array_name == 'dummy': subarray = np.arange(4).astype(np.int) ref_mic = 1 else: log.error('Array type {} does not exists'.format(inputs.array_name)) sys.exit(1) # MUSIC numMic = subarray.shape[0] fftPoint = 1024 frame_duration = 0.03 frames_per_block = 100 # Number of frames per block block_step = 10 frame_length = int(frame_duration * inputs.fs) # -> OptiTracker sampling rate # Unique timestamps: opti_timestamps, unique_idx = np.unique(inputs.timestamps, return_index=True) opti_rotation = inputs.array.rotation[:, unique_idx] opti_mics = inputs.array.mic[:, unique_idx] duration = inputs.y.shape[0] inputs.y = np.asfortranarray(inputs.y) # -> STFT X = np.stack([ librosa.stft(inputs.y[:, ch], n_fft=fftPoint, hop_length=frame_length // 4, win_length=fftPoint, window='hamming', pad_mode='reflect') for ch in subarray ], axis=1) X = X.transpose(2, 0, 1) frame_timestamp = librosa.samples_to_time(np.arange( 0, duration, frame_length // 4), sr=inputs.fs) fft_freq = librosa.fft_frequencies(sr=inputs.fs, n_fft=fftPoint) nframe = frame_timestamp.shape[0] # Check that the frame times and Optitracker times intersect: opti_timestamps = opti_timestamps[opti_timestamps < frame_timestamp[-1]] # -> MUSIC # Make blocks out of frames: frame_srt = np.arange(0, nframe - 1, block_step) frame_end = np.arange(frames_per_block, nframe, block_step) frame_end = np.pad(frame_end, (0, frame_srt.shape[0] - frame_end.shape[0]), 'constant', constant_values=nframe - 1) nblocks = frame_srt.shape[0] block_timestamps = np.mean( [frame_timestamp[frame_srt], frame_timestamp[frame_end]], axis=0) # Bandlimit signals to avoid spatial aliasing / low freq effects: # NOTE: This is crucial for the DICIT array, the other arrays can be # evaluated for fullband signals. valid_freq_idx = (800 < fft_freq) * (fft_freq < 1400) valid_freq = fft_freq[valid_freq_idx] valid_X = X[:, valid_freq_idx] _power = np.zeros([fftPoint // 2 - 1, az.shape[0], el.shape[0], nblocks]) for block_idx in range(nblocks): for freq_idx in range(valid_freq.shape[0]): # fftPoint/2-1 # Block of FFT frames: # print(freq_idx, block_idx) data_block = np.squeeze( valid_X[frame_srt[block_idx]:frame_end[block_idx], freq_idx, :]) if data_block.shape[0] > 1: # ensure svd does not result in empty U # Find nearest OptiTrac sample: _diff = block_timestamps[block_idx] - opti_timestamps closest_opti_idx = np.argmin(_diff) # Autocorrelation Rxx = np.dot(data_block.T, np.conj(data_block)) # Rxx = U * S * U^H, see [3] eq. (9.32) U, _, _ = np.linalg.svd(Rxx) # [3] eq. (9.37), using spectral sparsity assumption: # Signal subspace is 1 dimensional if 1 source is active, hence D = 1 Un = U[:, 1:] for a_idx in range(az.shape[0]): for e_idx in range(el.shape[0]): az_idx = az[a_idx] el_idx = el[e_idx] # [2] eq (8.35) modified s.th. az = 0 and el = pi/2 result in eta = [0 1 0], # i.e., pointing along y-axis: eta = np.array([ -np.sin(el_idx) * np.sin(az_idx), np.sin(el_idx) * np.cos(az_idx), np.cos(el_idx) ])[:, None] rot_eta = np.dot( np.squeeze(opti_rotation[:, closest_opti_idx, :]), eta) # [2] eq (8.36) - TDoA: tau = 1 / options.c * np.dot( rot_eta.T, np.squeeze(opti_mics[:, closest_opti_idx, subarray]) - np.repeat( opti_mics[:, closest_opti_idx:closest_opti_idx + 1, subarray[ref_mic]], numMic, axis=1)) # [2] eq (8.34) - Steering vector: SV = np.exp(1j * 2 * np.pi * valid_freq[freq_idx] * tau).T # [3] eq. (9.44): _power[freq_idx, a_idx, e_idx, block_idx] = 1. / np.sum( np.abs( np.linalg.multi_dot( [SV.conj().T, Un, Un.conj().T, SV]))) # Sum spectra over all frequencies: _spectrum = _power.sum(0).transpose(2, 0, 1) # -> Find DOA # NOTE: Single-source assumption azimuth = np.full([nblocks], np.nan) elevation = np.full([nblocks], np.nan) for block_idx in range(nblocks): if _spectrum.shape[2] == 1: # find_peak code for 1 elevation locs = find_peaks(_spectrum[block_idx, :]) if len(locs) > 0: azimuth[block_idx] = az[locs[0]] else: mesh_spec = np.squeeze(_spectrum[block_idx, :, :]) # Extract regional maxima: lm = maximum_filter(mesh_spec, 1) # Global maximum: loc = np.argmax(lm) loc_az, loc_el = np.unravel_index(loc, mesh_spec.shape) azimuth[block_idx] = az[loc_az] elevation[block_idx] = el[loc_el] # -> Interpolate estimates to OptiTracker timestamps # Interpolate MUSIC estimates to required time stamps: # Use left np.NaN to be compatible with the matlab code. interp_azimuth = np.interp(inputs.timestamps, block_timestamps, azimuth, left=np.NaN) interp_elevation = np.interp(inputs.timestamps, block_timestamps, elevation, left=np.NaN) # Output 1 - interpolated N_sources = 1 out = Namespace() out.source = list() for _ in range(N_sources): noNaN = ~np.isnan(interp_azimuth) interp_azimuth[noNaN] = wrapToPi(interp_azimuth[noNaN]) noNaN = ~np.isnan(interp_elevation) interp_elevation[noNaN] = wrapToPi(interp_elevation[noNaN]) results = dict( year=inputs.time.dt.year, month=inputs.time.dt.month, day=inputs.time.dt.day, hour=inputs.time.dt.hour, minute=inputs.time.dt.minute, second=inputs.time.dt.second + inputs.time.dt.microsecond / 1e6, timestamps=inputs.timestamps, azimuth=interp_azimuth, elevation=interp_elevation, ) out.source.append(results) return out
def __init__(self, src=None, ax=None, alt_views=None, interpolate=True, norm=True, crop=None, fix_rotations=False): """crop: only take first x seconds of clip""" if src is None: Tk().withdraw() # we don't want a full GUI, so keep the root window from appearing src = askopenfilename(initialdir=DataSources.c3d_data) # Load correct file self.name = src.split("\\")[-1][:-4] else: self.name = src.split("\\")[-1][:-4] print("LOADING", src) if not os.path.isfile(src): src = os.path.join(DataSources.c3d_data, src) # If relative reference, append to directory with open(src, 'rb') as handle: reader = c3d.Reader(handle) self._reader = reader # Extract meta data from file n_markers = reader.header.point_count # Work out the total number of markers n_frames = reader.header.last_frame - reader.header.first_frame + 1 freq = reader.header.frame_rate labels = str(reader.groups["POINT"].params["LABELS"].bytes)[ 2:] # Extract text of all labels, separated by many spaces # Convert separating spaces into commas for spaces in [25 - i for i in range(15)]: labels = labels.replace(" " * spaces, ", ") marker_labels = labels.split(", ")[:n_markers] data = [] for i, points, analog in reader.read_frames(): frame_data = [] # Analog gives force plate data (I think) for n, point in enumerate(points): x, y, z, *_ = point # Points gives x, y, z, error, n_cameras frame_data.append([x, y, z]) data.append(frame_data) def interpolate_zero_vals(data): """Gievn a time series of (x,y,z) points, identifies any ranges of (0,0,0) values, and replaces these with interpolated values either side of the zero range """ is_zero = lambda arr: np.linalg.norm(arr) == 0 for n, pos in enumerate(data): if n == 0: continue if n + 2 >= len(data): continue if is_zero(pos): # if 0 found, search ahead to find the range for which this goes on, and then begin interpolation n_start = n n_finish = n + 1 while n_finish + 2 <= len(data) and is_zero(data[n_finish]): n_finish += 1 # Note: n_start = index of first zero value # n_finish = index of first NON ZERO value # now the start and finish of the zero range is found start = Vector(*data[n_start - 1]) finish = Vector(*data[n_finish]) # Perform interpolation for i in range(n_finish - n_start): data[n_start + i] = (start + (finish - start) * (i + 1) / (n_finish - n_start + 1)) data = interpolate_zero_vals(data) # Run recursively to restart search for zeros break # end this search within this run of the function return data # Split up into individual marker time series, interpolate each individually, and then combine together # for processing if interpolate: data = list(zip(*[interpolate_zero_vals(list(marker_data)) for marker_data in zip(*data)])) # REMOVE ROTATIONAL MODES OF PAWS. IDENTIFY SIGNIFICANT TROUGHS, SET TO (0, 0, 0) data = np.array(data) if fix_rotations: for idx in [n for n, i in enumerate(marker_labels) if "paw" in i]: vert_data = data[:, idx, 2] troughs, properties = signal.find_peaks(-vert_data, prominence=5, rel_height=.1, width=(None, 5)) # print(signal.peak_widths(-vert_data, troughs, rel_height=0.1)[0]) window = 10 # n frames to look before for start of trough for t in troughs: # go backwards to find where paw starts rotating (change in sign of grad) prev_cusps = np.where(np.diff(vert_data[t - window:t]) > 0)[0] # cusps before trough if len(prev_cusps) == 0: continue # skip ones where previous cannot be found rot_start = t - window + 1 + prev_cusps[-1] # idx of start of trough next_higher = np.where(vert_data[rot_start + 1:] >= vert_data[rot_start])[ 0] # next time vert is at a higher value if len(next_higher) == 0: continue rot_end = rot_start + 1 + next_higher[0] # replace trough with linear interpolation x = np.arange(rot_end - rot_start) m = (vert_data[rot_end] - vert_data[rot_start]) / (rot_end - rot_start) vert_data[rot_start: rot_end] = vert_data[rot_start] + m * x # if idx == 23: # plt.plot(vert_data) # plt.scatter(troughs, vert_data[troughs]) # plt.show() if crop: data = data[:int(freq * crop)] super().__init__(ax, data, freq=freq, marker_labels=marker_labels, norm=norm) # self.n_frames = i self.get_bounds() ### FIXES FOR MOCAP DATA THAT IS MISSING MARKERS: if "set_1" in src: self.create_averaged_marker("front top", "left front upper", "right front upper") # form new joint at the front top of the system self.create_averaged_marker("right front ankle", "right front knee", "right front paw") # right front ankle missing from data, for now just add as avg if "set_2" in src: self.create_averaged_marker("front top", "left front upper", "right front upper") # form new joint at the front top of the system self.create_averaged_marker("rear top", "right rear upper", "left rear upper") # form new joint at the front top of the system self.create_averaged_marker("left rear ankle", "left rear knee", "left rear paw") # right front ankle missing from data, for now just add as avg
def analyze_hr(self, threshold_hr, distance): # create list to store analysis result hr_result = [] hr_result.append([]) # for plesant hr_result.append([]) # for neutral hr_result.append([]) # for unplesant for i in range(len(self.videoHR)): if i == 0: print("**************** Neutral ****************\n") elif i == 1: print("**************** Pleasant ****************\n") else: print("**************** Unpleasant ****************\n") for j in range(len(self.videoHR[i])): error = 0 # there is error -> 1 / not error -> 0 # Peak detection for compute heart rate _peaks, _ = find_peaks(self.videoHR[i][j], height=threshold_hr, distance=distance) peak_time = [] for t in range(1, len(_peaks)): peak_time.append(60 / ((_peaks[t] - _peaks[t - 1]) / 2000)) # If the time between the two peaks is greater than 0.05, # It's highly likely that the peak wasn't found properly. # Therefore, the threshold should be lowered. if peak_time[t - 1] > 0.05: error += 1 # if if error != 0: # If there are problems -> set threahold to -0.03 & again peak detection _peaks, _ = find_peaks(self.videoHR[i][j], height=-0.03, distance=distance) # Compute heart rate using distance between peaks peak_time = [ 60 / ((_peaks[t] - _peaks[t - 1]) / 2000) for t in range(1, len(_peaks)) ] # Find Max Peak if len(_peaks) != 0: # When there is more than one peak peak_value = [] # list for peak's y value for peak_index in _peaks: peak_value.append( self.videoHR[i][j][peak_index]) # peak's y value max_peak = np.max(peak_value) max_peak_index = _peaks[peak_value.index(max_peak)] print("max_peak :", max_peak) print("max_peak_index :", max_peak_index) if (len(_peaks) >= 1): # there is peak plt.plot(_peaks, peak_value, "or") plt.plot(self.videoHR[i][j]) plt.show() # original data self.videoHR[i][j] = [ 60 / ((_peaks[t] - _peaks[t - 1]) / 2000) for t in range(1, len(_peaks)) ] peak_sec = [ _peaks / 2000 for _peaks in _peaks if _peaks / 2000 <= 3 ] peak_befo = peak_sec.index( np.max(peak_sec)) # peak index before 3s peak_after = peak_befo + 1 # peak index after 3s # Compute average using heart rate of 3 seconds before event avg_heart = np.mean(self.videoHR[i][j][:peak_befo]) # Compute deviation of 6 seconds after event using heart rate average self.videoHR[i][j] = self.videoHR[i][j] - avg_heart plt.axis(option='auto') plt.plot(self.videoHR[i][j]) # calculated heart rate plt.show() print("\n")
Y = np.loadtxt("data/martix_mu1_vs_a_gamma_IC4.txt") # -------------------------------------- Result visualization ----------------------------------- plt.rcParams['font.family'] = 'sans-serif' plt.rcParams['font.weight'] = 'bold' plt.rcParams['font.sans-serif'] = ['Tahoma'] plt.rcParams.update({'font.size': 22}) fig = plt.figure(2) # color1 = 'tab:red' color1 = 'k' size_of_fig = 8 fig.set_size_inches(size_of_fig + 6, size_of_fig + 2) for i in range(5): peaks = sign.find_peaks(Y[:, i]) for j in peaks[0]: Y[j, i] = (Y[j - 1, i] + Y[j + 1, i]) / 2. # for i in np.arange(0,100, 1): # tests = [0, 1, 5, 10, 20] tests = [0, 24, 48, 72, 96] for i in [0, 1, 2, 3, 4]: plt.plot(a_s, Y[:, i], color=color1, linewidth=4) # if i ==0: # plt.text(np.max(a_s) - 3 * (a_s[-1] - a_s[-2]), np.max(Y[:, i])+0.0008, # '$\gamma={0}$'.format(round(A_s[tests[i]], 8))) plt.text( np.max(a_s) - 5. * (a_s[-1] - a_s[-2]), np.max(Y[:, i]), '$\gamma={0}$'.format(round(gF_s[tests[i]], 8)))
def plot_peaks(df, abase, distance=120, height=""): y = df[abase] peaks, _ = find_peaks(df[abase], distance=distance) plt.plot(df[abase].index, df[abase]) plt.plot(peaks, y[peaks], "x") plt.show()
from intervals import Interval from matplotlib import rcParams import matplotlib.pyplot as plt import math as m from PIL import Image from scipy.optimize import curve_fit import matplotlib.patches as mpatches from scipy.signal import find_peaks a = np.loadtxt('Q3b.csv', delimiter=",", skiprows=1) x=a[:,0] y=a[:,1] peaks, _ = find_peaks(y, distance=100) fig, ax = plt.subplots() rcParams['font.family']='sans-serif' rcParams["legend.fancybox"] = False rcParams['font.sans-serif']=['Helvetica'] #ax.set_xlim(0, 0.7) ax.set_ylim(0, 260) ax.plot(x, y,color='black', linewidth=1.0, label='data') ax.plot(x[peaks], y[peaks], "x") ax.set_xlabel("Distance(pixels)",size=14) ax.set_ylabel("Intensity(a.u.)",size=14)
import pandas as pd import numpy as np import matplotlib.pyplot as plt from scipy import signal df = pd.read_csv('ecg1.csv') ecg = df['ECG (500 Hz)'] # normalizo ecg = ecg - np.min(ecg) ecg = ecg / np.max(ecg) # plt.plot(ecg) # plt.show() # Encuentro picos onda R # threshold = 0.3 # aux = ecg > threshold # aux = ecg*aux # plt.plot(aux) # plt.show() # ind_peaks, _ = signal.find_peaks(aux) ind_peaks, _ = signal.find_peaks(ecg, height=0.3) print(ind_peaks) plt.plot(ecg) plt.plot(ind_peaks, ecg[ind_peaks], 'ro') plt.show()
i = 1 while i < len( time ): # update position, velocity, and acceleration using previous values and time step thetaNext, wNext, accNext = update_system(acc[i - 1], theta[i - 1], w[i - 1], time[i - 1], time[i]) theta.append(thetaNext) w.append(wNext) acc.append(accNext) i += 1 short_theta = np.array( theta[::20] ) #finds peaks, filters out so only every 20th point is considered short_time = time[::20] theta_pks, _ = sig.find_peaks(short_theta) acc_pks, _ = sig.find_peaks(acc) time_of_pks = short_time[ theta_pks] #makes x and y values so the peaks can be graphed short_theta_pks = short_theta[theta_pks] period = [] avg_period = [] average = 0 i = 1 while i < len(time_of_pks): #filters out peaks that are too close together if abs(time_of_pks[i - 1] - time_of_pks[i]) > .75: period.append(time_of_pks[i]) i = i + 1
def find_features(X): ############################# FEATURE DANIEL ##################################### # Analyse the peaks in the signal peaks = [] peaks_index = [] peaks_heights = [] max_height = np.zeros((len(X), 1)) mean_height = np.zeros((len(X), 1)) var_height = np.zeros((len(X), 1)) for ecg in range(len(X)): peaks.append(find_peaks(X[ecg, :], height=0.7, distance=10)) #find peaks peaks_index.append(peaks[ecg][0]) peaks_heights.append(peaks[ecg][1]['peak_heights']) if peaks_heights[ecg].size == 0: peaks_heights[ecg] = [0] else: peaks_heights[ecg] = peaks_heights[ecg] max_height[ecg, 0] = np.max( peaks_heights[ecg]) #FEATURE: Max height of peak mean_height[ecg, 0] = np.mean( peaks_heights[ecg]) #FEATURE: Mean height of peak var_height[ecg, 0] = np.var( peaks_heights[ecg]) #FEATURE: Variance in peak heigh peaks_int_max = np.zeros((len(peaks_index), 1)) peaks_int_min = np.zeros((len(peaks_index), 1)) peaks_int_med = np.zeros((len(peaks_index), 1)) peaks_int_mean = np.zeros((len(peaks_index), 1)) peaks_int = [] for ecg in range(len(peaks_index)): A = [] for peak in range(len(peaks_index[ecg]) - 1): A.append(peaks_index[ecg][peak + 1] - peaks_index[ecg][peak]) peaks_int.append(np.array(A)) if peaks_int[ecg].size == 0: peaks_int[ecg] = [0] else: peaks_int[ecg] = peaks_int[ecg] peaks_int_max[ecg, 0] = np.max( peaks_int[ecg]) # FEATURE: maximum time difference between peaks peaks_int_min[ecg, 0] = np.min( peaks_int[ecg]) # FEATURE: minimum time difference between peaks peaks_int_med[ecg, 0] = np.median( peaks_int[ecg]) # FEATURE: median time difference between peaks peaks_int_mean[ecg, 0] = np.mean( peaks_int[ecg]) #FEATURE: mean time difference between peaks # Find the signals with 'thick' peaks - peaks that last long peaks = [] peaks_index_thick = [] peaks_heights_thick = [] peaks_thick = np.zeros((len(peaks_index), 1)) for ecg in range(len(X)): peaks.append(find_peaks(X[ecg, :], height=0.3, width=20)) #find thick peaks peaks_index_thick.append(peaks[ecg][0]) peaks_heights_thick.append(peaks[ecg][1]['peak_heights']) if peaks_heights_thick[ecg].size == 0: peaks_heights_thick[ecg] = [0] peaks_index_thick[ecg] = [0] else: peaks_heights_thick[ecg] = peaks_heights_thick[ecg] peaks_index_thick[ecg] = peaks_index_thick[ecg] if peaks_heights_thick[ecg][0] == 0: peaks_thick[ecg] = 0 else: peaks_thick[ecg] = [ len(peaks_index_thick[ecg]) ] #FEATURE: number of peaks thicker than 20 and above 0.3 in height #FEATURE: Total length of heartbeat X_time = np.zeros((len(X), 1)) for column in range(len(X)): row = 20 while row < 185: if X[column, row] == X[column, row + 1] and X[ column, row + 1] == X[column, row + 2] and X[column, row + 2] == 0: X_time[column] = row row = 200 else: row += 1 if X_time[column] == 0: X_time[column] = 188 ############################# FEATURE TRISTAN ##################################### X_deriv = np.gradient(X, axis=1) # Parameters of the feature extraction signal_over_threshold = 0.7 signal_under_threshold = 0.2 last_samples = 125 first_samples = 25 local_maximum_threshold = 0.95 local_maximum_distance = 20 last_values_deriv = 75 # 1. Overall value of signal over "signal_over_threshold" overall_value_signal_over = np.asarray( np.transpose(np.sum(np.where(X > signal_over_threshold, X, 0), axis=1))) overall_value_signal_over = np.expand_dims(overall_value_signal_over, axis=1) # 2. Overall value of signal under "signal_under_threshold" overall_value_signal_under = np.transpose( np.sum(np.where(X < signal_under_threshold, X, 0), axis=1)) overall_value_signal_under = np.expand_dims(overall_value_signal_under, axis=1) # 3. Overall value after 125 samples overall_value_after = np.transpose(np.sum(X[:, last_samples:], axis=1)) overall_value_after = np.expand_dims(overall_value_after, axis=1) # Local maximum statistic peaks = [] peaks_index = [] peaks_index_average = [] peaks_heights = [] peaks_number = [] for ecg in range(len(X)): peaks.append( find_peaks(X[ecg, first_samples:], height=local_maximum_threshold, distance=local_maximum_distance)) #find peaks peaks_index.append(peaks[ecg][0]) peaks_index_average.append(np.mean(peaks[ecg][0])) peaks_heights.append(peaks[ecg][1]['peak_heights']) peaks_number.append(len(peaks[ecg][0])) # 4. The number of local maximums # Peaks number # 5. The average index of the local maximums # Peaks index average # 6. The height of the first local minimum height_first_local_min = np.transpose(np.amin(X[:, :first_samples], axis=1)) height_first_local_min = np.expand_dims(height_first_local_min, axis=1) # 7. The minimum value of the derivative min_value_deriv = np.transpose(np.amin(X_deriv, axis=1)) min_value_deriv = np.expand_dims(min_value_deriv, axis=1) # 8. The variance of the last values of the derivative variance_last_values = np.transpose( np.var(X_deriv[:, last_values_deriv:], axis=1)) variance_last_values = np.expand_dims(variance_last_values, axis=1) dataset1 = np.hstack( (max_height, mean_height, var_height, peaks_int_max, peaks_int_min, peaks_int_med, peaks_int_mean, peaks_thick, X_time)) dataset2 = np.hstack( (overall_value_signal_over, overall_value_signal_under, overall_value_after, height_first_local_min, min_value_deriv, variance_last_values)) return np.hstack((dataset1, dataset2))
def harmonicNoiseRatio(signal, freq, freq_lower=50, freq_higher=450, filter_autocorrelation=False, epsilon=1e-9): r"""Computes Harmonic-Noise-Ratio (HNR) using autocorrelation approximation. First, it computes the fundamental frequency using the power spectrum of ``signal``. Next, it computes the autocorrelation in Fourier space. Then, local maxima in the autocorrelation are found, the HNR computed and the maximum HNR and the corresponding frequency is returned. .. math:: R_{xx} = \frac{1}{N} \sum_{k=l}^{N-1} x[k]x[k-l] .. math:: HNR = \frac{R_{xx}[T_0]}{R_{xx}[0]-R_{xx}[T_0]} :param signal: audio signal :type signal: numpy.ndarray :param freq: sampling rate/frequency, e.g. 44100 :type freq: int :param freq_lower: lower frequency cut-off, defaults to 50 :type freq_lower: int, optional :param freq_higher: higher frequency cut-off, defaults to 350 :type freq_higher: int, optional :return: HNR [dB], F0_FFT [Hz], F0_Autocorr [Hz] :rtype: tuple(float, float, float) """ # Create timestamps for signal ``s`` time = np.arange(0, len(signal) / freq, 1 / freq) # rFFT from Signal fft = np.fft.rfft(signal) # Corresponding frequencies freqs = np.fft.rfftfreq(len(signal), 1 / freq) # Autocorrelation using fft R = np.fft.irfft(fft.conj() * fft) # Remove higher harmonics for peak detection if filter_autocorrelation: R_fft = np.fft.fft(R) R_freq = np.fft.fftfreq(R.size, d=1 / freq) R_fft[abs(R_freq) > freq_higher] = 0 Rp = np.fft.ifft(R_fft).real else: Rp = R.copy() # Find peaks in autocorrelation p = find_peaks(Rp, width=20)[0] # Remove first peak artifacts p = p[1:] if p[0] < 10 else p # Remove unnatural peaks (minima and frequencies > 350) p = [i for i in p if 1 / time[i] < freq_higher and R[i] > 0] # Compute HNR for peaks that are higher than minimum frequency (freq_lower) hnr = [ 10 * np.log10(R[pi] / (R[0] - R[pi])) for pi in p if 1 / time[pi] > freq_lower ] return np.max(hnr), 1 / time[p[np.argmax(hnr)]]
add_style(markersize=12, fontsize=16) #sav.saveplot(os.path.join(folder, 'Velocity.pdf')) #%% Revisiting Velocity # I'll be trying three things: #%% 1. How constant is the period algon a single measurement widths = [] for k, (d, duty) in enumerate(zip(data, duty_cycle)): dt = d[1,0] read_data = d[:,1] # Calculate and store widths (periods) peaks = find_peaks(np.diff(read_data), prominence=1, height=2)[0] peaks = peaks.astype(float) * dt w = np.diff(peaks) widths.append(w) # Remove outliers mean = np.mean(w) std = np.std(w) w = w[w < mean + 4*std] # Create, plot and format histogram f, ax = plt.subplots() ax.hist(w) #8 bins ax.legend({'Count = {}'.format(len(w))}) ax.set_title('{}/{}: duty={}%'.format(k+1, len(data), duty))
# %% def power_law(x, a, b): return a * x**(-1 / b) def exponential(x, a, b): return a * np.exp(-x / b) # %% fig, ax = plt.subplots(3, 2) ax = ax.reshape(6, ) for i, (r, g6, d) in enumerate(zip(r_all, G6, d_all)): peaks, props = signal.find_peaks(g6, width=10) r_peaks = r[peaks].real g6_peaks = g6[peaks].real popt_power, pcov_power = optimize.curve_fit(power_law, r_peaks, g6_peaks, p0=[g6_peaks.max(), 4]) popt_exp, pcov_exp = optimize.curve_fit(exponential, r_peaks, g6_peaks, p0=[g6_peaks.max(), 20]) power_fit = power_law(r, *popt_power) exp_fit = exponential(r, *popt_exp) ax[i].plot(r, g6, label='data') ax[i].plot(r, power_fit, label='power fit')
for filename in filenames: bead_size = 5 #Using smallest size, since even 10mm can make 5mm changes t, x, y, z, u, vx, vy, vz, uvx, uvy, uvz = read_file("../Data/" + filename) x = smooth_data(x, 10) # Smoothing data to make peak finding better #Can be used to plot if wanted # t = t[10000:30000] # x = x[10000:30000] # plt.figure() # plt.plot(t,x) indices, properties = find_peaks( x, prominence=1, distance=30, width=5 ) # Finds peaks in x, prominence main setting, distance and width settings reduce false peaks # plt.plot(t[indices], x[indices] , 'ro') count = 0 for i in range(len(indices)): # For each peak try: if (np.absolute(x[indices[i]] - x[indices[i + 1]]) > bead_size ): # maybe consider checking 2 points away for overall trends count += 1 # plt.plot(t[indices[i]],x[indices[i]], 'gs') except IndexError: # Can't be bothered to figure out indexing pass print(filename) print("Total cycles:", len(indices)) print("Transitions:", count)
soc_wi = np.copy(social_whisk_index).astype(int) sol_wi = np.random.permutation(solo_whisk_index) sol_wi = sol_wi[0:len(social_whisk_index)].astype(int) elif solo_whisk_index.shape[0] < social_whisk_index.shape[0]: sol_wi = np.copy(solo_whisk_index).astype(int) soc_wi = np.random.permutation(social_whisk_index) soc_wi = soc_wi[0:len(solo_whisk_index)].astype(int) GTM_frames_solo = l_mouse_frames[sol_wi, :, :] GTM_frames_social = l_mouse_frames[soc_wi, :, :] # GTM_social = np.mean(GTM_frames_social, axis=0) # GTM_solo = np.mean(GTM_frames_solo, axis=0) # GTM_social[~l_mouse_mask] = -100 # GTM_solo[~l_mouse_mask] = -100 whisk_events = sio.find_peaks(roi_gradient_signal, height=threshold)[0] social_duration = (end_interaction - start_interaction) / 28.815 social_whisk_rate = 60 * np.intersect1d( whisk_events, interaction_time).size / social_duration solo_duration = (roi_gradient_signal.size - np.arange( start_first_translation, end_second_translation).size) / 28.815 solo_whisk_rate = 60 * np.intersect1d(whisk_events, solo_time).size / solo_duration g2.create_dataset('SIGMA', data=SIGMA) g2.create_dataset('social_whisk_rate', data=social_whisk_rate) g2.create_dataset('solo_whisk_rate', data=solo_whisk_rate) g2.create_dataset('mask', data=l_mouse_mask) g2.create_dataset('roi_gradient_signal', data=roi_gradient_signal) g2.create_dataset('threshold', data=threshold)
highres_flux += get_me_highres(coef,dat,highres) coef = bcoefs2.data[fib] dat = bspec2.data[fib] highres_flux += get_me_highres(coef,dat,highres) highres_flux /= (2*len(fibers)) # plt.figure(); plt.plot(highres,highres_flux); plt.show() from linebrowser import LineBrowser iraf_vac = air_to_vacuum(iraf_air) salt_vac = air_to_vacuum(salt_air) # mock_coefs = (highres[0],highres[1]-highres[0],0.,0.,0.,0.) # browser = LineBrowser(salt_vac, np.zeros(len(salt_vac)), highres_flux, mock_coefs, iraf_vac) # browser.plot() peaks, properties = signal.find_peaks(highres_flux, height=(2000, None), width=(1, 100000), \ threshold=(None, None), prominence=(1000, None), wlen=10000000) # find peaks fxpeak = highres[peaks] # peaks in wavelength fypeak = highres_flux[peaks] # peaks heights (for noise) # noise = np.std(np.sort(highres_flux)[: (highres_flux.size // 2)]) # noise level # significant_peaks = fypeak > noise # peaks = peaks[significant_peaks] # fxpeak = fxpeak[significant_peaks] # significant peaks in wavelength # fypeak = fypeak[significant_peaks] # significant peaks height pw,ph = fxpeak,fypeak overlap = 0.2 to_delete = [] listw, listh = pw.tolist(), ph.tolist() for ii, (w, h) in enumerate(zip(pw, ph)):
def calc_sinogram(x, y, hist_bins=300, quant_size=0, drop_90=False, plot=False): import numpy as np import pandas as pd import warnings from skimage.transform import radon # , rescale, iradon, iradon_sart, hough_line from scipy import signal max_num=max(max(x),max(y)) if quant_size: bins=np.arange(-(max_num/quant_size+1),(max_num/quant_size+1))*quant_size+quant_size*0.5 if not quant_size or len(bins)>hist_bins: bins=np.linspace(-max_num, max_num, hist_bins, endpoint=True) H, xedges, yedges = np.histogram2d(x, y, bins=[bins]*2) # in order to estimate the angle, we need the space to be square H = H[::-1].T if 0: # maybe to get more resolution a=np.vstack([H,H]) H=np.hstack(([a,a])) theta = np.linspace(0., 180., max(H.shape), endpoint=False) if 1: with warnings.catch_warnings(): warnings.simplefilter("ignore") sinogram = radon(H, theta=theta, circle=True) # sinogram=pd.DataFrame(sinogram, columns=np.linspace(0,180,sinogram.shape[0], endpoint=True)).stack().idxmax()[1] sinogram = pd.DataFrame(sinogram, columns=np.linspace(-90, 90, sinogram.shape[0], endpoint=False)).rename_axis('angle', axis=1).rename_axis('offset', axis=0) # angle is from the horizon, you will get from -90 to 90 else: # hough gives very noisy output out, angles, d = hough_line(H, theta=theta) sinogram = pd.DataFrame(out, columns=angles, index=d).rename_axis('angle', axis=1).rename_axis('offset', axis=0) # angle is from the horizon, you will get from -90 to 90 if drop_90: sinogram[-90] = 0 if 0: # this will tell us the angle. we can also use idxmax on the sinogram, # but the best is to find the angle that has the highest std, # becaues max is by single line and std is by all lines # we cannot take the angle sum, because they all summed to big numbers radon_estimated_angle = sinogram.std().idxmax() else: # max_peaking = signal.find_peaks(sinogram.std(), distance=sinogram.shape[1]//100)[0] max_peaking = signal.find_peaks(sinogram.std(), distance=4)[0].tolist() # we want to find peaks so all values next to the peak will dropped max_peaking+=[0,sinogram.shape[0]-1] # adding also the edges because they are not count as peaks max_peaking=np.array(max_peaking) # print(max_peaking) max_peaking=sinogram.std().iloc[max_peaking] # max_peaking=max_peaking[~max_peaking.index.isin([-90, 0, -45, 90, 45])] # we multiply the pattern to the left right up and down so obviously we tend to get those angles radon_estimated_angle=max_peaking.idxmax() slop=np.tan(np.deg2rad(radon_estimated_angle)) if np.isnan(radon_estimated_angle): # you will get this if all quantized values are the same radon_estimated_angle=0 # ignore this - putting angle to rotate the data so it will take the original option and not all the other duplications sinogram_dict=dict(image=H, sinogram=sinogram, angle_by_std=radon_estimated_angle, angle_by_idxmax=sinogram.stack().idxmax()[1], overall_sinogram_std=sinogram.std().std(), slop=slop, y_avg=y.mean(), x_avg=x.mean(), actual_bin_size=len(bins)) if plot: plot_sinogram(sinogram_dict['image'], sinogram_dict['sinogram'], sinogram_dict['angle_by_std'], slop=sinogram_dict['slop']) if 0: empty_sinogram = sinogram.copy().astype(int)*0 empty_sinogram.loc[sinogram.index.to_series().median(), radon_estimated_angle]=1 empty_sinogram=empty_sinogram.fillna(0) line_image=iradon(empty_sinogram.values, circle=True)# , interpolation='linear') line_image.max() line_image.min() line_image.mean() abc=pd.DataFrame(line_image) # line_image=(line_image > line_image.mean()) * 255 # line_image = iradon_sart(sinogram.values, theta=theta) plt.close() plt.imshow(line_image, cmap=plt.cm.Greys_r) fig=abc.figure(kind='heatmap', colorscale='Greys', title='radon inverse - real world') fig=empty_sinogram.figure(kind='heatmap', colorscale='Greys', title='radon inverse - real world') py.offline.plot(fig) # print('sinogram %g' % radon_estimated_angle) # trying to get all max numbers. you cannot do sum because all angles summed to the same values # this will tell us how much the image is just lines or just noise # below 3 is low correlation. and you have up to 3.5 to some cases that are at the middle # print('overall sinogram std %g' % sinogram.std().std()) return sinogram_dict
def handle(self, *args, **options): # vars experiment_name = options['expt'] series_name = options['series'] if experiment_name!='' and series_name!='': experiment = Experiment.objects.get(name=experiment_name) series = experiment.series.get(name=series_name) # cell_instance = series.cell_instances.get(t=48, cell__pk=4) # cell_instance = series.cell_instances.get(t=49, cell__pk=9) # cell_instance = series.cell_instances.get(pk=198) # load mask image # 1. for each cell mask, load mask image outlines = {} colours = ['red','green','blue','purple'] for i, cell_mask in enumerate(cell_instance.masks.filter(channel__name__contains='zunique')): mask_img = cell_mask.load() # get edge edge_img = edge_image(mask_img) # get list of points points_r, points_c = np.where(edge_img) points = [list(lm) for lm in list(zip(points_r, points_c))] sorted_points = roll_edge_v1(points) # plot distances in order cell_centre = np.array([cell_mask.r, cell_mask.c]) distances = np.array([np.linalg.norm(cell_centre - np.array(p)) for p in sorted_points]) argmin = np.argmin(distances) distances = np.roll(distances, -argmin) distances = gf(distances, sigma=2) # plt.plot(distances) # plt.scatter(cell_mask.c, cell_mask.r) # find peaks in distance array peaks = find_peaks(distances, np.array([9])) # plt.scatter(peaks, [distances[peak] for peak in peaks]) # roll back to find true peak positions true_peaks = np.array(peaks) + argmin true_peaks[true_peaks>=len(sorted_points)] -= len(sorted_points) # find end point of protrusions protrusion_end_points = [sorted_points[peak] for peak in true_peaks] for protrusion_end_point in protrusion_end_points: print('new protrusion for cell mask {} for cell instance {}'.format(cell_mask.pk, cell_instance.pk)) relative_end_point = cell_centre - np.array(protrusion_end_point) print(cell_centre, protrusion_end_point) print('length from centre: {} microns'.format(np.linalg.norm(relative_end_point * series.scaling()))) print('orientation: {} degrees'.format(180 / math.pi * math.atan2(relative_end_point[0], relative_end_point[1]))) # plt.scatter([sorted_points[peak][1] for peak in true_peaks], [sorted_points[peak][0] for peak in true_peaks]) # plot outlines to check plt.plot([point[1] for point in sorted_points], [point[0] for point in sorted_points], label='radius: 2') # plt.scatter(points_c, points_r, label=cell_mask.channel.name, color=colours[i]) # plt.legend() # plt.axis('equal') plt.show() else: print('Please enter an experiment')
img_piece = img_piece[0:ini_H, :] #img_piece = cv2.medianBlur(img_piece,5) #long =img_piece long = numpy.append(img_piece, img_piece, axis=1) long = numpy.append(long, img_piece, axis=1) B_line = numpy.sum(long, axis=0) / long.shape[0] B_line = signal.medfilt(B_line, 7) B_line = numpy.convolve(B_line, numpy.ones((200, )) / 200, mode='valid') B_line = B_line / max(B_line) len_b = len(B_line) border1 = numpy.zeros(len_b) + 1 - 0.5 * (1 - min(B_line)) border2 = numpy.ones(len_b) * 1.1 peaks, _ = find_peaks(B_line, height=(border1, border2), distance=30, prominence=0.05) start = peaks[1] # to search border for k in range(ini_W): this = B_line[start + k] if this <= border1[start + k]: right = start + k + 100 break for k in range(ini_W): this = B_line[start - k] if this <= border1[start - k]: left = start - k + 100 break if Display_sig_flag == True:
# f[:bound_low] = 0 # f[bound_high:-bound_high] =0 # f[-bound_low:] = 0 # plt.subplot(152),plt.imshow(np.log(1+np.abs(f)),"gray"),plt.title("fft2") f = butter_bandpass_filter(f, low, high, fps) # plt.show() fft_maximus = [] for j in range(f.shape[0]): if low <= frequencies[j] <= high: fftMap = abs(f[j]) fft_maximus.append(fftMap.max()) else: fft_maximus.append(0) peaks, properties = signal.find_peaks(fft_maximus) max_peak = -1 max_freq = 0 for peak in peaks: if fft_maximus[peak] > max_freq: max_freq = fft_maximus[peak] max_peak = peak print(frequencies[max_peak] * 60) iff = fftpack.ifft(f, axis=0) iff = np.abs(iff) iff *= 100 kd[i] += iff # print(find_heart_rate(f,frequencies,low,high))
def find_protrusions(self): # load mask image and find edge mask_img = self.load() edge_img = edge_image(mask_img) # get list of points that lie on the edge: points_rc points_r, points_c = np.where(edge_img) points_rc = [list(lm) for lm in list(zip(points_r, points_c))] # sort points using a fixed radius count, max_count, sorted_points = roll_edge_v1(points_rc) if count<max_count: # get cell centre and calculate distances of edge points from this point cell_centre = np.array([self.r, self.c]) distances = np.array([np.linalg.norm(cell_centre - np.array(p)) for p in sorted_points]) # smooth to aid peak finding and shift the points to leave the smallest distance at zero argmin = np.argmin(distances) distances = np.roll(distances, -argmin) distances = gf(distances, sigma=2) # find peaks peaks = find_peaks(distances, np.array([9])) # shift peaks back to their original positions true_peaks = np.array(peaks) + argmin true_peaks[true_peaks>=len(sorted_points)] -= len(sorted_points) # rotate # find end points protrusion_end_points = [sorted_points[peak] for peak in true_peaks] # create new protrusion for each end point for protrusion_end_point in protrusion_end_points: relative_end_point = cell_centre - np.array(protrusion_end_point) # parameters r = relative_end_point[0] c = relative_end_point[1] length_from_centre = np.linalg.norm(relative_end_point * self.series.scaling()) # in microns length_from_mean = length_from_centre - np.mean(distances) orientation_from_horizontal = math.atan2(relative_end_point[0], relative_end_point[1]) # print(self.cell_instance.pk, self.pk, r, c, length_from_centre, orientation_from_horizontal) protrusion, protrusion_created = self.protrusions.get_or_create(experiment=self.experiment, series=self.series, cell=self.cell, cell_instance=self.cell_instance, channel=self.channel, region=self.region, region_instance=self.region_instance, r=r, c=c) if protrusion_created: protrusion.length = length_from_centre protrusion.length_from_mean = length_from_mean protrusion.orientation = orientation_from_horizontal protrusion.save() return 'success', len(protrusion_end_points) else: return 'success', 0
# zero timestamps and convert from ms to seconds timestamps_zero_sec = (timestamps_raw - timestamps_raw.iloc[0, 0]) / 1000 #%% prom_multiplier = 2.91 width_min = 5 width_max = 100 distance_min = 10 wlen_limit = 160 # ================================= pDCoCG PEAK DETECTION ================================= threshold_prom = prom_multiplier * (data_column.mad()) peak_ind, properties = find_peaks(data_column, prominence=threshold_prom, width=(width_min, width_max), distance=distance_min) peak_raw_times = timestamps_raw.iloc[peak_ind].values peak_times = timestamps_zero_sec.iloc[peak_ind].values peak_times_norm = peak_times / float(timestamps_zero_sec.iloc[-1]) peak_yval = data_column[peak_ind] peak_prom = peak_prominences(data_column, peak_ind, wlen=wlen_limit)[0] peak_prom_norm = peak_prom / max(peak_prom) contour_min = peak_yval - peak_prom hwidths = peak_widths(data_column, peak_ind, rel_height=0.5, wlen=wlen_limit) # hwidths ouputs 4 arrays: (1) the widths for each peak in samples (2) width heights (3&4) interpolated positions # of left and right intersection points of a horizontal line at the respective evaluation height hwidths_yval = (hwidths[1])
def handle_user_agreement(self, xp, hierarchy): """ For CN only. CN client is bugged. User Agreement and Privacy Policy may popup again even you have agreed with it. This method scrolls to the bottom and click AGREE. Returns: bool: If handled. """ if server.server == 'cn': area_wait_results = self.get_for_any_ele([ XPS('//*[@text="sdk协议"]', xp, hierarchy), XPS('//*[@content-desc="sdk协议"]', xp, hierarchy) ]) if area_wait_results is False: return False agree_wait_results = self.get_for_any_ele([ XPS('//*[@text="同意"]', xp, hierarchy), XPS('//*[@content-desc="同意"]', xp, hierarchy) ]) start_padding_results = self.get_for_any_ele([ XPS('//*[@text="隐私政策"]', xp, hierarchy), XPS('//*[@content-desc="隐私政策"]', xp, hierarchy), XPS('//*[@text="用户协议"]', xp, hierarchy), XPS('//*[@content-desc="用户协议"]', xp, hierarchy) ]) start_margin_results = self.get_for_any_ele([ XPS('//*[@text="请滑动阅读协议内容"]', xp, hierarchy), XPS('//*[@content-desc="请滑动阅读协议内容"]', xp, hierarchy) ]) test_image_original = self.device.image image_handle_crop = crop( test_image_original, (start_padding_results[2], 0, start_margin_results[2], 720)) # Image.fromarray(image_handle_crop).show() sims = color_similarity_2d(image_handle_crop, color=(182, 189, 202)) points = np.sum(sims >= 255) if points == 0: return False sims_height = np.mean(sims, axis=1) # pyplot.plot(sims_height, color='r') # pyplot.show() peaks, __ = find_peaks(sims_height, height=225) if len(peaks) == 2: peaks = (peaks[0] + peaks[1]) / 2 start_pos = [ (start_padding_results[2] + start_margin_results[2]) / 2, float(peaks) ] end_pos = [ (start_padding_results[2] + start_margin_results[2]) / 2, area_wait_results[3] ] logger.info("user agreement position find result: " + ', '.join('%.2f' % _ for _ in start_pos)) logger.info("user agreement area expect: " + 'x:963-973, y:259-279') self.device.drag(start_pos, end_pos, segments=2, shake=(0, 25), point_random=(0, 0, 0, 0), shake_random=(0, -5, 0, 5)) AGREE = Button(area=agree_wait_results, color=(), button=agree_wait_results, name='AGREE') self.device.click(AGREE) return True
def block_extent_routine(self, args): self._block_pos_temp = np.array([0, 0]) self._block_found_temp = False original_block_angle = np.arctan2( (args['target'][1] - self.current_position(grid=False)[1]), (-args['target'][0] + self.current_position(grid=False)[0])) - np.pi / 4 #print(original_block_angle) sweep_angles = np.linspace(original_block_angle - 0.4, original_block_angle + 0.4, 20) trigger_value = 0.2 if self._angle_index < len(sweep_angles) - 1: if sweep_angles[self._angle_index] > np.pi: desired_angle = sweep_angles[self._angle_index] - np.pi * 2 elif sweep_angles[self._angle_index] < -np.pi: desired_angle = sweep_angles[self._angle_index] + np.pi * 2 else: desired_angle = sweep_angles[self._angle_index] if self._angle_index == 0: self.set_heading(desired_angle, 5) else: self.set_heading(desired_angle, 15) current_orientation = np.array([ -np.cos(self.current_angle()), 0, -np.sin(self.current_angle()) ]) desired_orientation = np.array( [-np.cos(desired_angle), 0, -np.sin(desired_angle)]) cross_start = -np.cross(current_orientation, desired_orientation)[1] if np.abs(cross_start) < 0.01: #print(self._angle_index) self._angle_index = self._angle_index + 1 self._dist_array.append(self.robot_data[self.robot_id][5]) else: # rising_mask = ((np.array(self._dist_array[:-1]) < trigger_value) & (np.array(self._dist_array[1:]) > trigger_value)) # falling_mask = ((np.array(self._dist_array[:-1]) > trigger_value) & (np.array(self._dist_array[1:]) < trigger_value)) # print(np.flatnonzero(rising_mask) +1) # print(np.flatnonzero(falling_mask) +1) #print(np.array(self._dist_array)*-1) peaks, properties = find_peaks(np.array(self._dist_array) * -1, height=(-0.35, 0), width=3) #print(self._dist_array[peaks[0]]) if len(peaks) == 0: print('no block found') self._angle_index = 0 self._dist_array = [] self.set_state('idle') self._block_found_temp = False args['env'].update_block((args['target'], 0, True)) else: self._block_found_temp = True sweep1 = sweep_angles[int(properties["left_ips"][0])] sweep2 = sweep_angles[int(properties["right_ips"][0])] exact_angle = (sweep1 + sweep2) / 2 if exact_angle + np.pi / 4 > np.pi: exact_angle = exact_angle + np.pi / 4 - np.pi * 2 elif sweep_angles[peaks[0]] + np.pi / 4 < -np.pi: exact_angle = exact_angle + np.pi / 4 + np.pi * 2 else: exact_angle = exact_angle + np.pi / 4 cross = self.set_heading(exact_angle, 5, info=True) #print(exact_position) if np.abs(cross) < 0.04: exact_position = convert_to_grid_coords( transform_local_coords([ self.robot_data[self.robot_id][1], self.robot_data[self.robot_id][2], exact_angle ], [0, self._dist_array[peaks[0]]])) self._angle_index = 0 self._dist_array = [] self._block_pos_temp = np.array( [int(exact_position[0]), int(exact_position[1])]) self.set_state('go_to_target', target=self._block_pos_temp, early_stop=2, grip=0, block=True, empty=False, look_at=True, speed=0.6)
import numpy as np from scipy.optimize import curve_fit from scipy.signal import find_peaks import matplotlib.pyplot as plt def e(x, a, b, c): return a * np.exp(b * x) + c t, U = np.genfromtxt('data.txt', unpack=True) t *= 1e3 maxs, properties = find_peaks(U, prominence=1, distance=100) mins, properties = find_peaks(-U, prominence=1, distance=100) x = np.linspace(0, plt.xlim()[1]) parameters_max, pcov_max = curve_fit(e, t[maxs], U[maxs]) print(parameters_max, np.sqrt(np.diag(pcov_max)), sep='\n') parameters_min, pcov_min = curve_fit(e, t[mins], U[mins]) print(parameters_min, np.sqrt(np.diag(pcov_min)), sep='\n') plt.plot(t, U, 'k-', label='Gedämpfte Schwingung') plt.plot(x, e(x, *parameters_max), label='Obere Einhüllende') plt.plot(t[maxs], U[maxs], 'rx', label='Maxima') plt.plot(x, e(x, *parameters_min), label='Untere Einhüllende') plt.plot(t[mins], U[mins], 'bx', label='Minima')
def __find_peaks(self): self.__peaks = [None] * 500 self.__filter_pedometer() self.__peaks = sig.find_peaks(self.__data_buffer)[0] return
def find_points( sig, fs, metadata, bias, gain, **kwargs): """ Поиск характерных точек :param sig: входной сигнал (многоканальный) :param fs: частота дискретизации :param metadata: первичная сегментация, содержащая qrs_start, qrs_end, qrs_center :param bias: уровень изолинии :param gain: усиление :return: None (результатом являются измененные значения в metadata) """ qrs_duration_max = int(fs*kwargs.get( "qrs_duration_max", config.WAVES["qrs_duration_max"] )) pma_detection_on = kwargs.get( "pma_detection_on", config.PACEMAKER["detection"] ) pma_duration_max = fs*kwargs.get( "pma_duration_max", config.PACEMAKER["spike_duration_max"] ) pma_scale = 1 # номер уровня для поиска артефактов кардиостимулятора r_scale = 2 # номер уровня для поиска R-зубца p_scale = 4 # номер уровня для поиска P-зубца t_scale = 4 # номер уровня для поиска T-зубца f_scale = 4 # номер уровня для обнаружения трепетаний t_window_fraction = 0.6 p_window_fraction = 1.0 - t_window_fraction num_scales = max(r_scale, p_scale, t_scale) num_cycles = len(metadata) pilot_chan = 1 if sig.shape[1] > 1 else 0 for chan, x in signal_channels(sig): approx, detail = ddwt(x-bias[chan], num_scales=num_scales) # границы QRS здесь не определяем, надеемся на metadata # очень приближенная оценка шума noise = np.std(detail[1]) * 0.7 #print(noise) if chan == pilot_chan: fibpos = find_peaks(detail[f_scale], height=noise/2)[0] else: fibpos = [] for ncycle, qrs in enumerate(metadata): prev_r = int(metadata[ncycle - 1]["qrs_center"] * fs) \ if ncycle else 0 next_r = int(metadata[ncycle + 1]["qrs_center"] * fs) \ if ncycle < num_cycles - 1 else len(x) cur_r = int(qrs["qrs_center"] * fs) # оценка изолинии iso = np.percentile(approx[r_scale][prev_r:next_r], 15) qrs["isolevel"][chan] = iso / gain[chan] # Поиск зубцов Q, R, S # узкое окно для поиска только R this_qrs = [int(qrs["qrs_start"] * fs), int(qrs["qrs_end"] * fs)] tight_bounds = [ max(0, this_qrs[0]), min(len(x) - 1, this_qrs[1]) ] # более широкое окно для поиска остальных зубцов prev_qrs =\ int(metadata[ncycle - 1]["qrs_end"] * fs) if ncycle else 0 next_qrs =\ int(metadata[ncycle + 1]["qrs_start"] * fs) \ if ncycle < num_cycles - 1 else len(x) loose_bounds = [ int((tight_bounds[0] + prev_qrs)/2), int((tight_bounds[1] + next_qrs)/2) ] #if ncycle==34 and chan==0: # fig, axarr = plt.subplots(2, 1, sharex="col") # fleft = int(metadata[ncycle-1]["qrs_end"]*fs) # fright = int(qrs["qrs_start"]*fs) # #x1 = tight_bounds[0] # #x2 = tight_bounds[1] # x1 = fleft # x2 = fright # xval = np.arange(x1, x2) # axarr[0].plot(xval, approx[r_scale][x1:x2]) # axarr[0].grid() # acf, v = detect_periodic(detail[f_scale][x1:x2]) # xv = x1 + np.arange(0, len(acf)) # axarr[1].plot(xv, acf) # #axarr[1].plot(xval, approx[f_scale][x1:x2]) # #axarr[1].plot(xval, detail[f_scale][x1:x2], "m") # axarr[1].grid() # print("Look at the plots") # plt.show(block=False) #print(ncycle, chan) if pma_detection_on and fs > 260: pma_modes = find_extrema( detail[pma_scale], loose_bounds[0], loose_bounds[1], noise / 2 ) pma = pma_search(pma_modes, tight_bounds[0], tight_bounds[1], max_dur=pma_duration_max) if pma: qrs["pma"][chan].append(pma) # все пики производной в широком окне modes = find_extrema( detail[r_scale], loose_bounds[0], loose_bounds[1], noise/2 ) qrssearch(modes, tight_bounds, approx[r_scale], qrs, chan, iso, qrs_duration_max) # поиск P-зубца # окно для поиска wlen = (cur_r - prev_r) * p_window_fraction p_search_lb = int(prev_r + wlen) if ncycle: prev_t = metadata[ncycle-1]["t_end"][chan] if prev_t is None: prev_t = metadata[ncycle - 1]["t_pos"][chan] if prev_t is not None: p_search_lb = max(p_search_lb, prev_t) pwindow = [ p_search_lb, cur_r ] modas_subset = find_extrema( detail[p_scale], pwindow[0], pwindow[1], noise/2 ) # последняя мода перед R не учитывается, потому что относится к QRS pleft, pcenter, pright = ptsearch( modas_subset[:-1], approx[r_scale+1], bias=iso, limits=pwindow, height=noise/2 ) qrs["p_pos"][chan] = pcenter qrs["p_start"][chan] = pleft qrs["p_end"][chan] = pright # уточнение уровня изолинии по интервалу PQ if pright is not None: pq_end = qrs["q_pos"][chan] if pq_end is None: pq_end = qrs["r_start"][chan] if pq_end is None: pq_end = qrs["r_pos"][chan] if pq_end is not None and pq_end - pright > 1: iso = np.median(approx[r_scale][pright:pq_end]) qrs["isolevel"][chan] = iso / gain[chan] # поиск T-зубца # окно для поиска wlen = (next_r - cur_r) * t_window_fraction twindow = [ cur_r, int(cur_r + wlen) ] modas_subset = find_extrema( detail[p_scale], twindow[0], twindow[1], noise / 4 ) # первая мода справа от R не учитывается, потому что относится к QRS tleft, tcenter, tright = ptsearch( modas_subset[1:], approx[r_scale+1], bias=iso, limits=twindow, height=noise ) qrs["t_pos"][chan] = tcenter qrs["t_start"][chan] = tleft qrs["t_end"][chan] = tright # поиск F-волн в промежутках между qrs if chan == pilot_chan and ncycle: #fleft = int(metadata[ncycle-1]["qrs_end"]*fs) #fright = int(qrs["qrs_start"]*fs) fleft = get_cycle_end(metadata[ncycle-1], chan, fs) fright = get_cycle_start(qrs, chan, fs) # Берем промежуток между QRS (с возможным захватом P и T) # и обнаруживаем в нем периодичность rest_range = [ int(metadata[ncycle-1]["qrs_end"]*fs), int(qrs["qrs_start"]*fs) ] # защита от слишком коротких пауз # TODO: разобраться, почему это происходит if rest_range[1] - rest_range[0] > 8: pk = detect_periodic(detail[f_scale][ rest_range[0]:rest_range[1]])[1] else: pk = 0 qrs["flutter"][chan] = pk
def reshape_4DSTEM_FlyBack(data, scan_x, plot_sum = False): """ Reshapes the lazy-imported stack of dimensions: (xxxxxx|256, 256) to the correct scan pattern shape: (x, y | 256,256). It utilises the over-exposed fly-back frame to identify the start of the lines in the first 10 lines of frames,checks line length consistancy and finds the number of frames to skip at the beginning (this number is printed out as string output). Parameters ---------- data : hyperspy lazily imported mib file with diensions of: framenumbers|256, 256 plot_Sum: (default: Flase) Set to True to get the intensity profile of the first 10 lines - to check for peak finding correctness Returns ------- data_reshaped : reshaped data (x, y | 256,256) optional: plots the sum intensity vs frames """ data_crop = data.inav[0:np.int(10* np.sqrt(data.axes_manager[0].size))] #crop the first ~10 lines data_crop_t = data_crop.T data_crop_t_sum = data_crop_t.sum() intensity_array = data_crop_t_sum.data #summing over patterns intensity_array = intensity_array.compute() #out of lazy #Checking for local maxima to be more than _factor_ times the neighbouring elements #This factor is currently not robust to all datasets! #factor = np.int(max(intensity_array) / np.mean(intensity_array)) #print(factor) #local_max = (np.r_[True, intensity_array[1:] > factor* intensity_array[:-1]] # & np.r_[intensity_array[:-1] > factor* intensity_array[1:], True]) peaks = find_peaks(intensity_array, distance= scan_x) if plot_sum == True: import matplotlib.pyplot as plt fig1 = plt.figure() ax1 = fig1.add_subplot(121) ax2 = fig1.add_subplot(122) ax1.plot(intensity_array, 'k') ax2.plot(peaks[0],np.ones(len(peaks[0])),'*') ax1.set_title('sum intensity of first ~10 lines of frame') ax2.set_title('peaks detected') #peaks = np.ravel(np.where(local_max)) lines = np.ediff1d(peaks[0]) #Diff between consecutive elements of the array line_len = lines[lines.size-1] # Assuming the last element to be the line length check = np.ravel(np.where(lines == line_len)) #Checking line lengths line_confirm = [np.ediff1d(check) == 1] if ~np.all(line_confirm): #In case there is a False in there take the index of the last False start_ind = np.where(line_confirm[0] == False)[-1][-1] + 2 skip_ind = peaks[0][start_ind] else: #In case they are all True take the index of the first True skip_ind = peaks[0][check[0]] #number of frames to skip at the beginning n_lines = floor((data.data.shape[0] - skip_ind) / line_len) #Number of lines data_skip = data.inav[skip_ind:skip_ind + (n_lines * line_len)] #with the skipped frames removed data_skip.data = data_skip.data.reshape(n_lines, line_len, 256, 256) data_skip.axes_manager._axes.insert(0, data_skip.axes_manager[0].copy()) data_skip.get_dimensions_from_data() #reshaped print('Number of frames skipped at the beginning: ', skip_ind) data_skip = data_skip.inav[1:] return data_skip