def __sliding_window_fast(array: np.ndarray, window_size: int, mode: str = "attack") -> np.ndarray: if mode == "attack": window_size = make_odd(window_size) return maximum_filter1d(array, size=(2 * window_size - 1)) half_window_size = (window_size - 1) // 2 array = np.pad(array, (half_window_size, 0)) return maximum_filter1d(array, size=window_size)[:-half_window_size]
def prominent_peaks(image, min_xdistance, min_ydistance, threshold=None): img = image.copy() rows, cols = img.shape if threshold is None: threshold = 0.5 * np.max(img) yc_size = 2 * min_ydistance + 1 xc_size = 2 * min_xdistance + 1 img_max = maximum_filter1d(img, size=yc_size, axis=0, mode='constant', cval=0) img_max = maximum_filter1d(img_max, size=xc_size, axis=1, mode='constant', cval=0) mask = (img == img_max) img *= mask img_t = img > threshold label_img = measure.label(img_t) props = measure.regionprops(label_img, img_max) props = sorted(props, key=lambda x: x.max_intensity)[::-1] coords = np.array([np.round(p.centroid) for p in props], dtype=int) yc_peaks = [] xc_peaks = [] yc_ext, xc_ext = np.mgrid[-min_ydistance:min_ydistance + 1, -min_xdistance:min_xdistance + 1] for yc_idx, xc_idx in coords: accum = img_max[yc_idx, xc_idx] if accum > threshold: yc_nh = yc_idx + yc_ext xc_nh = xc_idx + xc_ext yc_in = np.logical_and(yc_nh > 0, yc_nh < rows) yc_nh = yc_nh[yc_in] xc_nh = xc_nh[yc_in] xc_low = xc_nh < 0 yc_nh[xc_low] = rows - yc_nh[xc_low] xc_nh[xc_low] += cols xc_high = xc_nh >= cols yc_nh[xc_high] = rows - yc_nh[xc_high] xc_nh[xc_high] -= cols img_max[yc_nh, xc_nh] = 0 yc_peaks.append(yc_idx) xc_peaks.append(xc_idx) return np.transpose(np.vstack( (np.array(xc_peaks), np.array(yc_peaks)))).astype(int)
def _find_peak_locations_fn(logits, size, threshold): assert size % 2 == 1 assert logits.ndim == 2 and logits.shape[1] == 88 logits_max = maximum_filter1d(logits, size=size, axis=0, mode='constant') assert logits_max.shape == logits.shape logits_peak_ids = np.logical_and(logits == logits_max, logits > threshold) # Due to numerical precision, there could be multiple peaks within a window. # In this case, we use the first peak and remove the other peaks. num_frames = len(logits) hs = (size - 1) // 2 for pitch in xrange(88): for frame_idx in xrange(num_frames - hs): if logits_peak_ids[frame_idx, pitch]: for fidx in xrange(hs): if logits_peak_ids[frame_idx + 1 + fidx, pitch]: logits_peak_ids[frame_idx + 1 + fidx, pitch] = False logits_peak_ids = np.where(logits_peak_ids) return logits_peak_ids
def preprocessFeatureMat(X, Lfilt): """ Binarizes and blurs the feature matrix Parameters ---------- X : 2D array The original feature matrix (presumably output by buildFeatureMat()) Lfilt : int The width of the hamming filter used to blur the feature matrix. Returns ------- X : 2D array The modified feature matrix without blur Xblur : 2D array The modified feature matrix with blur """ Xblur = _filterRows(X, Lfilt) # ensure that the maximum value in Xblur is 1; we do this by dividing # by the largets value within Lfilt / 2, rather than just clamping, so # that there's a smooth dropoff as you move away from dense groups of # 1s in X; otherwise it basically ends up max-pooled maxima = filters.maximum_filter1d(Xblur, Lfilt // 2, axis=1, mode='constant') Xblur[maxima > 0] /= maxima[maxima > 0] # have columns be adjacent in memory return np.asfortranarray(X), np.asfortranarray(Xblur)
def dff(C, sig_baseline=10, win_baseline=300, sig_output=3, method='maximin'): """ delta F / F using maximin method from Suite2P inputs: C - neuropil subtracted fluorescence (neurons x timepoints) outputs dFF - neurons x timepoints :param C: :param sig_baseline: :param win_baseline: :param sig_output: :param method: :return: """ if method == 'maximin': # windowed baseline estimation flow = filters.gaussian_filter(C, [0, sig_baseline]) flow = filters.minimum_filter1d(flow, win_baseline, axis=1) flow = filters.maximum_filter1d(flow, win_baseline, axis=1) else: flow = None raise NotImplementedError C -= flow # substract baseline (dF) C /= flow # divide by baseline (dF/F) return filters.gaussian_filter(C, [0, sig_output]) # smooth result
def _rolling_nanmax_1d(a, w=None): """ Compute the rolling max for 1-D while ignoring NaNs. This essentially replaces: `np.nanmax(rolling_window(T[..., start:stop], m), axis=T.ndim)` Parameters ---------- a : ndarray The input array w : ndarray, default None The rolling window size Returns ------- output : ndarray Rolling window nanmax. """ if w is None: w = a.shape[0] half_window_size = int(math.ceil((w - 1) / 2)) return maximum_filter1d(a, size=w)[half_window_size:half_window_size + a.shape[0] - w + 1]
def detect(self, threshold, combine=30, pre_avg=100, pre_max=30, post_avg=30, post_max=70, delay=0): """ Detects the onsets. :param threshold: threshold for peak-picking :param combine: only report 1 onset for N miliseconds :param pre_avg: use N miliseconds past information for moving average :param pre_max: use N miliseconds past information for moving maximum :param post_avg: use N miliseconds future information for mov. average :param post_max: use N miliseconds future information for mov. maximum :param delay: report the onset N miliseconds delayed In online mode, post_avg and post_max are set to 0. Implements the peak-picking method described in: "Evaluating the Online Capabilities of Onset Detection Methods" Sebastian Böck, Florian Krebs and Markus Schedl Proceedings of the 13th International Society for Music Information Retrieval Conference (ISMIR), 2012 """ # online mode? if self.online: post_max = 0 post_avg = 0 # convert timing information to frames pre_avg = int(round(self.fps * pre_avg / 1000.)) pre_max = int(round(self.fps * pre_max / 1000.)) post_max = int(round(self.fps * post_max / 1000.)) post_avg = int(round(self.fps * post_avg / 1000.)) # convert to seconds combine /= 1000. delay /= 1000. # init detections self.detections = [] # moving maximum max_length = pre_max + post_max + 1 max_origin = int(np.floor((pre_max - post_max) / 2)) mov_max = maximum_filter1d(self.activations, max_length, mode='constant', origin=max_origin) # moving average avg_length = pre_avg + post_avg + 1 avg_origin = int(np.floor((pre_avg - post_avg) / 2)) mov_avg = uniform_filter1d(self.activations, avg_length, mode='constant', origin=avg_origin) # detections are activation equal to the maximum detections = self.activations * (self.activations == mov_max) # detections must be greater or equal than the mov. average + threshold detections = detections * (detections >= mov_avg + threshold) # convert detected onsets to a list of timestamps last_onset = 0 for i in np.nonzero(detections)[0]: onset = float(i) / float(self.fps) + delay # only report an onset if the last N miliseconds none was reported if onset > last_onset + combine: self.detections.append(onset) # save last reported onset last_onset = onset
def Undersampled_Lip_Tragectory(phrase, Sleep_Time): A = "espeak -z -s 100 -v female5 -w test.wav " A = A + "'" + phrase + "'" #os.system("espeak -z -s 80 -v female5 -w test.wav 'Hey, why no one is looking at me? I feel neglected. I feel it! I am afraid!' ") os.system(A) samplerate, data = wavfile.read('test.wav') dt = 1 / float(samplerate) times = np.arange(len(data)) / float(samplerate) N = len(times) max_data = maximum_filter1d(data, size=1000) max_data = gaussian_filter(max_data, sigma=100) max_Amplitude = 10 Amplitude = max_Amplitude * (max_data / float(np.max(max_data))) n = Sleep_Time * samplerate Amp = [] T = [] i = 0 while (i * n < N): Amp.append(Amplitude[int(i * n)]) T.append(times[int(i * n)]) i = i + 1 Amp = np.array(Amp) T = np.array(T) ''' plt.figure(1) plt.suptitle(phrase) plt.subplot(211) plt.plot(times,data) plt.plot(times,max_data,'r') plt.subplot(212) plt.plot(times,Amplitude) plt.plot(T,Amp,'r*') plt.show() ''' return Amp, T
def Undersampled_Lip_Tragectory(phrase, Sleep_Time): A = "espeak -z -s 80 -v female5 -w test.wav " A = A + "'" + phrase + "'" os.system(A) samplerate, data = wavfile.read('test.wav') dt = 1 / float(samplerate) times = np.arange(len(data)) / float(samplerate) N = len(times) max_data = maximum_filter1d(data, size=1000) max_data = gaussian_filter(max_data, sigma=100) max_Amplitude = 10 Amplitude = max_Amplitude * (max_data / float(np.max(max_data))) n = Sleep_Time * samplerate Amp = [] T = [] i = 0 while (i * n < N): Amp.append(Amplitude[int(i * n)]) T.append(times[int(i * n)]) i = i + 1 Amp = np.array(Amp) T = np.array(T) return Amp, T
def Speech(phrase): flag = Event() flag.set() A = "espeak -z -s 80 -w temp.wav " A = A + "'" + phrase + "'" os.system(A) samplerate, data = wavfile.read('temp.wav') times = np.arange(len(data)) / float(samplerate) max_data = maximum_filter1d(data, size=500) max_Amplitude = 10 Amplitude = max_Amplitude * (max_data / float(np.max(max_data))) plt.figure(1) plt.plot(times, data) plt.plot(times, max_data, 'r') plt.show() plt.figure(2) plt.plot(times, Amplitude) plt.show() thread_movement = Thread(target=MoveLips, args=(times, Amplitude, flag)) thread_talk = Thread(target=Talk, args=(phrase, flag)) thread_talk.start() thread_movement.start() thread_talk.join() thread_movement.join() print(np.max(max_data))
def get_2D_peaks(arr2D, plot=False, amp_min=DEFAULT_AMP_MIN): # http://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.iterate_structure.html#scipy.ndimage.iterate_structure struct = generate_binary_structure(2, 1) neighborhood = iterate_structure(struct, PEAK_NEIGHBORHOOD_SIZE) # find local maxima using our filter shape local_max = maximum_filter1d(arr2D, size=PEAK_NEIGHBORHOOD_SIZE * 2 + 1, axis=0) local_max = maximum_filter1d(local_max, size=PEAK_NEIGHBORHOOD_SIZE * 2 + 1, axis=1) local_max = local_max == arr2D background = (arr2D == 0) eroded_background = binary_erosion(background, structure=neighborhood, border_value=1) # Boolean mask of arr2D with True at peaks (Fixed deprecated boolean operator by changing '-' to '^') detected_peaks = local_max ^ eroded_background # extract peaks amps = arr2D[detected_peaks] j, i = np.where(detected_peaks) # filter peaks amps = amps.flatten() peaks = zip(i, j, amps) peaks_filtered = filter(lambda x: x[2] > amp_min, peaks) # freq, time, amp # get indices for frequency and time frequency_idx = [] time_idx = [] for x in peaks_filtered: frequency_idx.append(x[1]) time_idx.append(x[0]) if plot: # scatter of the peaks fig, ax = plt.subplots() ax.imshow(arr2D) ax.scatter(time_idx, frequency_idx) ax.set_xlabel('Time') ax.set_ylabel('Frequency') ax.set_title("Spectrogram") plt.gca().invert_yaxis() plt.show() return zip(frequency_idx, time_idx)
def validate_signal(t, y, t_ref, y_ref, num=1000, dx=20, dy=0.1): """ Validate a signal y(t) against a reference signal y_ref(t_ref) by creating a band around y_ref and finding the values in y outside the band Parameters: t time of the signal y values of the signal t_ref time of the reference signal y_ref values of the reference signal num number of samples for the band dx horizontal width of the band in samples dy vertical distance of the band to y_ref Returns: t_band time values of the band y_min lower limit of the band y_max upper limit of the band i_out indices of the values in y outside the band """ from scipy.ndimage.filters import maximum_filter1d, minimum_filter1d from scipy.interpolate import interp1d # re-sample the reference signal into a uniform grid t_band = np.linspace(start=t_ref[0], stop=t_ref[-1], num=num) # make t_ref strictly monotonic by adding epsilon to duplicate sample times for i in range(1, len(t_ref)): while t_ref[i - 1] >= t_ref[i]: t_ref[i] = t_ref[i] + 1e-13 interp_method = 'linear' if y.dtype == np.float64 else 'zero' y_band = interp1d(x=t_ref, y=y_ref, kind=interp_method)(t_band) y_band_min = np.min(y_band) y_band_max = np.max(y_band) # calculate the width of the band if y_band_min == y_band_max: w = 0.5 if y_band_min == 0 else np.abs(y_band_min) * dy else: w = (y_band_max - y_band_min) * dy # calculate the lower and upper limits y_min = minimum_filter1d(input=y_band, size=dx) - w y_max = maximum_filter1d(input=y_band, size=dx) + w # find outliers y_min_i = np.interp(x=t, xp=t_band, fp=y_min) y_max_i = np.interp(x=t, xp=t_band, fp=y_max) i_out = np.logical_or(y < y_min_i, y > y_max_i) # do not count outliers outside the t_ref i_out = np.logical_and(i_out, t > t_band[0]) i_out = np.logical_and(i_out, t < t_band[-1]) return t_band, y_min, y_max, i_out
def get_mask(y, rpad=20, nmax=20): xp = y[1, :, :].flatten().astype('int32') yp = y[0, :, :].flatten().astype('int32') _, Ly, Lx = y.shape xm, ym = np.meshgrid(np.arange(Lx), np.arange(Ly)) xedges = np.arange(-.5 - rpad, xm.shape[1] + .5 + rpad, 1) yedges = np.arange(-.5 - rpad, xm.shape[0] + .5 + rpad, 1) #xp = (xm-dx).flatten().astype('int32') #yp = (ym-dy).flatten().astype('int32') h, _, _ = np.histogram2d(xp, yp, bins=[xedges, yedges]) hmax = maximum_filter1d(h, 5, axis=0) hmax = maximum_filter1d(hmax, 5, axis=1) yo, xo = np.nonzero(np.logical_and(h - hmax > -1e-6, h > 10)) Nmax = h[yo, xo] isort = np.argsort(Nmax)[::-1] yo, xo = yo[isort], xo[isort] pix = [] for t in range(len(yo)): pix.append([yo[t], xo[t]]) for iter in range(5): for k in range(len(pix)): ye, xe = extendROI(pix[k][0], pix[k][1], h.shape[0], h.shape[1], 1) igood = h[ye, xe] > 2 ye, xe = ye[igood], xe[igood] pix[k][0] = ye pix[k][1] = xe ibad = np.ones(len(pix), 'bool') for k in range(len(pix)): #print(pix[k][0].size) if pix[k][0].size < nmax: ibad[k] = 0 #pix = [pix[k] for k in ibad.nonzero()[0]] M = np.zeros(h.shape) for k in range(len(pix)): M[pix[k][0], pix[k][1]] = 1 + k M0 = M[rpad + xp, rpad + yp] M0 = np.reshape(M0, xm.shape) return M0, pix
def compute_sliding_minmax(array, Window, sig=2): if sig > 0: Flow = filters.gaussian_filter1d(array, sig) else: Flow = array Flow = filters.minimum_filter1d(Flow, Window, mode='wrap') Flow = filters.maximum_filter1d(Flow, Window, mode='wrap') return Flow
def filtermax(f, maxfiltsize=10): """Apply maximum filter to the spectrum to ignore deeper fluxes of absorption lines.""" # Maximum filter to ignore deeper fluxes of absorption lines f_maxfilt = maximum_filter1d(f, size=maxfiltsize) # Find points selected by maximum filter idxmax = np.array([i for i in range(len(f)) if f[i] - f_maxfilt[i] == 0.]) return f_maxfilt, idxmax
def center_baseline(V, sigma=100, window=500): ''' centers V so the baseline is at 0 ''' Flow = filters.gaussian_filter(V.T, [0.,sigma]) Flow = filters.minimum_filter1d(Flow, window) Flow = filters.maximum_filter1d(Flow, window) V_centered = (V.T - Flow).T #V_centered = (V.T - Flow.mean(axis=1)[:,np.newaxis]).T return V_centered
def find_reps(y, threshold, open_size, close_size): """ From the Y profile of a barbell's path, determine the concentric phase of each rep. The algorithm is as follows: 1. Compute the gradient (dy/dt) of the Y motion 2. Binarize the gradient signal by a minimum threshold value to eliminate noise. 3. Perform 1D opening by open_size using a minimum then maximum filter in series. 4. Perform 1D closing by close_size using a maximum then minimum filter in series. The result is a step function that is true for every time point that the concentric (+Y) phase of the rep is being performed. Parameters ---------- y : (N) array Y component of the motion of the barbell path. threshold : float Miniumum acceptable value of the gradient (dY/dt) to indicate a rep. Increasing this can help eliminate noise, but may cause a small delay after a rep begins to when it is counted, therefore underestimating the time to complete a rep. open_size : int Minimum threshold of length of time that it takes to complete a rep (in frames). Increase this if there are false positive spikes in the rep step signal that are small in width. close_size : int Minimum length of time that could be between reps. Increase this if there are false breaks between reps that should be continuous. Returns ------- (N) array Step signal representing when reps are performed. (1 indicates concentric phase of rep, 0 indicates no rep). """ ygrad = np.gradient(y) rep_signal = np.where(ygrad > threshold, 1, 0) # Opening to remove spikes rep_signal = maximum_filter1d(minimum_filter1d(rep_signal, open_size), open_size) # Closing to connect movements (as in the step up from the jerk) rep_signal = minimum_filter1d(maximum_filter1d(rep_signal, close_size), close_size) return rep_signal
def Synch_framestart(signal, L, spread=300, threshold=0.8): P = Synch_P(signal, L) R = Synch_R(signal, L) R = maximum_filter1d(R, spread) M = ((np.abs(P))**2) / (R**2) start, end = longest_block((M > threshold), 0)[:2] frame_start = int((start + end) / 2) freq_offset = np.mean(np.angle(P[start:end])) return frame_start, freq_offset, end
def connectedRegion(mLam, rsmall, d0): mLam0 = np.zeros(rsmall.shape) mLam1 = np.zeros(rsmall.shape) # non-zero lam's mLam0[rsmall<=d0] = mLam>0 mLam1[rsmall<=d0] = mLam mmax = mLam1.argmax() mask = np.zeros(rsmall.size) mask[mmax] = 1 mask = np.resize(mask, (2*d0+1, 2*d0+1)) for m in range(int(np.ceil(mask.shape[0]/2))): mask = filters.maximum_filter1d(mask, 3, axis=0) * mLam0 mask = filters.maximum_filter1d(mask, 3, axis=1) * mLam0 #mask = filters.maximum_filter(mask, footprint=rsmall<=1.5) * mLam0 mLam *= mask[rsmall<=d0] return mLam
def smoothingInput(self): print(self.edge_det_window, self.smoothing_window, self.smoothing_var) depths = np.array(self.data_list[0][self.fileIndex]) smoothing_filter = gaussian(self.smoothing_window, self.smoothing_var) / \ np.sum(gaussian(self.smoothing_window, self.smoothing_var)) union_depths = maximum_filter1d( depths, self.edge_det_window) ## MAX POOL to extract boarder lines final_depth = np.convolve(union_depths, smoothing_filter, mode='same') ## Smoothing boarder lines return final_depth
def smooth_covars(cov, size): T = cov.shape[0] dX = cov.shape[1] traces = np.empty([T]) for t in range(T): traces[t] = np.trace(cov[t]) smoothed_traces = maximum_filter1d(traces, size) for t in range(T): if smoothed_traces[t] > traces[t]: cov[t] += np.eye(dX) * (smoothed_traces[t] - traces[t]) / dX
def preprocess(F: np.ndarray, baseline: str, win_baseline: float, sig_baseline: float, fs: float, prctile_baseline: float = 0.9) -> np.ndarray: """ preprocesses fluorescence traces for spike deconvolution baseline-subtraction with window 'win_baseline' Parameters ---------------- F : float, 2D array size [neurons x time], in pipeline uses neuropil-subtracted fluorescence baseline : str setting that describes how to compute the baseline of each trace win_baseline : float window (in seconds) for max filter sig_baseline : float width of Gaussian filter in seconds fs : float sampling rate per plane prctile_baseline : float percentile of trace to use as baseline if using `constant_prctile` for baseline Returns ---------------- F : float, 2D array size [neurons x time], baseline-corrected fluorescence """ win = int(win_baseline * fs) if baseline == 'maximin': Flow = filters.gaussian_filter(F, [0., sig_baseline]) Flow = filters.minimum_filter1d(Flow, win) Flow = filters.maximum_filter1d(Flow, win) elif baseline == 'constant': Flow = filters.gaussian_filter(F, [0., sig_baseline]) Flow = np.amin(Flow) elif baseline == 'constant_prctile': Flow = np.percentile(F, prctile_baseline, axis=1) Flow = np.expand_dims(Flow, axis=1) else: Flow = 0. F = F - Flow return F
def _make_noise_gradient_color(grad): """ Make a noise gradient color. TODO: Improve noise gradient quality. Example: Descriptor(b'Grdn'){ 'Nm ': 'Custom\x00', 'GrdF': (b'GrdF', b'ClNs'), 'ShTr': False, 'VctC': False, 'ClrS': (b'ClrS', b'RGBC'), 'RndS': 3650322, 'Smth': 2048, 'Mnm ': [0, 0, 0, 0], 'Mxm ': [0, 100, 100, 100] } """ from scipy.ndimage.filters import maximum_filter1d, uniform_filter1d logger.debug('Noise gradient is not accurate.') roughness = grad.get(Key.Smoothness).value / 4096. # Larger is sharper. maximum = np.array([x.value for x in grad.get(Key.Maximum)], dtype=np.float32) minimum = np.array([x.value for x in grad.get(Key.Minimum)], dtype=np.float32) seed = grad.get(Key.RandomSeed).value rng = np.random.RandomState(seed) Y = rng.binomial(1, .5, (256, len(maximum))).astype(np.float32) size = max(1, int(roughness)) Y = maximum_filter1d(Y, size, axis=0) Y = uniform_filter1d(Y, size * 64, axis=0) Y = Y / np.max(Y, axis=0) Y = ((maximum - minimum) * Y + minimum) / 100. X = np.linspace(0, 1, 256, dtype=np.float32) if grad.get(Key.ShowTransparency): G = interpolate.interp1d(X, Y[:, :-1], axis=0, bounds_error=False, fill_value=(Y[0, :-1], Y[-1, :-1])) Ga = interpolate.interp1d(X, Y[:, -1], axis=0, bounds_error=False, fill_value=(Y[0, -1], Y[-1, -1])) else: G = interpolate.interp1d(X, Y[:, :3], axis=0, bounds_error=False, fill_value=(Y[0, :3], Y[-1, :3])) Ga = None return G, Ga
def validate_signal(t, y, t_ref, y_ref, num=1000, dx=20, dy=0.1): """ Validate a signal y(t) against a reference signal y_ref(t_ref) by creating a band around y_ref and finding the values in y outside the band Parameters: t time of the signal y values of the signal t_ref time of the reference signal y_ref values of the reference signal num number of samples for the band dx horizontal width of the band in samples dy vertical distance of the band to y_ref Returns: t_band time values of the band y_min lower limit of the band y_max upper limit of the band i_out indices of the values in y outside the band """ from scipy.ndimage.filters import maximum_filter1d, minimum_filter1d # re-sample the reference signal into a uniform grid t_band = np.linspace(start=t_ref[0], stop=t_ref[-1], num=num) # sort out the duplicate samples before the interpolation m = np.concatenate(([True], np.diff(t_ref) > 0)) y_band = np.interp(x=t_band, xp=t_ref[m], fp=y_ref[m]) y_band_min = np.min(y_band) y_band_max = np.max(y_band) # calculate the width of the band if y_band_min == y_band_max: w = 0.5 if y_band_min == 0 else np.abs(y_band_min) * dy else: w = (y_band_max - y_band_min) * dy # calculate the lower and upper limits y_min = minimum_filter1d(input=y_band, size=dx) - w y_max = maximum_filter1d(input=y_band, size=dx) + w # find outliers y_min_i = np.interp(x=t, xp=t_band, fp=y_min) y_max_i = np.interp(x=t, xp=t_band, fp=y_max) i_out = np.logical_or(y < y_min_i, y > y_max_i) # do not count outliers outside the t_ref i_out = np.logical_and(i_out, t > t_band[0]) i_out = np.logical_and(i_out, t < t_band[-1]) return t_band, y_min, y_max, i_out
def preprocessFeatureMat(X, Lfilt, logX=False, logXblur=False, capXblur=True, **sink): # if not capXblur: # X = localMaxFilterSimMat(X) # X = localMaxFilterSimMat(X) # Lfilt *= 2 # TODO remove after test featureMeans = np.mean(X, axis=1).reshape((-1, 1)) if logX and logXblur: X *= -np.log2(featureMeans) # variable encoding costs for rows Xblur = filterSimMat(X, Lfilt, 'hamming', scaleFilterMethod='max1') if logX and not logXblur: Xblur = filterSimMat(X, Lfilt, 'hamming', scaleFilterMethod='max1') X *= -np.log2(featureMeans) if not logX and logXblur: Xblur = filterSimMat(X, Lfilt, 'hamming', scaleFilterMethod='max1') Xblur *= np.log2(featureMeans) if not logX and not logXblur: Xblur = filterSimMat(X, Lfilt, 'hamming', scaleFilterMethod='max1') # Xblur = filterSimMat(X, Lfilt, 'flat', scaleFilterMethod='max1') if capXblur: # don't make long stretches also have large values maxima = filters.maximum_filter1d(Xblur, Lfilt // 2, axis=1, mode='constant') # maxima = filters.maximum_filter1d(Xblur, Lfilt, axis=1, mode='constant') Xblur[maxima > 0] /= maxima[maxima > 0] # print "preprocessFeatureMat(): max value in Xblur: ", np.max(Xblur) # 1.0 # import sys # sys.exit() # Xblur = np.minimum(Xblur, 1.) # plt.figure() # viz.imshowBetter(X) # plt.figure() # viz.imshowBetter(Xblur) # have columns be adjacent in memory X = np.asfortranarray(X) Xblur = np.asfortranarray(Xblur) # assert(np.all((X > 0.) <= (Xblur > 0.))) assert(np.all(np.sum(X, axis=1) > 0)) assert(np.all(np.sum(Xblur, axis=1) > 0)) # if np.max(X) > 1.: # print "X min" print "preprocessFeatureMat(): X shape, logX, logXblur", X.shape, logX, logXblur print "preprocessFeatureMat(): Lfilt", Lfilt print "preprocessFeatureMat(): X min, max", X.min(), X.max() print "preprocessFeatureMat(): Xblur min, max", Xblur.min(), Xblur.max() # import sys # sys.exit() return X, Xblur
def filter1d_same(a: np.ndarray, W: int, max_or_min: str, fillna=np.nan): out_dtype = np.full(0, fillna).dtype hW = (W - 1) // 2 # Half window size if max_or_min == 'max': out = maximum_filter1d(a, size=W, origin=hW) else: out = minimum_filter1d(a, size=W, origin=hW) if out.dtype is out_dtype: out[:W - 1] = fillna else: out = np.concatenate((np.full(W - 1, fillna), out[W - 1:])) return out
def process_cut(spect, stddevs=3, ignore=2): from scipy.ndimage.filters import maximum_filter1d # "loudness" curve loud = np.log(np.sum(np.exp(spect), axis=1)) # normieren nloud = (loud - np.mean(loud)) / np.std(loud) lowloud = nloud < -stddevs # schauen, ob innerhalb von 3 stddevs, Klicks darin (bis zu 2 Frames lang) ignorieren. fltloud = ~maximum_filter1d(lowloud, ignore + 1) where_ok = np.where(fltloud)[0] cut_front = np.min(where_ok) cut_back = np.max(where_ok) return cut_front, cut_back + 1
def _gradient_nms(self, accumulated_grad, win_size=3): ''' Non-maximum suppression to find local maximum of accumulated gradient. @accumulated_grad: np.array, input accumulated gradient. @win_size: int, sliding window length. It decides how much you refer to neighbor field values. @return: list, local maximum accumulated gradient indexs. ''' indexs = [] maximas = maximum_filter1d(accumulated_grad, win_size) for i in range(len(accumulated_grad)): if accumulated_grad[i] > 0 and abs(accumulated_grad[i] - maximas[i]) < 1e-6: indexs.append(i) return indexs
def preprocess(F,ops): sig = ops['sig_baseline'] win = int(ops['win_baseline']*ops['fs']) if ops['baseline']=='maximin': Flow = filters.gaussian_filter(F, [0., sig]) Flow = filters.minimum_filter1d(Flow, win) Flow = filters.maximum_filter1d(Flow, win) elif ops['baseline']=='constant': Flow = filters.gaussian_filter(F, [0., sig]) Flow = np.amin(Flow) elif ops['baseline']=='constant_prctile': Flow = np.percentile(F, ops['prctile_baseline'], axis=1) Flow = np.expand_dims(Flow, axis = 1) else: Flow = 0. F = F - Flow return F
def generate_Lip_Tragectory(phrase): A = "espeak -z -s 80 -v female5 -w test.wav " A = A + "'" + phrase + "'" #os.system("espeak -z -s 80 -v female5 -w test.wav 'Hey, why no one is looking at me? I feel neglected. I feel it! I am afraid!' ") os.system(A) samplerate, data = wavfile.read('test.wav') dt = 1 / float(samplerate) times = np.arange(len(data)) / float(samplerate) N = len(times) max_data = maximum_filter1d(data, size=1000) max_data = gaussian_filter(max_data, sigma=100) max_Amplitude = 10 Amplitude = np.round(max_Amplitude * (max_data / np.max(max_data))) Extrema = argrelextrema(max_data, np.less_equal, order=100)[0] Amplitude = Amplitude[Extrema] Sleep_Time = [] for i in range(len(Extrema)): if (i + 1 < len(Extrema)): Sleep_Time.append(dt * (times[Extrema[i + 1]] - times[Extrema[i]])) return np.array(Amplitude), np.array(Sleep_Time), Extrema
def preprocess(F, ops): """ preprocesses fluorescence traces for spike deconvolution baseline-subtraction with window 'win_baseline' Parameters ---------------- F : float, 2D array size [neurons x time], in pipeline uses neuropil-subtracted fluorescence ops : dictionary 'baseline', 'win_baseline', 'sig_baseline', 'fs', (optional 'prctile_baseline' needed if ops['baseline']=='constant_prctile') Returns ---------------- F : float, 2D array size [neurons x time], baseline-corrected fluorescence """ sig = ops['sig_baseline'] win = int(ops['win_baseline'] * ops['fs']) if ops['baseline'] == 'maximin': Flow = filters.gaussian_filter(F, [0., sig]) Flow = filters.minimum_filter1d(Flow, win) Flow = filters.maximum_filter1d(Flow, win) elif ops['baseline'] == 'constant': Flow = filters.gaussian_filter(F, [0., sig]) Flow = np.amin(Flow) elif ops['baseline'] == 'constant_prctile': Flow = np.percentile(F, ops['prctile_baseline'], axis=1) Flow = np.expand_dims(Flow, axis=1) else: Flow = 0. F = F - Flow return F
# Compute errors. max_errors = [] av_errors = [] for color in range(0, 3): max_error = np.zeros(6) av_error = np.zeros(6) for c in range(0, num_checkers): # Get min. absolute diff to envelopes. env_diff = np.minimum(np.fabs(checker_int[color][c, :] - envelopes[color][:, 0]), np.fabs(checker_int[color][c, :] - envelopes[color][:, 2])) # Reject values within vincinity of envelopes. reject_mask = img_filters.maximum_filter1d(np.int_(env_diff <= 0.02), 7) if np.min(reject_mask) != 1: int_vals = checker_int[color][c, :]; int_vals = int_vals[reject_mask != 1] median = np.median(int_vals) max_error[c] = np.max(np.fabs(int_vals - median)) av_error[c] = np.std(int_vals) max_errors.append(max_error) av_errors.append(av_error) color_name = [ 'red', 'green', 'blue' ] print "Average error: " for color in range(0, 3):
def detect(self, threshold, combine=0.03, pre_avg=0.15, pre_max=0.01, post_avg=0, post_max=0.05, delay=0): """ Detects the onsets. :param threshold: threshold for peak-picking :param combine: only report 1 onset for N seconds :param pre_avg: use N seconds past information for moving average :param pre_max: use N seconds past information for moving maximum :param post_avg: use N seconds future information for moving average :param post_max: use N seconds future information for moving maximum :param delay: report the onset N seconds delayed In online mode, post_avg and post_max are set to 0. Implements the peak-picking method described in: "Evaluating the Online Capabilities of Onset Detection Methods" Sebastian Böck, Florian Krebs and Markus Schedl Proceedings of the 13th International Society for Music Information Retrieval Conference (ISMIR), 2012 """ # online mode? if self.online: post_max = 0 post_avg = 0 # convert timing information to frames pre_avg = int(round(self.fps * pre_avg)) pre_max = int(round(self.fps * pre_max)) post_max = int(round(self.fps * post_max)) post_avg = int(round(self.fps * post_avg)) # convert to seconds combine /= 1000. delay /= 1000. # init detections self.detections = [] # moving maximum max_length = pre_max + post_max + 1 max_origin = int(np.floor((pre_max - post_max) / 2)) mov_max = maximum_filter1d(self.activations, max_length, mode='constant', origin=max_origin) # moving average avg_length = pre_avg + post_avg + 1 avg_origin = int(np.floor((pre_avg - post_avg) / 2)) mov_avg = uniform_filter1d(self.activations, avg_length, mode='constant', origin=avg_origin) # detections are activation equal to the moving maximum detections = self.activations * (self.activations == mov_max) # detections must be greater or equal than the mov. average + threshold detections *= (detections >= mov_avg + threshold) # convert detected onsets to a list of timestamps detections = np.nonzero(detections)[0].astype(np.float) / self.fps # shift if necessary if delay != 0: detections += delay # always use the first detection and all others if none was reported # within the last `combine` seconds if detections.size > 1: # filter all detections which occur within `combine` seconds combined_detections = detections[1:][np.diff(detections) > combine] # add them after the first detection self.detections = np.append(detections[0], combined_detections) else: self.detections = detections