Look at the filter function. If you just need a 1-pole low-pass filter, it’s xfilt = filter(a, [1 a-1], x); where a = T/τ, T = the time between samples, and τ (tau) is the filter time constant. Here’s the corresponding high-pass filter: xfilt = filter([1-a a-1],[1 a-1], x); If you need to design a … Read more
Here’s a bit of code that might help. from __future__ import division import numpy as np def find_transition_times(t, y, threshold): “”” Given the input signal `y` with samples at times `t`, find the times where `y` increases through the value `threshold`. `t` and `y` must be 1-D numpy arrays. Linear interpolation is used to estimate … Read more
I prefer a Savitzky-Golay filter. It uses least squares to regress a small window of your data onto a polynomial, then uses the polynomial to estimate the point in the center of the window. Finally the window is shifted forward by one data point and the process repeats. This continues until every point has been … Read more
Yes, it is possible to recover most of the signal and estimate the phase with e.g. Griffin-Lim Algorithm (GLA). Its “fast” implementation for Python can be found in librosa. Here’s how you can use it: import numpy as np import librosa y, sr = librosa.load(librosa.util.example_audio_file(), duration=10) S = np.abs(librosa.stft(y)) y_inv = librosa.griffinlim(S) And that’s how … Read more
Pitch is not the same as peak magnitude frequency bin (which is what the FFT in the Accelerate framework might give you directly). So any peak frequency detector will not be reliable for pitch estimation. A low-pass filter will not help when the note has a missing or very weak fundamental (common in some voice, … Read more
Instead of a convolution you should use a correlation. The size of the correlation peak tells you how much both signals are alike, the position of the peak their relative position in time, or the delay between both signals.
There are a number of different ways to do it with scipy, but 2D convolution isn’t directly included in numpy. (It’s also easy to implement with an fft using only numpy, if you need to avoid a scipy dependency.) scipy.signal.convolve2d, scipy.signal.convolve, scipy.signal.fftconvolve, and scipy.ndimage.convolve will all handle a 2D convolution (the last three are N-d) … Read more
There are two issues: the way you use the FFT, and the particular filter. Filtering is traditionally implemented as convolution in the time domain. You’re right that multiplying the spectra of the input and filter signals is equivalent. However, when you use the Discrete Fourier Transform (DFT) (implemented with a Fast Fourier Transform algorithm for … Read more
My favorite resource for audio interpolating (especially in resampling applications) is Olli Niemitalo’s “Elephant” paper. I’ve used a couple of these and they sound terrific (much better than a straight cubic solution, which is relatively noisy). There are spline forms, Hermite forms, Watte, parabolic, etc. And they are discussed from an audio point-of-view. This is … Read more