def THDN(signal, sample_rate, filename):
signal = signal - mean(signal) # this is so that the DC offset is not the peak in the case of PDM
windowed = signal * blackmanharris(len(signal))
# Find the peak of the frequency spectrum (fundamental frequency), and filter
# the signal by throwing away values between the nearest local minima
f = rfft(windowed)
#limit the bandwidth
if len(f) > 24000:
f[24000:len(f)] = 0
bandwidth_limited = irfft(f)
total_rms = rms_flat(bandwidth_limited)
#for i in range(6000):
#print abs(f[i])
i = argmax(abs(f))
#This will be exact if the frequency under test falls into the middle of an fft bin
print 'Frequency: %f Hz' % (sample_rate * (i / len(windowed)))
lowermin, uppermin = find_range(abs(f), i)
#notch out the signal
f[lowermin: uppermin] = 0
noise = irfft(f)
THDN = rms_flat(noise) / total_rms
print "THD+N: %.12f%% or %.12f dB" % (THDN * 100, 20 * log10(THDN))
def freq_from_HPS(sig, fs):
"""
Estimate frequency using harmonic product spectrum (HPS)
"""
windowed = sig * blackmanharris(len(sig))
from pylab import subplot, plot, log, copy, show
#harmonic product spectrum:
c = abs(rfft(windowed))
maxharms = 8
subplot(maxharms,1,1)
plot(log(c))
for x in range(2,maxharms):
a = copy(c[::x]) #Should average or maximum instead of decimating
# max(c[::x],c[1::x],c[2::x],...)
c = c[:len(a)]
i = argmax(abs(c))
true_i = parabolic(abs(c), i)[0]
print 'Pass %d: %f Hz' % (x, fs * true_i / len(windowed))
c *= a
subplot(maxharms,1,x)
plot(log(c))
show()
def window(f,start,stop,type='blackman'):
"""
runs the data through a hamming window.
@param f: The data matrix
@param start: The start index of the hamming window.
@param stop: The end index of the hamming window.
"""
h=numpy.zeros(f.shape,dtype=float)
if len(h.shape)==1:
if type=='hamming':
h[start:stop]=signal.hamming(stop-start)
elif type=='blackman':
h[start:stop]=signal.blackman(stop-start)
elif type=='hann':
h[start:stop]=signal.hann(stop-start)
elif type=='blackmanharris':
h[start:stop]=signal.blackmanharris(stop-start)
elif type=='rectangular' or type=='rect' or type=='boxcar':
h[start:stop]=signal.boxcar(stop-start)
else:
if type=='hamming':
h[:,start:stop]=signal.hamming(stop-start)
elif type=='blackman':
h[:,start:stop]=signal.blackman(stop-start)
elif type=='hann':
h[:,start:stop]=signal.hann(stop-start)
elif type=='blackmanharris':
h[:,start:stop]=signal.blackmanharris(stop-start)
elif type=='rectangular' or type=='rect' or type=='boxcar':
h[:,start:stop]=signal.boxcar(stop-start)
return numpy.multiply(f,h)
def delayTransformVisibilities(visList,df,kernel=None,wind='Blackman-Harris'):
'''
ARGS:
visList: nfreqxnvis complex matrix of visibilities
df: float indicating channel width
RETURNS:
ndelayxnvis grid of delay-transformed visibilities
'''
nf=visList.shape[0]
if kernel is None:
kernel=np.ones(nf)
nv=visList.shape[1]
windowGrid=np.zeros_like(visList)
if wind=='Blackman-Harris':
window=signal.blackmanharris(nf)
elif wind=='Nithya':
window=signal.blackmanharris(nf/2)
window=signal.fftconvolve(window,window,mode='full')
window=np.append(window,window[-1])
window/=window.max()
window/=np.sqrt(np.mean(np.abs(kernel*window)**2.))
for vNum in range(nv):
windowGrid[:,vNum]=window*kernel
return df*fft.fftshift(fft.fft(fft.fftshift(visList*windowGrid,axes=[0]),axis=0),axes=[0])
def test_basic(self):
assert_allclose(signal.blackmanharris(6, False),
[6.0e-05, 0.055645, 0.520575, 1.0, 0.520575, 0.055645])
assert_allclose(signal.blackmanharris(6),
[6.0e-05, 0.1030114893456638, 0.7938335106543362,
0.7938335106543364, 0.1030114893456638, 6.0e-05])
assert_allclose(signal.blackmanharris(7, sym=True),
[6.0e-05, 0.055645, 0.520575, 1.0, 0.520575, 0.055645,
6.0e-05])
def test_basic(self):
assert_allclose(signal.blackmanharris(6, False),
[6.0e-05, 0.055645, 0.520575, 1.0, 0.520575, 0.055645])
assert_allclose(signal.blackmanharris(7, sym=False),
[6.0e-05, 0.03339172347815117, 0.332833504298565,
0.8893697722232837, 0.8893697722232838,
0.3328335042985652, 0.03339172347815122])
assert_allclose(signal.blackmanharris(6),
[6.0e-05, 0.1030114893456638, 0.7938335106543362,
0.7938335106543364, 0.1030114893456638, 6.0e-05])
assert_allclose(signal.blackmanharris(7, sym=True),
[6.0e-05, 0.055645, 0.520575, 1.0, 0.520575, 0.055645,
6.0e-05])
def sinewaveSynth(freq, mag, N, H, fs):
# Synthesis of a time-varying sinusoid
# freq,mag, phase: frequency, magnitude and phase of sinusoid,
# N: synthesis FFT size, H: hop size, fs: sampling rate
# returns y: output array sound
hN = N/2 # half of FFT size for synthesis
L = freq.size # number of frames
pout = 0 # initialize output sound pointer
ysize = H*(L+3) # output sound size
y = np.zeros(ysize) # initialize output array
sw = np.zeros(N) # initialize synthesis window
ow = triang(2*H); # triangular window
sw[hN-H:hN+H] = ow # add triangular window
bh = blackmanharris(N) # blackmanharris window
bh = bh / sum(bh) # normalized blackmanharris window
sw[hN-H:hN+H] = sw[hN-H:hN+H]/bh[hN-H:hN+H] # normalized synthesis window
lastfreq = freq[0] # initialize synthesis frequencies
phase = 0 # initialize synthesis phases
for l in range(L): # iterate over all frames
phase += (np.pi*(lastfreq+freq[l])/fs)*H # propagate phases
Y = UF.genSpecSines(freq[l], mag[l], phase, N, fs) # generate sines in the spectrum
lastfreq = freq[l] # save frequency for phase propagation
yw = np.real(fftshift(ifft(Y))) # compute inverse FFT
y[pout:pout+N] += sw*yw # overlap-add and apply a synthesis window
pout += H # advance sound pointer
y = np.delete(y, range(hN)) # delete half of first window
y = np.delete(y, range(y.size-hN, y.size)) # delete half of the last window
return y
def stochasticResidual(x, N, H, sfreq, smag, sphase, fs, stocf):
# subtract sinusoids from a sound
# x: input sound, N: fft-size, H: hop-size
# sfreq, smag, sphase: sinusoidal frequencies, magnitudes and phases
# returns mYst: stochastic approximation of residual
hN = N/2
x = np.append(np.zeros(hN),x) # add zeros at beginning to center first window at sample 0
x = np.append(x,np.zeros(hN)) # add zeros at the end to analyze last sample
bh = blackmanharris(N) # synthesis window
w = bh/ sum(bh) # normalize synthesis window
L = sfreq[:,0].size # number of frames
pin = 0
for l in range(L):
xw = x[pin:pin+N]*w # window the input sound
X = fft(fftshift(xw)) # compute FFT
Yh = UF_C.genSpecSines(N*sfreq[l,:]/fs, smag[l,:], sphase[l,:], N) # generate spec sines
Xr = X-Yh # subtract sines from original spectrum
mXr = 20*np.log10(abs(Xr[:hN])) # magnitude spectrum of residual
mXrenv = resample(np.maximum(-200, mXr), mXr.size*stocf) # decimate the mag spectrum
if l == 0:
mYst = np.array([mXrenv])
else:
mYst = np.vstack((mYst, np.array([mXrenv])))
pin += H # advance sound pointer
return mYst
def run(self, tf, dt, K, c1, c2):
""" Run a simulation """
n, m, k = self.n, self.m, self.k
# Total simulation time
simTime = int(tf / dt)
# Returns the three synaptic connections kernels
W12, W21, W22, delays = self.build_kernels(K)
# Compute delays by dividing distances by axonal velocity
delays12 = np.floor(delays[0] / c2)
delays21 = np.floor(delays[1] / c1)
delays22 = np.floor(delays[2] / c2)
maxDelay = int(max(delays12[0].max(), delays21[0].max(), delays22[0].max()))
# Set the initial conditions and the history
self.initial_conditions(simTime)
# Initialize the cortical and striatal inputs
Cx = 0.5
Str = 0.4
# Presynaptic activities
pre12, pre21, pre22 = np.empty((m,)), np.empty((m,)), np.empty((m,))
# Simulation
for i in range(maxDelay, simTime):
# Take into account the history of rate for each neuron according
# to its axonal delay
for idxi, ii in enumerate(range(m)):
mysum = 0.0
for jj in range(k, n):
mysum += (W12[ii, jj] * self.X2[i - delays12[ii, jj], jj]) * self.dx
pre12[idxi] = mysum
for idxi, ii in enumerate(range(k, n)):
mysum = 0.0
for jj in range(0, m):
mysum += (W21[ii, jj] * self.X1[i - delays21[ii, jj], jj]) * self.dx
pre21[idxi] = mysum
for idxi, ii in enumerate(range(k, n)):
mysum = 0.0
for jj in range(k, n):
mysum += (W22[ii, jj] * self.X2[i - delays22[ii, jj], jj]) * self.dx
pre22[idxi] = mysum
# Forward Euler step
self.X1[i, :m] = self.X1[i - 1, :m] + (-self.X1[i - 1, :m] + self.S1(-pre12 + Cx)) * dt / self.tau1
self.X2[i, k:] = self.X2[i - 1, k:] + (-self.X2[i - 1, k:] + self.S2(pre21 - pre22 - Str)) * dt / self.tau2
dx = 1.0 / float(m)
fr = self.X1.sum(axis=1) * dx / 1.0
signal = detrend(fr)
windowed = signal * blackmanharris(len(signal))
f = rfft(windowed)
i = np.argmax(np.abs(f))
# true_i = parabolic(np.log(np.abs(f)), i)[0]
return i
def sineModelSynth(tfreq, tmag, tphase, N, H, fs):
"""
Synthesis of a sound using the sinusoidal model
tfreq, tmag, tphase: frequencies, magnitudes and phases of sinusoids
N: synthesis FFT size, H: hop size, fs: sampling rate
returns y: output array sound
"""
hN = N / 2 # half of FFT size for synthesis
L = tfreq.shape[0] # number of frames
pout = 0
ysize = H * (L+3)
y = np.zeros(ysize)
# synthesis window
sw = np.zeros(N)
ow = triang(2 * H)
sw[hN-H:hN+H] = ow
bh = blackmanharris(N)
bh = bh / sum(bh)
sw[hN-H:hN+H] = sw[hN-H:hN+H] / bh[hN-H:hN+H]
lastytfreq = tfreq[0,:]
ytphase = 2*np.pi*np.random.rand(tfreq[0,:].size)
for l in range(L): # iterate over all frames
if (tphase.size > 0):
ytphase = tphase[l, :]
def waveform_to_file(station,clen=10000,oversample=10, filt=False, outpath=None,verbose=False):
"""
lets use 0.1 s code cycle and coherence assumption
our transmit bandwidth is 100 kHz, and with a clen=10e3 baud code,
that is 0.1 seconds per cycle as a coherence assumption.
furthermore, we use a 1 MHz bandwidth, so we oversample by a factor of 10.
NOTE: this writing method doesn't store any metadata - have to know the sample rate
"""
a = rep_seq(create_pseudo_random_code(clen,station,verbose), rep=oversample)
if filt == True:
w = np.zeros([oversample*clen], dtype='complex64') # yes, zeros for zero-padded
fl = int(oversample+(0.1*oversample))
w[:fl]= signal.blackmanharris(fl) # W[fl:] \equiv 0
aa = np.fft.ifft(np.fft.fft(w) * np.fft.fft(a))
a = (aa/abs(aa).max()).astype('complex64') #normalized, single prec complex
if outpath:
p = Path(outpath).expanduser()
p.mkdir(parents=True, exist_ok=True)
ofn = p / f"code-l{clen}-b{oversample}-{station:06d}.bin"
print('writing',ofn)
# https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.tofile.html
a.tofile(ofn) # this binary format is OK for GNU Radio to read
return a
def sineSubtraction(x, N, H, sfreq, smag, sphase, fs): """ Subtract sinusoids from a sound x: input sound, N: fft-size, H: hop-size sfreq, smag, sphase: sinusoidal frequencies, magnitudes and phases returns xr: residual sound """ hN = N/2 # half of fft size x = np.append(np.zeros(hN),x) # add zeros at beginning to center first window at sample 0 x = np.append(x,np.zeros(hN)) # add zeros at the end to analyze last sample bh = blackmanharris(N) # blackman harris window w = bh/ sum(bh) # normalize window sw = np.zeros(N) # initialize synthesis window sw[hN-H:hN+H] = triang(2*H) / w[hN-H:hN+H] # synthesis window L = sfreq.shape[0] # number of frames, this works if no sines xr = np.zeros(x.size) # initialize output array pin = 0 for l in range(L): xw = x[pin:pin+N]*w # window the input sound X = fft(fftshift(xw)) # compute FFT Yh = UF_C.genSpecSines(N*sfreq[l,:]/fs, smag[l,:], sphase[l,:], N) # generate spec sines Xr = X-Yh # subtract sines from original spectrum xrw = np.real(fftshift(ifft(Xr))) # inverse FFT xr[pin:pin+N] += xrw*sw # overlap-add pin += H # advance sound pointer xr = np.delete(xr, range(hN)) # delete half of first window which was added in stftAnal xr = np.delete(xr, range(xr.size-hN, xr.size)) # delete half of last window which was added in stftAnal return xr
def freq_power_from_fft(sig, fs):
# Compute Fourier transform of windowed signal
windowed = sig * blackmanharris(CHUNK)
fftData = abs(rfft(windowed))
# powerData = 20*log10(fftData)
# Find the index of the peak and interpolate to get a more accurate peak
i = argmax(fftData) # Just use this for less-accurate, naive version
# make sure i is not an endpoint of the bin
if i != len(fftData)-1 and i != 0:
#print("data: " + str(parabolic(log(abs(fftData)), i)))
true_i,logmag = parabolic(log(abs(fftData)), i)
# Convert to equivalent frequency
freq= fs * true_i / len(windowed)
#print("frequency="+ str(freq) + " log of magnitude=" + str(logmag))
if logmag < 0:
logmag = 0
return freq,logmag
else:
freq = fs * i / len(windowed)
logmag = log(abs(fftData))[i]
if logmag < 0:
logmag = 0
#print("frequency="+ str(freq) + "log of magnitude not interp=" + str(logmag))
return freq,logmag
def stochasticResidualAnal(x, N, H, sfreq, smag, sphase, fs, stocf): """ Subtract sinusoids from a sound and approximate the residual with an envelope x: input sound, N: fft size, H: hop-size sfreq, smag, sphase: sinusoidal frequencies, magnitudes and phases fs: sampling rate; stocf: stochastic factor, used in the approximation returns stocEnv: stochastic approximation of residual """ hN = N/2 # half of fft size x = np.append(np.zeros(hN),x) # add zeros at beginning to center first window at sample 0 x = np.append(x,np.zeros(hN)) # add zeros at the end to analyze last sample bh = blackmanharris(N) # synthesis window w = bh/ sum(bh) # normalize synthesis window L = sfreq.shape[0] # number of frames, this works if no sines pin = 0 for l in range(L): xw = x[pin:pin+N] * w # window the input sound X = fft(fftshift(xw)) # compute FFT Yh = UF_C.genSpecSines(N*sfreq[l,:]/fs, smag[l,:], sphase[l,:], N) # generate spec sines Xr = X-Yh # subtract sines from original spectrum mXr = 20*np.log10(abs(Xr[:hN])) # magnitude spectrum of residual mXrenv = resample(np.maximum(-200, mXr), mXr.size*stocf) # decimate the mag spectrum if l == 0: # if first frame stocEnv = np.array([mXrenv]) else: # rest of frames stocEnv = np.vstack((stocEnv, np.array([mXrenv]))) pin += H # advance sound pointer return stocEnv
def sineModelSynth(tfreq, tmag, tphase, N, H, fs): """ Synthesis of a sound using the sinusoidal model tfreq,tmag,tphase: frequencies, magnitudes and phases of sinusoids N: synthesis FFT size, H: hop size, fs: sampling rate returns y: output array sound """ hN = N/2 # half of FFT size for synthesis L = tfreq.shape[0] # number of frames pout = 0 # initialize output sound pointer ysize = H*(L+3) # output sound size y = np.zeros(ysize) # initialize output array sw = np.zeros(N) # initialize synthesis window ow = triang(2*H) # triangular window sw[hN-H:hN+H] = ow # add triangular window bh = blackmanharris(N) # blackmanharris window bh = bh / sum(bh) # normalized blackmanharris window sw[hN-H:hN+H] = sw[hN-H:hN+H]/bh[hN-H:hN+H] # normalized synthesis window lastytfreq = tfreq[0,:] # initialize synthesis frequencies ytphase = 2*np.pi*np.random.rand(tfreq[0,:].size) # initialize synthesis phases for l in range(L): # iterate over all frames if (tphase.size > 0): # if no phases generate them ytphase = tphase[l,:] else: ytphase += (np.pi*(lastytfreq+tfreq[l,:])/fs)*H # propagate phases Y = UF.genSpecSines(tfreq[l,:], tmag[l,:], ytphase, N, fs) # generate sines in the spectrum lastytfreq = tfreq[l,:] # save frequency for phase propagation ytphase = ytphase % (2*np.pi) # make phase inside 2*pi yw = np.real(fftshift(ifft(Y))) # compute inverse FFT y[pout:pout+N] += sw*yw # overlap-add and apply a synthesis window pout += H # advance sound pointer y = np.delete(y, range(hN)) # delete half of first window y = np.delete(y, range(y.size-hN, y.size)) # delete half of the last window return y
def plot_specgram(ax, data, fs, nfft=256, noverlap=128, window='hann',
cmap='jet', interpolation='bilinear', rasterized=True):
if window not in SPECGRAM_WINDOWS:
raise ValueError("Window not supported")
elif window == "boxcar":
mwindow = signal.boxcar(nfft)
elif window == "hamming":
mwindow = signal.hamming(nfft)
elif window == "hann":
mwindow = signal.hann(nfft)
elif window == "bartlett":
mwindow = signal.bartlett(nfft)
elif window == "blackman":
mwindow = signal.blackman(nfft)
elif window == "blackmanharris":
mwindow = signal.blackmanharris(nfft)
specgram, freqs, time = mlab.specgram(data, NFFT=nfft, Fs=fs,
window=mwindow,
noverlap=noverlap)
specgram = 10 * np.log10(specgram[1:, :])
specgram = np.flipud(specgram)
freqs = freqs[1:]
halfbin_time = (time[1] - time[0]) / 2.0
halfbin_freq = (freqs[1] - freqs[0]) / 2.0
extent = (time[0] - halfbin_time, time[-1] + halfbin_time,
freqs[0] - halfbin_freq, freqs[-1] + halfbin_freq)
ax.imshow(specgram, cmap=cmap, interpolation=interpolation,
extent=extent, rasterized=rasterized)
ax.axis('tight')
def _BLACKMANHARRIS_Window(signal):
""" blackman-harris window process
Use Windows to smooth transient data in the begin/end
"""
windowed = signal * blackmanharris(len(signal)) # TODO Kaiser?
return windowed
def harmonicModel(x, fs, w, N, t, nH, minf0, maxf0, f0et): """ Analysis/synthesis of a sound using the sinusoidal harmonic model x: input sound, fs: sampling rate, w: analysis window, N: FFT size (minimum 512), t: threshold in negative dB, nH: maximum number of harmonics, minf0: minimum f0 frequency in Hz, maxf0: maximim f0 frequency in Hz, f0et: error threshold in the f0 detection (ex: 5), returns y: output array sound """ hN = N/2 # size of positive spectrum hM1 = int(math.floor((w.size+1)/2)) # half analysis window size by rounding hM2 = int(math.floor(w.size/2)) # half analysis window size by floor x = np.append(np.zeros(hM2),x) # add zeros at beginning to center first window at sample 0 x = np.append(x,np.zeros(hM1)) # add zeros at the end to analyze last sample Ns = 512 # FFT size for synthesis (even) H = Ns/4 # Hop size used for analysis and synthesis hNs = Ns/2 pin = max(hNs, hM1) # init sound pointer in middle of anal window pend = x.size - max(hNs, hM1) # last sample to start a frame fftbuffer = np.zeros(N) # initialize buffer for FFT yh = np.zeros(Ns) # initialize output sound frame y = np.zeros(x.size) # initialize output array w = w / sum(w) # normalize analysis window sw = np.zeros(Ns) # initialize synthesis window ow = triang(2*H) # overlapping window sw[hNs-H:hNs+H] = ow bh = blackmanharris(Ns) # synthesis window bh = bh / sum(bh) # normalize synthesis window sw[hNs-H:hNs+H] = sw[hNs-H:hNs+H] / bh[hNs-H:hNs+H] # window for overlap-add hfreqp = [] f0t = 0 f0stable = 0 while pin<pend: #-----analysis----- x1 = x[pin-hM1:pin+hM2] # select frame mX, pX = DFT.dftAnal(x1, w, N) # compute dft ploc = UF.peakDetection(mX, t) # detect peak locations iploc, ipmag, ipphase = UF.peakInterp(mX, pX, ploc) # refine peak values ipfreq = fs * iploc/N f0t = UF.f0Twm(ipfreq, ipmag, f0et, minf0, maxf0, f0stable) # find f0 if ((f0stable==0)&(f0t>0)) \ or ((f0stable>0)&(np.abs(f0stable-f0t)<f0stable/5.0)): f0stable = f0t # consider a stable f0 if it is close to the previous one else: f0stable = 0 hfreq, hmag, hphase = harmonicDetection(ipfreq, ipmag, ipphase, f0t, nH, hfreqp, fs) # find harmonics hfreqp = hfreq #-----synthesis----- Yh = UF.genSpecSines(hfreq, hmag, hphase, Ns, fs) # generate spec sines fftbuffer = np.real(ifft(Yh)) # inverse FFT yh[:hNs-1] = fftbuffer[hNs+1:] # undo zero-phase window yh[hNs-1:] = fftbuffer[:hNs+1] y[pin-hNs:pin+hNs] += sw*yh # overlap-add pin += H # advance sound pointer y = np.delete(y, range(hM2)) # delete half of first window which was added in stftAnal y = np.delete(y, range(y.size-hM1, y.size)) # add zeros at the end to analyze last sample return y
def freq_from_fft(signal, fs):
# Compute Fourier transform of windowed signal
windowed = signal * blackmanharris(len(signal))
f = rfft(windowed)
i = argmax(abs(f))
# Convert to equivalent frequency
return fs*i/len(windowed)
def sprModel(x, fs, w, N, t): """ Analysis/synthesis of a sound using the sinusoidal plus residual model, one frame at a time x: input sound, fs: sampling rate, w: analysis window, N: FFT size (minimum 512), t: threshold in negative dB, returns y: output sound, ys: sinusoidal component, xr: residual component """ hN = N/2 # size of positive spectrum hM1 = int(math.floor((w.size+1)/2)) # half analysis window size by rounding hM2 = int(math.floor(w.size/2)) # half analysis window size by floor Ns = 512 # FFT size for synthesis (even) H = Ns/4 # Hop size used for analysis and synthesis hNs = Ns/2 pin = max(hNs, hM1) # initialize sound pointer in middle of analysis window pend = x.size - max(hNs, hM1) # last sample to start a frame fftbuffer = np.zeros(N) # initialize buffer for FFT ysw = np.zeros(Ns) # initialize output sound frame xrw = np.zeros(Ns) # initialize output sound frame ys = np.zeros(x.size) # initialize output array xr = np.zeros(x.size) # initialize output array w = w / sum(w) # normalize analysis window sw = np.zeros(Ns) ow = triang(2*H) # overlapping window sw[hNs-H:hNs+H] = ow bh = blackmanharris(Ns) # synthesis window bh = bh / sum(bh) # normalize synthesis window wr = bh # window for residual sw[hNs-H:hNs+H] = sw[hNs-H:hNs+H] / bh[hNs-H:hNs+H] while pin<pend: #-----analysis----- x1 = x[pin-hM1:pin+hM2] # select frame mX, pX = DFT.dftAnal(x1, w, N) # compute dft ploc = UF.peakDetection(mX, t) # find peaks iploc, ipmag, ipphase = UF.peakInterp(mX, pX, ploc) # refine peak values iploc, ipmag, ipphase = UF.peakInterp(mX, pX, ploc) # refine peak values ipfreq = fs*iploc/float(N) # convert peak locations to Hertz ri = pin-hNs-1 # input sound pointer for residual analysis xw2 = x[ri:ri+Ns]*wr # window the input sound fftbuffer = np.zeros(Ns) # reset buffer fftbuffer[:hNs] = xw2[hNs:] # zero-phase window in fftbuffer fftbuffer[hNs:] = xw2[:hNs] X2 = fft(fftbuffer) # compute FFT for residual analysis #-----synthesis----- Ys = UF.genSpecSines(ipfreq, ipmag, ipphase, Ns, fs) # generate spec of sinusoidal component Xr = X2-Ys; # get the residual complex spectrum fftbuffer = np.zeros(Ns) fftbuffer = np.real(ifft(Ys)) # inverse FFT of sinusoidal spectrum ysw[:hNs-1] = fftbuffer[hNs+1:] # undo zero-phase window ysw[hNs-1:] = fftbuffer[:hNs+1] fftbuffer = np.zeros(Ns) fftbuffer = np.real(ifft(Xr)) # inverse FFT of residual spectrum xrw[:hNs-1] = fftbuffer[hNs+1:] # undo zero-phase window xrw[hNs-1:] = fftbuffer[:hNs+1] ys[ri:ri+Ns] += sw*ysw # overlap-add for sines xr[ri:ri+Ns] += sw*xrw # overlap-add for residual pin += H # advance sound pointer y = ys+xr # sum of sinusoidal and residual components return y, ys, xr
def calculate(self):
data = self.data * blackmanharris(self.data.size)
finfo = np.abs(rfft(data))
xvals = fftfreq(self.data.size, d=(1.0 / self.fs))
xvals = xvals[:xvals.size / 8]
if finfo.size != xvals.size:
finfo = finfo[:xvals.size]
xvals = xvals[:finfo.size]
return xvals, finfo
def multiply_blackmann_harris_window(inputs, axis=1):
n = inputs.shape[axis]
w = blackmanharris(n)
#w=w/np.mean(w)
# make w have same dimensionality as inputs,
# to ensure correct dimensions are multiplied
for i_axis in xrange(inputs.ndim):
if i_axis != axis:
w = np.expand_dims(w, i_axis)
return w * inputs
def getHz(self, soundData, rate):
usedata = unpack("%dh" % (len(soundData) / 2), soundData)
usedata = np.array(usedata, dtype="h")
window = usedata * blackmanharris(len(usedata))
fouriour = np.fft.rfft(window)
fouriour = np.delete(fouriour, len(fouriour) - 1)
i = np.argmax(abs(fouriour))
true_i = parabolic(np.log(abs(fouriour)), i)[0]
return rate * true_i / len(window)
def hpsModelSynth(hfreq, hmag, hphase, mYst, N, H, fs): # Synthesis of a sound using the harmonic plus stochastic model # hfreq: harmonic frequencies, hmag:harmonic amplitudes, mYst: stochastic envelope # Ns: synthesis FFT size, H: hop size, fs: sampling rate # y: output sound, yh: harmonic component, yst: stochastic component hN = N/2 # half of FFT size for synthesis L = hfreq[:,0].size # number of frames nH = hfreq[0,:].size # number of harmonics pout = 0 # initialize output sound pointer ysize = H*(L+4) # output sound size yhw = np.zeros(N) # initialize output sound frame ysw = np.zeros(N) # initialize output sound frame yh = np.zeros(ysize) # initialize output array yst = np.zeros(ysize) # initialize output array sw = np.zeros(N) ow = triang(2*H) # overlapping window sw[hN-H:hN+H] = ow bh = blackmanharris(N) # synthesis window bh = bh / sum(bh) # normalize synthesis window wr = bh # window for residual sw[hN-H:hN+H] = sw[hN-H:hN+H] / bh[hN-H:hN+H] # synthesis window for harmonic component sws = H*hanning(N)/2 # synthesis window for stochastic component lastyhfreq = hfreq[0,:] # initialize synthesis harmonic frequencies yhphase = 2*np.pi*np.random.rand(nH) # initialize synthesis harmonic phases for l in range(L): yhfreq = hfreq[l,:] # synthesis harmonics frequencies yhmag = hmag[l,:] # synthesis harmonic amplitudes mYrenv = mYst[l,:] # synthesis residual envelope if (hphase.size > 0): yhphase = hphase[l,:] else: yhphase += (np.pi*(lastyhfreq+yhfreq)/fs)*H # propagate phases lastyhfreq = yhfreq Yh = UF.genSpecSines(yhfreq, yhmag, yhphase, N, fs) # generate spec sines mYs = resample(mYrenv, hN) # interpolate to original size mYs = 10**(mYs/20) # dB to linear magnitude pYs = 2*np.pi*np.random.rand(hN) # generate phase random values Ys = np.zeros(N, dtype = complex) Ys[:hN] = mYs * np.exp(1j*pYs) # generate positive freq. Ys[hN+1:] = mYs[:0:-1] * np.exp(-1j*pYs[:0:-1]) # generate negative freq. fftbuffer = np.zeros(N) fftbuffer = np.real(ifft(Yh)) # inverse FFT of harm spectrum yhw[:hN-1] = fftbuffer[hN+1:] # undo zer-phase window yhw[hN-1:] = fftbuffer[:hN+1] fftbuffer = np.zeros(N) fftbuffer = np.real(ifft(Ys)) # inverse FFT of stochastic approximation spectrum ysw[:hN-1] = fftbuffer[hN+1:] # undo zero-phase window ysw[hN-1:] = fftbuffer[:hN+1] yh[pout:pout+N] += sw*yhw # overlap-add for sines yst[pout:pout+N] += sws*ysw # overlap-add for stoch pout += H # advance sound pointer y = yh+yst # sum harmonic and stochastic components return y, yh, yst
def freq_from_hps(signal, fs):
"""
Estimate frequency using harmonic product spectrum.
Note: Low frequency noise piles up and overwhelms the desired peaks.
From: https://gist.github.com/endolith/255291 and
https://github.com/endolith/waveform-analyzer
Parameters
----------
signal : list or array
time series data
fs : integer
sample rate
Returns
-------
frequency : float
frequency (Hz)
"""
import numpy as np
from scipy.signal import blackmanharris, decimate
from mhealthx.signals import parabolic
N = len(signal)
signal -= np.mean(signal) # Remove DC offset
# Compute Fourier transform of windowed signal:
windowed = signal * blackmanharris(len(signal))
# Get spectrum:
X = np.log(abs(np.fft.rfft(windowed)))
# Downsample sum logs of spectra instead of multiplying:
hps = np.copy(X)
for h in np.arange(2, 9): # TODO: choose a smarter upper limit
dec = decimate(X, h)
hps[:len(dec)] += dec
# Find the peak and interpolate to get a more accurate peak:
i_peak = np.argmax(hps[:len(dec)])
i_interp = parabolic(hps, i_peak)[0]
# Convert to equivalent frequency:
frequency = fs * i_interp / N # Hz
return frequency
def sineModelMultiRes(x, fs, wList, NList, t, BList): """ Analysis/synthesis of a sound using the sinusoidal model, without sine tracking x: input array sound, w: analysis window, N: size of complex spectrum, t: threshold in negative dB returns y: output array sound """ #-----synthesis params init----- Ns = 512 # FFT size for synthesis (even) H = Ns/4 # Hop size used for analysis and synthesis hNs = Ns/2 # half of synthesis FFT size yw = np.zeros(Ns) # initialize output sound frame y = np.zeros(x.size) # initialize output array sw = np.zeros(Ns) # initialize synthesis window ow = triang(2*H) # triangular window sw[hNs-H:hNs+H] = ow # add triangular window bh = blackmanharris(Ns) # blackmanharris window bh = bh / sum(bh) # normalized blackmanharris window sw[hNs-H:hNs+H] = sw[hNs-H:hNs+H] / bh[hNs-H:hNs+H] # normalized synthesis window for i in range(3): #-----analysis params init----- w = wList[i] N = NList[i] Bmin = BList[i][0] Bmax = BList[i][1] hM1 = int(math.floor((w.size+1)/2)) # half analysis window size by rounding hM2 = int(math.floor(w.size/2)) # half analysis window size by floor pin = max(hNs, hM1) # init sound pointer in middle of anal window pend = x.size - max(hNs, hM1) # last sample to start a frame fftbuffer = np.zeros(N) # initialize buffer for FFT w = w / sum(w) # normalize analysis window while pin<pend: # while input sound pointer is within sound #-----analysis----- x1 = x[pin-hM1:pin+hM2] # select frame mX, pX = DFT.dftAnal(x1, w, N) # compute dft ploc = UF.peakDetection(mX, t) # detect locations of peaks iploc, ipmag, ipphase = UF.peakInterp(mX, pX, ploc) # refine peak values by interpolation ipfreq = fs*iploc/float(N) # convert peak locations to Hertz ipmag = ipmag[np.logical_and(ipfreq>=Bmin, ipfreq<Bmax)] ipphase = ipphase[np.logical_and(ipfreq>=Bmin, ipfreq<Bmax)] ipfreq = ipfreq[np.logical_and(ipfreq>=Bmin, ipfreq<Bmax)] #-----synthesis----- Y = UF.genSpecSines(ipfreq, ipmag, ipphase, Ns, fs) # generate sines in the spectrum fftbuffer = np.real(ifft(Y)) # compute inverse FFT yw[:hNs-1] = fftbuffer[hNs+1:] # undo zero-phase window yw[hNs-1:] = fftbuffer[:hNs+1] y[pin-hNs:pin+hNs] += sw*yw # overlap-add and apply a synthesis window pin += H # advance sound pointer return y
def freq_from_fft(signal, fs):
"""Estimate frequency from peak of FFT
"""
# Compute Fourier transform of windowed signal
windowed = signal * blackmanharris(len(signal))
f = rfft(windowed)
# Find the peak and interpolate to get a more accurate peak
i = argmax(abs(f)) # Just use this for less-accurate, naive version
true_i = parabolic(log(abs(f)), i)[0]
# Convert to equivalent frequency
return fs * true_i / len(windowed)
def pitch_detect(sample):
if type(sample) is array.array:
pass
else:
sample = array.array('h',sample)
window = signal.blackmanharris(len(sample),False)
window = np.array(window)
window -=window.mean()
freq= abs(fp.rfft(window))
i = np.argmax(abs(freq)) # Just use this for less-accurate, naive version
true_i = parabolic(np.log(abs(freq)), i)[0]
# Convert to equivalent frequency
return RATE * true_i / len(window)
def freq_from_fft(sig, fs):
"""Estimate frequency from peak of FFT
"""
# Compute Fourier transform of windowed signal
N = next_fast_len(sig.size)
windowed = sig * signal.blackmanharris(len(sig))
f = np.fft.rfft(windowed, N)
# Find the peak and interpolate to get a more accurate peak
i = np.argmax(abs(f)) # Just use this for less-accurate, naive version
true_i = parabolic(np.log(abs(f)), i)[0]
# Convert to equivalent frequency
return fs * true_i / N
def sineModel(x, fs, w, N, t):
# Analysis/synthesis of a sound using the sinusoidal model
# x: input array sound, w: analysis window, N: size of complex spectrum,
# t: threshold in negative dB
# returns y: output array sound
hN = N/2 # size of positive spectrum
hM1 = int(math.floor((w.size+1)/2)) # half analysis window size by rounding
hM2 = int(math.floor(w.size/2)) # half analysis window size by floor
Ns = 512 # FFT size for synthesis (even)
H = Ns/4 # Hop size used for analysis and synthesis
hNs = Ns/2 # half of synthesis FFT size
pin = max(hNs, hM1) # initialize sound pointer in middle of analysis window
pend = x.size - max(hNs, hM1) # last sample to start a frame
fftbuffer = np.zeros(N) # initialize buffer for FFT
yw = np.zeros(Ns) # initialize output sound frame
y = np.zeros(x.size) # initialize output array
w = w / sum(w) # normalize analysis window
sw = np.zeros(Ns) # initialize synthesis window
ow = triang(2*H); # triangular window
sw[hNs-H:hNs+H] = ow # add triangular window
bh = blackmanharris(Ns) # blackmanharris window
bh = bh / sum(bh) # normalized blackmanharris window
sw[hNs-H:hNs+H] = sw[hNs-H:hNs+H] / bh[hNs-H:hNs+H] # normalized synthesis window
while pin<pend: # while input sound pointer is within sound
#-----analysis-----
xw = x[pin-hM1:pin+hM2] * w # window the input sound
fftbuffer = np.zeros(N) # reset buffer
fftbuffer[:hM1] = xw[hM2:] # zero-phase window in fftbuffer
fftbuffer[N-hM2:] = xw[:hM2]
X = fft(fftbuffer) # compute FFT
mX = 20 * np.log10( abs(X[:hN]) ) # magnitude spectrum of positive frequencies
ploc = PP.peakDetection(mX, hN, t) # detect locations of peaks
pmag = mX[ploc] # get the magnitude of the peaks
pX = np.unwrap( np.angle(X[:hN]) ) # unwrapped phase spect. of positive freq.
iploc, ipmag, ipphase = PP.peakInterp(mX, pX, ploc) # refine peak values by interpolation
#-----synthesis-----
plocs = iploc*Ns/N; # adapt peak locations to size of synthesis FFT
Y = GS.genSpecSines(plocs, ipmag, ipphase, Ns) # generate sines in the spectrum
fftbuffer = np.real( ifft(Y) ) # compute inverse FFT
yw[:hNs-1] = fftbuffer[hNs+1:] # undo zero-phase window
yw[hNs-1:] = fftbuffer[:hNs+1]
y[pin-hNs:pin+hNs] += sw*yw # overlap-add and apply a synthesis window
pin += H # advance sound pointer
return y
Ns = 256
hNs = Ns // 2
yw = np.zeros(Ns)
fs = 44100
freqs = np.array([1000.0, 4000.0, 8000.0])
amps = np.array([.6, .4, .6])
phases = ([0.5, 1.2, 2.3])
yploc = Ns * freqs / fs
ypmag = 20 * np.log10(amps / 2.0)
ypphase = phases
Y = UF.genSpecSines(freqs, ypmag, ypphase, Ns, fs)
mY = 20 * np.log10(abs(Y[:hNs]))
pY = np.unwrap(np.angle(Y[:hNs]))
y = fftshift(ifft(Y)) * sum(blackmanharris(Ns))
plt.figure(1, figsize=(9, 5))
plt.subplot(3, 1, 1)
plt.plot(fs * np.arange(Ns / 2) / Ns, mY, 'r', lw=1.5)
plt.axis([0, fs / 2.0, -100, 0])
plt.title("mY, freqs (Hz) = 1000, 4000, 8000; amps = .6, .4, .6")
plt.subplot(3, 1, 2)
pY[pY == 0] = np.nan
plt.plot(fs * np.arange(Ns / 2) / Ns, pY, 'c', lw=1.5)
plt.axis([0, fs / 2.0, -.01, 3.0])
plt.title("pY, phases (radians) = .5, 1.2, 2.3")
plt.subplot(3, 1, 3)
plt.plot(np.arange(-hNs, hNs), y, 'b', lw=1.5)
'../../software/models/'))
import utilFunctions as UF
from scipy.signal import blackmanharris, triang
from scipy.fftpack import ifft
fs = 44100
Ns = 512
hNs = Ns / 2
H = Ns / 4
ipfreq = np.array([4000.0])
ipmag = np.array([0.0])
ipphase = np.array([0.0])
Y = UF.genSpecSines_p(ipfreq, ipmag, ipphase, Ns, fs)
y = np.real(ifft(Y))
# undo the blackman harris window and apply a triangle function
sw = np.zeros(Ns)
ow = triang(Ns / 2)
sw[int(hNs - H):int(hNs + H)] = ow
bh = blackmanharris(Ns)
bh = bh / sum(bh)
# sw is the synthesis window
sw[int(hNs -
H):int(hNs +
H)] = sw[int(hNs - H):int(hNs + H)] / bh[int(hNs - H):int(hNs +
H)]
yw = np.zeros(Ns)
yw[:int(hNs - 1)] = y[int(hNs + 1):]
yw[int(hNs - 1):] = y[:int(hNs + 1)]
yw *= sw
def hprModel(x, fs, w, N, t, nH, minf0, maxf0, f0et):
"""
Analysis/synthesis of a sound using the harmonic plus residual model
x: input sound, fs: sampling rate, w: analysis window,
N: FFT size (minimum 512), t: threshold in negative dB,
nH: maximum number of harmonics, minf0: minimum f0 frequency in Hz,
maxf0: maximim f0 frequency in Hz,
f0et: error threshold in the f0 detection (ex: 5),
maxhd: max. relative deviation in harmonic detection (ex: .2)
returns y: output sound, yh: harmonic component, xr: residual component
"""
hN = N // 2 # size of positive spectrum
hM1 = int(math.floor(
(w.size + 1) / 2)) # half analysis window size by rounding
hM2 = int(math.floor(w.size / 2)) # half analysis window size by floor
Ns = 512 # FFT size for synthesis (even)
H = Ns // 4 # Hop size used for analysis and synthesis
hNs = Ns // 2
pin = max(hNs,
hM1) # initialize sound pointer in middle of analysis window
pend = x.size - max(hNs, hM1) # last sample to start a frame
fftbuffer = np.zeros(N) # initialize buffer for FFT
yhw = np.zeros(Ns) # initialize output sound frame
xrw = np.zeros(Ns) # initialize output sound frame
yh = np.zeros(x.size) # initialize output array
xr = np.zeros(x.size) # initialize output array
w = w / sum(w) # normalize analysis window
sw = np.zeros(Ns)
ow = triang(2 * H) # overlapping window
sw[hNs - H:hNs + H] = ow
bh = blackmanharris(Ns) # synthesis window
bh = bh / sum(bh) # normalize synthesis window
wr = bh # window for residual
sw[hNs - H:hNs + H] = sw[hNs - H:hNs + H] / bh[hNs - H:hNs + H]
hfreqp = []
f0t = 0
f0stable = 0
while pin < pend:
#-----analysis-----
x1 = x[pin - hM1:pin + hM2] # select frame
mX, pX = DFT.dftAnal(x1, w, N) # compute dft
ploc = UF.peakDetection(mX, t) # find peaks
iploc, ipmag, ipphase = UF.peakInterp(mX, pX,
ploc) # refine peak values
ipfreq = fs * iploc / N # convert locations to Hz
f0t = UF.f0Twm(ipfreq, ipmag, f0et, minf0, maxf0, f0stable) # find f0
if ((f0stable==0)&(f0t>0)) \
or ((f0stable>0)&(np.abs(f0stable-f0t)<f0stable/5.0)):
f0stable = f0t # consider a stable f0 if it is close to the previous one
else:
f0stable = 0
hfreq, hmag, hphase = HM.harmonicDetection(ipfreq, ipmag, ipphase, f0t,
nH, hfreqp,
fs) # find harmonics
hfreqp = hfreq
ri = pin - hNs - 1 # input sound pointer for residual analysis
xw2 = x[ri:ri + Ns] * wr # window the input sound
fftbuffer = np.zeros(Ns) # reset buffer
fftbuffer[:hNs] = xw2[hNs:] # zero-phase window in fftbuffer
fftbuffer[hNs:] = xw2[:hNs]
X2 = fft(
fftbuffer) # compute FFT of input signal for residual analysis
#-----synthesis-----
Yh = UF.genSpecSines(hfreq, hmag, hphase, Ns, fs) # generate sines
Xr = X2 - Yh # get the residual complex spectrum
fftbuffer = np.zeros(Ns)
fftbuffer = np.real(ifft(Yh)) # inverse FFT of harmonic spectrum
yhw[:hNs - 1] = fftbuffer[hNs + 1:] # undo zero-phase window
yhw[hNs - 1:] = fftbuffer[:hNs + 1]
fftbuffer = np.zeros(Ns)
fftbuffer = np.real(ifft(Xr)) # inverse FFT of residual spectrum
xrw[:hNs - 1] = fftbuffer[hNs + 1:] # undo zero-phase window
xrw[hNs - 1:] = fftbuffer[:hNs + 1]
yh[ri:ri + Ns] += sw * yhw # overlap-add for sines
xr[ri:ri + Ns] += sw * xrw # overlap-add for residual
pin += H # advance sound pointer
y = yh + xr # sum of harmonic and residual components
return y, yh, xr
def sineModelMultiRes(x, fs, windows, fftSizes, t, bands):
"""
Analysis/synthesis of a sound using a multi-resolution sinusoidal model, without sine tracking
x: input array sound,
s: sampling frequency,
w: analysis windows,
fftSizes: sizes of complex spectrum,
t: threshold in negative dB,
bands: bands of the sounds for multi-resolution analysis
returns y: output array sound
"""
# Resynthesis values
Ns = 512 # FFT size for synthesis (even)
H = Ns // 4 # Hop size used for analysis and synthesis
hNs = Ns // 2 # half of synthesis FFT size
yw = np.zeros(Ns) # initialize output sound frame
x = np.array(x) # Convert input to numpy array
# Create output buffers for all the bands
y1 = np.zeros(x.size)
y2 = np.zeros(x.size)
y3 = np.zeros(x.size)
outputArrays = np.array([y1, y2, y3])
sw = np.zeros(Ns) # initialize synthesis window
ow = triang(2 * H) # triangular window
sw[hNs - H:hNs + H] = ow # add triangular window
bh = blackmanharris(Ns) # blackmanharris window
bh = bh / sum(bh) # normalized blackmanharris window
sw[hNs - H:hNs +
H] = sw[hNs - H:hNs + H] / bh[hNs - H:hNs +
H] # normalized synthesis window
# Compute analysis/synthesis 3 times with each window/fft/band
for i in range(0, 3):
#-----variable inits-----
# Get the current window bounds (rounding up/floor down)
hM1 = int(math.floor((windows[i].size + 1) / 2))
hM2 = int(math.floor(windows[i].size / 2))
# Get start/end pin for current window
pin = max(hNs, hM1)
pend = x.size - max(hNs, hM1)
# Normalize window
w = windows[i] / sum(windows[i])
# Get current FFT size and init FFT buffer
N = fftSizes[i]
fftbuffer = np.zeros(N)
# Pick up/down bin limits
binCutoffUpLimit = (np.ceil(bands[i] * N / fs)) - 1
if i == 0:
binCutoffDownLimit = 0
else:
binCutoffDownLimit = np.ceil(bands[i - 1] * N / fs)
while pin < pend:
#-----analysis-----
# Get the frame with current window size
x1 = x[pin - hM1:pin + hM2]
# Get the spectra for each frame sizes using windows with their respective FFT sizes
mX, pX = DFT.dftAnal(x1, w, N)
# Only get the part of the spectrum we're interested in for the current band
mXFilt = mX.copy()
mXFilt[binCutoffDownLimit:] = -120
mXFilt[:binCutoffUpLimit] = -120
# Get the peaks out of each spectrum
ploc = UF.peakDetection(mX, t)
# Refine peak values by interpolation
iploc, ipmag, ipphase = UF.peakInterp(mX, pX, ploc)
# Convert peak locations to Hertz
ipfreq = fs * iploc / float(N)
#-----synthesis-----
Y = UF.genSpecSines(ipfreq, ipmag, ipphase, Ns,
fs) # generate sines in the spectrum
fftbuffer = np.real(ifft(Y)) # compute inverse FFT
yw[:hNs - 1] = fftbuffer[hNs + 1:] # undo zero-phase window
yw[hNs - 1:] = fftbuffer[:hNs + 1]
# Place sample to respective output array
outputArrays[
i][pin - hNs:pin +
hNs] += sw * yw # overlap-add and apply a synthesis window
pin += H # advance sound pointer
# Sum the content of the three time-domain-bandlimited output arrays into final output array
out = outputArrays.sum(axis=0)
# Scale down the final output (optimally I would have windowed-out for the filtering process)
out *= 0.3
return out
import matplotlib.pyplot as plt
import numpy as np
from scipy.fftpack import fft
from scipy import signal
M = 64
N = 512
hN = N / 2
hM = M / 2
fftbuffer = np.zeros(N)
mX1 = np.zeros(N)
plt.figure(1, figsize=(7.5, 4))
fftbuffer[hN - hM:hN + hM] = signal.blackmanharris(M)
plt.subplot(2, 1, 1)
plt.plot(np.arange(-hN, hN), fftbuffer, 'b', lw=1.5)
plt.axis([-hN, hN, 0, 1.1])
X = fft(fftbuffer)
mX = 20 * np.log10(abs(X))
mX1[:hN] = mX[hN:]
mX1[N - hN:] = mX[:hN]
plt.subplot(2, 1, 2)
plt.plot(np.arange(-hN, hN), mX1 - max(mX), 'r', lw=1.5)
plt.axis([-hN, hN, -110, 0])
plt.tight_layout()
plt.savefig('blackman-harris.png')
plt.show()
A = lambda t: A_fun(t, F_m, F_0) F = lambda t: F_fun(t, F_m, F_0) reltol = 1e-8 abstol = 1e-10 theta1 = np.pi / 3 pool = mp.Pool() pool.map(ode_parallel, range(ky_n)) pool.close() dt = tspan[1] - tspan[0] jx_er = np.gradient(jx_er, dt) jy_er = np.gradient(jy_er, dt) # Applying window functions to the current window = signal.blackmanharris(jx_ra.shape[0]) jx_ra *= window jy_ra *= window jx_er *= window jy_er *= window # Material properties (in terms of of fundamental freq. x_mingab = 8 x_maxgab = 31 x_specrange = 51 # Axis of HHG-spectra L = tspan.shape[0] n = np.power(2, nextpow2(L)) t_step = tspan[1] - tspan[0] f = np.arange(int(n / 2) + 1) / t_step * np.pi / (int(n / 2) + 1) / omega
plt.subplot(3,2,1)
plt.plot(freqaxis, mX, 'r', lw=1.5)
plt.axis([0,fs/2,-110, 0])
plt.title ('mW1; Hamming')
plt.subplot(3,2,3)
plt.plot(freqaxis, pX, 'c', lw=1.5)
plt.axis([0,fs/2,min(pX),max(pX)])
plt.title ('pW1; Hamming')
plt.subplot(3,2,5)
plt.plot(np.arange(-hM,hM+1), y[0:M], 'b', lw=1.5)
plt.axis([-hM,hM+1,-1,1])
plt.title ('y1')
w = blackmanharris(255)
mX, pX = DFT.dftAnal(x, w, N)
y = DFT.dftSynth(mX,pX,M)*sum(w)
plt.subplot(3,2,2)
plt.plot(freqaxis, mX, 'r', lw=1.5)
plt.axis([0,fs/2,-110, 0])
plt.title ('mW2; Blackman Harris')
plt.subplot(3,2,4)
plt.plot(freqaxis, pX, 'c', lw=1.5)
plt.axis([0,fs/2,min(pX),max(pX)])
plt.title ('pW2; Blackman Harris')
plt.subplot(3,2,6)
plt.plot(np.arange(-hM,hM+1), y[0:M], 'b', lw=1.5)
def sineModelMultiRes_combined(x, fs, multi_w, multi_N, t, multi_B):
"""
Analysis/synthesis of a sound using the sinusoidal model, without sine tracking
x: input array sound, w: analysis window, N: size of complex spectrum, t: threshold in negative dB
returns y: output array sound
"""
# fallback for original code
w = multi_w[0]
N = multi_N[0]
bands = range(len(multi_B)) # to iterate over bands
#-orig-----------------------------
hM1 = int(math.floor(
(w.size + 1) / 2)) # half analysis window size by rounding
hM2 = int(math.floor(w.size / 2)) # half analysis window size by floor
#-multi----------------------------
multi_w_size = np.array([multi_w[i].size for i in bands])
multi_hM1 = np.floor((multi_w_size + 1) / 2.0).astype(
int) # half analysis window size by rounding
multi_hM2 = np.floor(multi_w_size / 2.0).astype(
int) # half analysis window size by floor
#----------------------------------
Ns = 512 # FFT size for synthesis (even)
H = Ns / 4 # Hop size used for analysis and synthesis
hNs = Ns / 2 # half of synthesis FFT size
#-orig-----------------------------
pin = max(hNs, hM1) # init sound pointer in middle of anal window
pend = x.size - max(hNs, hM1) # last sample to start a frame
#-multi----------------------------
multi_pin = np.maximum(
hNs, multi_hM1) # init sound pointer in middle of anal window
multi_pend = x.size - multi_pin # last sample to start a frame
#----------------------------------
#-orig-----------------------------
fftbuffer = np.zeros(N) # initialize buffer for FFT
#-multi----------------------------
fftbuffer_combined = np.zeros(N)
#multi_fftbuffer = [np.array(multi_N[i]) for i in bands]
#----------------------------------
yw = np.zeros(Ns) # initialize output sound frame
y = np.zeros(x.size) # initialize output array
#-multi----------------------------
yw_combined = np.zeros(Ns) # initialize output sound frame
y_combined = np.zeros(x.size) # initialize output array
#-orig-----------------------------
w = w / sum(w) # normalize analysis window
#-multi----------------------------
multi_w = [multi_w[i] / sum(multi_w[i])
for i in bands] # normalize analysis window
#----------------------------------
sw = np.zeros(Ns) # initialize synthesis window
ow = triang(2 * H) # triangular window
sw[hNs - H:hNs + H] = ow # add triangular window
bh = blackmanharris(Ns) # blackmanharris window
bh = bh / sum(bh) # normalized blackmanharris window
sw[hNs - H:hNs +
H] = sw[hNs - H:hNs + H] / bh[hNs - H:hNs +
H] # normalized synthesis window
while pin < pend and (multi_pin < multi_pend
).all(): # while input sound pointer is within sound
#-----analysis-----
#-orig-----------------------------
x1 = x[pin - hM1:pin + hM2] # select frame
#-multi----------------------------
multi_x1 = [
x[(multi_pin[i] - multi_hM1[i]):(multi_pin[i] + multi_hM2[i])]
for i in bands
] # select frame
#----------------------------------
#-orig-----------------------------
mX, pX = DFT.dftAnal(x1, w, N) # compute dft
#-multi----------------------------
multi_mX = []
multi_pX = []
for i in bands:
mXi, pXi = DFT.dftAnal(multi_x1[i], multi_w[i], multi_N[i])
multi_mX.append(mXi)
multi_pX.append(pXi)
#----------------------------------
# we could apply the filters for the bands here already ...
#-orig-----------------------------
ploc = UF.peakDetection(mX, t) # detect locations of peaks
#pmag = mX[ploc] # get the magnitude of the peaks
#-multi----------------------------
multi_ploc = []
#multi_pmag = []
for i in bands:
ploci = UF.peakDetection(multi_mX[i],
t) # detect locations of peaks
#pmagi = multi_mX[i][ploci] # get the magnitude of the peaks
multi_ploc.append(ploci)
#multi_pmag.append(pmagi)
#----------------------------------
#-orig-----------------------------
iploc, ipmag, ipphase = UF.peakInterp(
mX, pX, ploc) # refine peak values by interpolation
ipfreq = fs * iploc / float(N) # convert peak locations to Hertz
#-multi----------------------------
#multi_iploc = []
multi_ipmag = []
multi_ipphase = []
multi_ipfreq = []
for i in bands:
iploci, ipmagi, ipphasei = UF.peakInterp(
multi_mX[i], multi_pX[i],
multi_ploc[i]) # refine peak values by interpolation
ipfreqi = fs * iploci / float(
multi_N[i]) # convert peak locations to Hertz
#multi_iploc.append(iploci)
multi_ipmag.append(ipmagi)
multi_ipphase.append(ipphasei)
multi_ipfreq.append(ipfreqi)
#----------------------------------
# ... but we shall decide here!
"""
print "--------------------------------------"
print ipfreq
print ipmag
print ipphase
"""
"""
ipfreq_combined = []
ipmag_combined = []
ipphase_combined = []
for i in bands:
for p in range(len(multi_ipfreq[i])):
f = multi_ipfreq[i][p]
if (i == 0 or f >= multi_B[i-1]) and f < multi_B[i]:
ipfreq_combined.append(f)
ipmag_combined.append(multi_ipmag[i][p])
ipphase_combined.append(multi_ipphase[i][p])
#ipfreq = np.array(ipfreq_combined)
#ipmag = np.array(ipmag_combined)
#ipphase = np.array(ipphase_combined)
"""
# count first for array allocation
num_ip = 0
for i in bands:
for p in range(len(multi_ipfreq[i])):
f = multi_ipfreq[i][p]
if (i == 0 or f >= multi_B[i - 1]) and f < multi_B[i]:
num_ip += 1
ipfreq_combined = np.zeros(num_ip)
ipmag_combined = np.zeros(num_ip)
ipphase_combined = np.zeros(num_ip)
ip = 0
for i in bands:
for p in range(len(multi_ipfreq[i])):
f = multi_ipfreq[i][p]
if (i == 0 or f >= multi_B[i - 1]) and f < multi_B[i]:
ipfreq_combined[ip] = f
ipmag_combined[ip] = multi_ipmag[i][p]
ipphase_combined[ip] = multi_ipphase[i][p]
ip += 1
"""
print "--------------------------------------"
print ipfreq_combined
print ipmag_combined
print ipphase_combined
"""
#-----synthesis-----
Y = UF.genSpecSines(ipfreq, ipmag, ipphase, Ns,
fs) # generate sines in the spectrum
fftbuffer = np.real(ifft(Y)) # compute inverse FFT
yw[:hNs - 1] = fftbuffer[hNs + 1:] # undo zero-phase window
yw[hNs - 1:] = fftbuffer[:hNs + 1]
y[pin - hNs:pin +
hNs] += sw * yw # overlap-add and apply a synthesis window
#print y[pin-hNs:pin+hNs]
pin += H # advance sound pointer
Y_combined = UF.genSpecSines(ipfreq_combined, ipmag_combined,
ipphase_combined, Ns,
fs) # generate sines in the spectrum
fftbuffer_combined = np.real(ifft(Y_combined)) # compute inverse FFT
yw_combined[:hNs -
1] = fftbuffer_combined[hNs + 1:] # undo zero-phase window
yw_combined[hNs - 1:] = fftbuffer_combined[:hNs + 1]
y_combined[
pin - hNs:pin +
hNs] += sw * yw_combined # overlap-add and apply a synthesis window
#print y_combined[pin-hNs:pin+hNs]
multi_pin += H
"""
plt.figure(1)
plt.plot(abs(Y))
plt.figure(2)
plt.plot(abs(Y_combined))
plt.show()
"""
return y, y_combined
def sineModelMultiRes(x, fs, w, N, t,B): """ Analysis/synthesis of a sound using the sinusoidal model, without sine tracking x: input array sound, w: analysis window, N: size of complex spectrum, t: threshold in negative dB returns y: output array sound MODIFIED by RJL for Audio Signal Processing course on coursera to allow for multi resolutions w=[w1,w2,w3] are the windows for the three bands (with corresponding fft size N= [N1,N2,N3]). The bands are defined by the boundaries B= [Ba,Bb]. I.e Band 1 is 0<= f< Ba, band 2 is Ba <= f < Bb, and band 3 is Bb <= f < 22050. (The assignement instructions suggested as input three 'bands' but only two numbers are requred here.) """ # Note: For production code would need to make sure the arguments are lists of the correct size Here hM1s = [int(math.floor((aw.size+1)/2)) for aw in w] # half analysis window size by rounding hM2s = [int(math.floor(aw.size/2)) for aw in w] # half analysis window size by floor Ns = 512 # FFT size for synthesis (even) H = Ns//4 # Hop size used for analysis and synthesis hNs = Ns//2 # half of synthesis FFT size pin = max(hNs, max(hM1s)) # init sound pointer in middle of anal window pend = x.size - max(hNs, max(hM1s)) # last sample to start a frame fftbuffers = [np.zeros(n) for n in N] # initialize buffers for FFTs yw = np.zeros(Ns) # initialize output sound frame y = np.zeros(x.size) # initialize output array w = [aw / sum(aw) for aw in w] # normalize analysis windows sw = np.zeros(Ns) # initialize synthesis window ow = triang(2*H) # triangular window sw[hNs-H:hNs+H] = ow # add triangular window bh = blackmanharris(Ns) # blackmanharris window bh = bh / sum(bh) # normalized blackmanharris window sw[hNs-H:hNs+H] = sw[hNs-H:hNs+H] / bh[hNs-H:hNs+H] # normalized synthesis window B = [(0,B[0]),(B[0],B[1]),(B[1],22050)] # set up bands ipfreq = [0,0,0] ipphase =[0,0,0] ipmag =[0,0,0] while pin<pend: # while input sound pointer is within sound #-----analysis----- Basically unchanged but done three times, ecept i get rid of frequencies not in band for i in range(0,3): # here we mandate three bands! x1 = x[pin-hM1s[i]:pin+hM2s[i]] # select frame mX, pX = DFT.dftAnal(x1, w[i], N[i]) # compute dft ploc = UF.peakDetection(mX, t) # detect locations of peaks iploc, ipmagt, ipphaset = UF.peakInterp(mX, pX, ploc) # refine peak values by interpolation ipfreqt = fs*iploc/float(N[i]) # convert peak locations to Her indexes = [j for (j,f) in enumerate(ipfreqt) if f >= B[i][0] and f < B[i][1] ] # filter out of band peaks ipfreq[i] = ipfreqt[indexes] # There must be an easier way, but here are rebuild ipphase[i] = ipphaset[indexes] # with only the indexes where the freq is in range ipmag[i] = ipmagt[indexes] # Combine the peaks into single combined analysis. This is verbose but clear ipfreqC = np.concatenate((ipfreq[0],ipfreq[1],ipfreq[2])) ipphaseC = np.concatenate((ipphase[0] , ipphase[1] ,ipphase[2])) ipmagC = np.concatenate((ipmag[0],ipmag[1],ipmag[2])) #-----synthesis----- completely unchanged. # import pdb; pdb.set_trace() Y = UF.genSpecSines(ipfreqC, ipmagC, ipphaseC, Ns, fs) # generate sines in the spectrum fftbuffer = np.real(ifft(Y)) # compute inverse FFT yw[:hNs-1] = fftbuffer[hNs+1:] # undo zero-phase window yw[hNs-1:] = fftbuffer[:hNs+1] y[pin-hNs:pin+hNs] += sw*yw # overlap-add and apply a synthesis window pin += H # advance sound pointer return y
from scipy.io import wavfile
from scipy import signal
from sinemodel import *
# read the wav file
filename = "sound/Wave_5.wav"
[fs, x] = wavfile.read(filename)
# parameter
L = size(x)
dureefenetre = 23e-3 #duration of each window
#M=fs*dureefenetre
M = dureefenetre * fs #window size
if (M % 2 == 0): M += 1
H_ratio = 0.25 # Ratio (hop size)/(window size)
w = signal.blackmanharris(M) # window for tram
N = 1024 # fft size
Ns = 1024 # window size for synthesis
seuil = -50
#t = linspace(0,1,16000);
#x = sin(2*pi*1000*t);
y = sinemodel(x, w, N, Ns, H_ratio, seuil)
#==============================================================================
# Analysis/synthesis of a sound using the sinusoidal model
# x: input sound, w: analysis window (odd size), N: FFT size,
# seuil: threshold in negative dB, y: output sound
# Ns: FFT size for synthesis (even)
# H_Ratio: (hop size)/(window size)
#==============================================================================
wavfile.write('test.wav', fs, y)
else:
data = cic_out
rate = Fs / cic_rate
data_len = len(data)
t = np.arange(data_len) / rate
# plot of time
fig = plt.figure(1)
plt.plot(t, np.real(data))
plt.grid()
plt.xlabel("Time")
plt.ylabel("data")
plt.title("sinusoid - time")
# plot of frequency
fig = plt.figure(2)
f = rate * fftshift(fftfreq(data_len)) / 1e6
win = signal.blackmanharris(data_len)
data_bhwin = data * win
bh_gain = sum(win) / data_len
data_dB = 20 * np.log10(
np.abs(fftshift(fft(data_bhwin))) / (data_len * (data_scl / 2) * bh_gain))
plt.plot(f, data_dB)
plt.grid()
plt.xlabel("Frequency (MHz)")
plt.ylabel("dB")
plt.title("sinusoid - freq")
plt.xlim((0, (rate / 1e6) / 2))
plt.show()
def freq_from_fft(sig, fs):
windowed = sig * blackmanharris(len(sig))
f = rfft(windowed)
i = argmax(abs(f)) # Just use this for less-accurate, naive version
true_i = parabolic(abs(f), i)[0]
return fs * true_i / len(windowed)
x = np.concatenate((x, np.zeros(pad)))
"""
# Display waveform
plt.figure(figsize=(20,5))
plt.plot(x)
plt.axis([0, x.size, -1.1, 1.1])
plt.title("Original signal")
plt.ylabel("Amplitude[V]")
plt.xlabel("Time[s]")
plt.grid()
plt.show()
"""
# Compute STFT
print "Computing STFT... "
w = signal.blackmanharris(N)
# without zero padding
M = w.size # size of analysis window
hM1 = int(math.floor((M + 1) / 2)) # half analysis window size by rounding
hM2 = int(math.floor(M / 2)) # half analysis window size by floor
x = np.append(np.zeros(hM2),
x) # add zeros at beginning to center first window at sample 0
x = np.append(x, np.zeros(hM1)) # add zeros at the end to analyze last sample
pin = hM1 # initialize sound pointer in middle of analysis window
pend = x.size - hM1 # last sample to start a frame
w = w / sum(w) # normalize analysis window
yp = np.zeros(x.size) # initialize output array
yh = np.zeros(x.size) # initialize output array
nframes = (x.size - M) / overlap + 1
S = np.zeros(shape=(nframes,
hM2 + 1)) # initialize magnitude of spectrogram array
def hpsModel(x, fs, w, N, t, nH, minf0, maxf0, f0et, stocf):
"""
Analysis/synthesis of a sound using the harmonic plus stochastic model, one frame at a time, no harmonic tracking
x: input sound; fs: sampling rate, w: analysis window; N: FFT size (minimum 512), t: threshold in negative dB,
nH: maximum number of harmonics, minf0: minimum f0 frequency in Hz; maxf0: maximim f0 frequency in Hz,
f0et: error threshold in the f0 detection (ex: 5); stocf: decimation factor of mag spectrum for stochastic analysis
returns y: output sound, yh: harmonic component, yst: stochastic component
"""
hN = N // 2 # size of positive spectrum
hM1 = int(math.floor(
(w.size + 1) / 2)) # half analysis window size by rounding
hM2 = int(math.floor(w.size / 2)) # half analysis window size by floor
Ns = 512 # FFT size for synthesis (even)
H = Ns // 4 # Hop size used for analysis and synthesis
hNs = Ns // 2
pin = max(hNs,
hM1) # initialize sound pointer in middle of analysis window
pend = x.size - max(hNs, hM1) # last sample to start a frame
fftbuffer = np.zeros(N) # initialize buffer for FFT
yhw = np.zeros(Ns) # initialize output sound frame
ystw = np.zeros(Ns) # initialize output sound frame
yh = np.zeros(x.size) # initialize output array
yst = np.zeros(x.size) # initialize output array
w = w / sum(w) # normalize analysis window
sw = np.zeros(Ns)
ow = triang(2 * H) # overlapping window
sw[hNs - H:hNs + H] = ow
bh = blackmanharris(Ns) # synthesis window
bh = bh / sum(bh) # normalize synthesis window
wr = bh # window for residual
sw[hNs - H:hNs +
H] = sw[hNs - H:hNs +
H] / bh[hNs - H:hNs +
H] # synthesis window for harmonic component
sws = H * hanning(Ns) / 2 # synthesis window for stochastic
hfreqp = []
f0t = 0
f0stable = 0
while pin < pend:
#-----analysis-----
x1 = x[pin - hM1:pin + hM2] # select frame
mX, pX = DFT.dftAnal(x1, w, N) # compute dft
ploc = UF.peakDetection(mX, t) # find peaks
iploc, ipmag, ipphase = UF.peakInterp(mX, pX,
ploc) # refine peak values
ipfreq = fs * iploc / N # convert peak locations to Hz
f0t = UF.f0Twm(ipfreq, ipmag, f0et, minf0, maxf0, f0stable) # find f0
if ((f0stable==0)&(f0t>0)) \
or ((f0stable>0)&(np.abs(f0stable-f0t)<f0stable/5.0)):
f0stable = f0t # consider a stable f0 if it is close to the previous one
else:
f0stable = 0
hfreq, hmag, hphase = HM.harmonicDetection(ipfreq, ipmag, ipphase, f0t,
nH, hfreqp,
fs) # find harmonics
hfreqp = hfreq
ri = pin - hNs - 1 # input sound pointer for residual analysis
xw2 = x[ri:ri + Ns] * wr # window the input sound
fftbuffer = np.zeros(Ns) # reset buffer
fftbuffer[:hNs] = xw2[hNs:] # zero-phase window in fftbuffer
fftbuffer[hNs:] = xw2[:hNs]
X2 = fft(fftbuffer) # compute FFT for residual analysis
#-----synthesis-----
Yh = UF.genSpecSines(hfreq, hmag, hphase, Ns,
fs) # generate spec sines of harmonic component
Xr = X2 - Yh # get the residual complex spectrum
mXr = 20 * np.log10(abs(Xr[:hNs])) # magnitude spectrum of residual
mXrenv = resample(
np.maximum(-200, mXr),
mXr.size * stocf) # decimate the magnitude spectrum and avoid -Inf
stocEnv = resample(mXrenv, hNs) # interpolate to original size
pYst = 2 * np.pi * np.random.rand(hNs) # generate phase random values
Yst = np.zeros(Ns, dtype=complex)
Yst[:hNs] = 10**(stocEnv / 20) * np.exp(
1j * pYst) # generate positive freq.
Yst[hNs + 1:] = 10**(stocEnv[:0:-1] / 20) * np.exp(
-1j * pYst[:0:-1]) # generate negative freq.
fftbuffer = np.zeros(Ns)
fftbuffer = np.real(ifft(Yh)) # inverse FFT of harmonic spectrum
yhw[:hNs - 1] = fftbuffer[hNs + 1:] # undo zero-phase window
yhw[hNs - 1:] = fftbuffer[:hNs + 1]
fftbuffer = np.zeros(Ns)
fftbuffer = np.real(ifft(Yst)) # inverse FFT of stochastic spectrum
ystw[:hNs - 1] = fftbuffer[hNs + 1:] # undo zero-phase window
ystw[hNs - 1:] = fftbuffer[:hNs + 1]
yh[ri:ri + Ns] += sw * yhw # overlap-add for sines
yst[ri:ri + Ns] += sws * ystw # overlap-add for stochastic
pin += H # advance sound pointer
y = yh + yst # sum of harmonic and stochastic components
return y, yh, yst
def sineModelMultiRes(x, fs, multi_w, multi_N, t, multi_B):
"""
Analysis/synthesis of a sound using the sinusoidal model, without sine tracking
x: input array sound, w: analysis window, N: size of complex spectrum, t: threshold in negative dB
returns y: output array sound
"""
bands = range(len(multi_B)) # to iterate over bands
N = max(multi_N)
multi_w_size = np.array([multi_w[i].size for i in bands])
multi_hM1 = np.floor((multi_w_size + 1) / 2.0).astype(
int) # half analysis window size by rounding
multi_hM2 = np.floor(multi_w_size / 2.0).astype(
int) # half analysis window size by floor
Ns = 512 # FFT size for synthesis (even)
H = Ns / 4 # Hop size used for analysis and synthesis
hNs = Ns / 2 # half of synthesis FFT size
multi_pin = np.maximum(
hNs, multi_hM1) # init sound pointer in middle of anal window
multi_pend = x.size - multi_pin # last sample to start a frame
fftbuffer_combined = np.zeros(N)
yw_combined = np.zeros(Ns) # initialize output sound frame
y_combined = np.zeros(x.size) # initialize output array
multi_w = [multi_w[i] / sum(multi_w[i])
for i in bands] # normalize analysis window
sw = np.zeros(Ns) # initialize synthesis window
ow = triang(2 * H) # triangular window
sw[hNs - H:hNs + H] = ow # add triangular window
bh = blackmanharris(Ns) # blackmanharris window
bh = bh / sum(bh) # normalized blackmanharris window
sw[hNs - H:hNs +
H] = sw[hNs - H:hNs + H] / bh[hNs - H:hNs +
H] # normalized synthesis window
while (multi_pin <
multi_pend).all(): # while input sound pointer is within sound
#-----analysis-----
multi_x1 = [
x[(multi_pin[i] - multi_hM1[i]):(multi_pin[i] + multi_hM2[i])]
for i in bands
] # select frame
multi_mX = []
multi_pX = []
for i in bands:
mXi, pXi = DFT.dftAnal(multi_x1[i], multi_w[i], multi_N[i])
multi_mX.append(mXi)
multi_pX.append(pXi)
multi_ploc = []
for i in bands:
ploci = UF.peakDetection(multi_mX[i],
t) # detect locations of peaks
multi_ploc.append(ploci)
multi_ipmag = []
multi_ipphase = []
multi_ipfreq = []
for i in bands:
iploci, ipmagi, ipphasei = UF.peakInterp(
multi_mX[i], multi_pX[i],
multi_ploc[i]) # refine peak values by interpolation
ipfreqi = fs * iploci / float(
multi_N[i]) # convert peak locations to Hertz
multi_ipmag.append(ipmagi)
multi_ipphase.append(ipphasei)
multi_ipfreq.append(ipfreqi)
# count first for array allocation
num_ip = 0
for i in bands:
for p in range(len(multi_ipfreq[i])):
f = multi_ipfreq[i][p]
if (i == 0 or f >= multi_B[i - 1]) and f < multi_B[i]:
num_ip += 1
ipfreq_combined = np.zeros(num_ip)
ipmag_combined = np.zeros(num_ip)
ipphase_combined = np.zeros(num_ip)
ip = 0
for i in bands:
for p in range(len(multi_ipfreq[i])):
f = multi_ipfreq[i][p]
if (i == 0 or f >= multi_B[i - 1]) and f < multi_B[i]:
ipfreq_combined[ip] = f
ipmag_combined[ip] = multi_ipmag[i][p]
ipphase_combined[ip] = multi_ipphase[i][p]
ip += 1
#-----synthesis-----
Y_combined = UF.genSpecSines(ipfreq_combined, ipmag_combined,
ipphase_combined, Ns,
fs) # generate sines in the spectrum
fftbuffer_combined = np.real(ifft(Y_combined)) # compute inverse FFT
yw_combined[:hNs -
1] = fftbuffer_combined[hNs + 1:] # undo zero-phase window
yw_combined[hNs - 1:] = fftbuffer_combined[:hNs + 1]
y_combined[
multi_pin[0] - hNs:multi_pin[0] +
hNs] += sw * yw_combined # overlap-add and apply a synthesis window
multi_pin += H
return y_combined
def genCQTkernel(fmax, bins, fs, **kwargs):
'''
%Calculating the CQT Kernel for one octave. All atoms are center-stacked.
%Atoms are placed so that the stacks of lower octaves are centered at the
%same positions in time, however, their amount is reduced by factor two for
%each octave down.
%
%INPUT:
% fmax ... highest frequency of interest
% bins ... number of bins per octave
% fs ... sampling frequency
%
%optional input parameters (parameter name/value pairs):
%
% 'q' ... Q scaling factor. Default: 1.
% 'atomHopFactor' ... relative hop size corresponding to the shortest
% temporal atom. Default: 0.25.
% 'thresh' ... values smaller than 'tresh' in the spectral kernel are rounded to
% zero. Default: 0.0005.
% 'win' ... defines which window will be used for the CQT. Valid
% values are: 'blackman','hann' and 'blackmanharris'. To
% use the square root of each window use the prefix 'sqrt_'
% (i.e. 'sqrt_blackman'). Default: 'sqrt_blackmanharris'
% 'perfRast' ... if set to 1 the kernel is designed in order to
% enable perfect rasterization using the function
% cqtPerfectRast() (Default: perRast=0). See documentation of
% 'cqtPerfectRast' for further information.
%
%OUTPUT:
% cqtKernel ... Dict that contains the spectral kernel 'fKernel'
% additional design parameters used in cqt(), cqtPerfectRast() and icqt().
%
%He Wang, 2020/12/01 [email protected]
'''
# input parameters
q = kwargs.get('q', 1)
atomHopFactor = kwargs.get('atomHopFactor', 0.25)
thresh = kwargs.get('thresh', 0.0005)
winFlag = kwargs.get('win', 'sqrt_blackmanharris')
perfRast = kwargs.get('perfRast', 0)
# define
fmin = (fmax/2)*2**(1/bins)
Q = 1/(2**(1/bins)-1)
Q = Q*q
Nk_max = Q * fs / fmin
Nk_max = round_half_up(Nk_max) # length of the largest atom [samples]
# Compute FFT size, FFT hop, atom hop, ...
Nk_min = round_half_up( Q * fs / (fmin*2**((bins-1)/bins)) ) # length of the shortest atom [samples]
atomHOP = round_half_up(Nk_min * atomHopFactor) # atom hop size
first_center = np.ceil(Nk_max/2) # first possible center position within the frame
first_center = atomHOP * np.ceil(first_center/atomHOP) # lock the first center to an integer multiple of the atom hop size
FFTLen = 2**nextpow2(first_center+np.ceil(Nk_max/2)) # use smallest possible FFT size (increase sparsity)
if perfRast:
winNr = int(np.floor((FFTLen-np.ceil(Nk_max/2)-first_center)/atomHOP)) # number of temporal atoms per FFT Frame
if winNr == 0 :
FFTLen = FFTLen * 2
winNr = int(np.floor((FFTLen-np.ceil(Nk_max/2)-first_center)/atomHOP))
else:
winNr = int(np.floor((FFTLen-np.ceil(Nk_max/2)-first_center)/atomHOP))+1 # number of temporal atoms per FFT Frame
last_center = first_center + (winNr-1)*atomHOP
fftHOP = (last_center + atomHOP) - first_center # hop size of FFT frames
fftOLP = (FFTLen-fftHOP/FFTLen)*100 # overlap of FFT frames in percent ***AK:needed?
# init variables
tempKernel= np.zeros((1, FFTLen), dtype=complex)
sparKernel= np.zeros((1, FFTLen), dtype=complex)#[]
# Compute kernel
atomInd = 0
for k in range(bins):
Nk = int(round_half_up( Q * fs / (fmin*2**(k/bins)) )) # N[k] = (fs/fk)*Q. Rounding will be omitted in future versions
if winFlag == 'sqrt_blackmanharris':
winFct = np.sqrt(blackmanharris(Nk))
elif winFlag == 'blackmanharris':
winFct = blackmanharris(Nk)
elif winFlag == 'sqrt_hann':
winFct = np.sqrt(hann(Nk, 'periodic'))
elif winFlag == 'hann':
winFct = hann(Nk, 'periodic')
elif winFag == 'sqrt_blackman':
winFct = np.sqrt(blackman(Nk, False))
elif winFag == 'blackman':
winFct = blackman(Nk, False)
else:
winFct = np.sqrt(blackmanharris(Nk))
if k==1:
warnings.warn('QT:INPUT','Non-existing window function. Default window is used!', UserWarning)
fk = fmin*2**(k/bins)
tempKernelBin = (winFct/Nk) * np.exp(2*np.pi*1j*fk*np.arange(Nk)/fs)
atomOffset = first_center - np.ceil(Nk/2)
for i in range(winNr):
shift = int(atomOffset + (i * atomHOP))
tempKernel[:, shift: Nk+shift] = tempKernelBin
atomInd += 1
specKernel= np.fft.fft(tempKernel)
specKernel[abs(specKernel)<=thresh] = 0
sparKernel = np.append(sparKernel, specKernel, axis=0)
tempKernel = np.zeros((1, FFTLen), dtype=complex) # reset window
sparKernel = (sparKernel.T/FFTLen)[:,1:]
# Normalize the magnitudes of the atoms
wx1=np.argmax(np.abs(sparKernel)[:,0])
wx2=np.argmax(np.abs(sparKernel)[:,-1])
wK=sparKernel[wx1: wx2+1,:]
wK = np.diag(np.dot(wK, wK.conj().T))
wK = wK[int(round_half_up(1/q)): -int(round_half_up(1/q))-2]
weight = 1./np.mean(np.abs(wK))
weight = weight * (fftHOP/FFTLen)
weight = np.sqrt(weight) # sqrt because the same weight is applied in icqt again
sparKernel = weight*sparKernel
return {'fKernel': sparKernel, 'fftLEN':FFTLen,'fftHOP':fftHOP,'fftOverlap':fftOLP,'perfRast':perfRast,
'bins':bins,'firstcenter':first_center,'atomHOP':atomHOP,'atomNr':winNr,'Nk_max':Nk_max,'Q':Q,'fmin':fmin }
def get_data(self):
"""Get spectrogram data from the tuner. Will return width number of
values which are the intensities of each frequency bucket (i.e. FFT of
radio samples).
"""
# Get width number of raw samples so the number of frequency bins is
# the same as the display width. Add two because there will be mean/DC
# values in the results which are ignored. Increase by 1/self.zoom_fac if needed
if self.zoom_fac < (self.sdr.sample_rate/1000000):
zoom = int(self.width*((self.sdr.sample_rate/1000000)/self.zoom_fac))
else:
zoom = self.width
self.zoom_fac = self.get_sample_rate()
# Read the full array in case we want to write it to a file
rawsamples = self.sdr.read_samples(freqshow.SDR_SAMPLE_SIZE)
# Write the data if requested
if self.record_iq == True:
# do something
if zoom < freqshow.SDR_SAMPLE_SIZE:
freqbins = rawsamples[0:zoom+2]
else:
zoom = self.width
self.zoom_fac = self.get_sample_rate()
freqbins = rawsamples[0:zoom+2]
# Apply a window function to the sample to remove power in sample sidebands before the fft.
if self.filter == 'kaiser':
window = signal.kaiser(freqshow.SDR_SAMPLE_SIZE, self.kaiser_beta, False,)[0:zoom+2] # for every bin there is a window the same exact size as the read samples.
elif self.filter == 'boxcar':
window = signal.boxcar(freqshow.SDR_SAMPLE_SIZE, False,)[0:zoom+2]
elif self.filter == 'hann':
window = signal.hann(freqshow.SDR_SAMPLE_SIZE, False,)[0:zoom+2]
elif self.filter == 'hamming':
window = signal.hamming(freqshow.SDR_SAMPLE_SIZE, False,)[0:zoom+2]
elif self.filter == 'blackman':
window = signal.blackman(freqshow.SDR_SAMPLE_SIZE, False,)[0:zoom+2]
elif self.filter == 'blackmanharris':
window = signal.blackmanharris(freqshow.SDR_SAMPLE_SIZE, False,)[0:zoom+2]
elif self.filter == 'bartlett':
window = signal.bartlett(freqshow.SDR_SAMPLE_SIZE, False,)[0:zoom+2]
elif self.filter == 'barthann':
window = signal.barthann(freqshow.SDR_SAMPLE_SIZE, False,)[0:zoom+2]
elif self.filter == 'nuttall':
window = signal.nuttall(freqshow.SDR_SAMPLE_SIZE, False,)[0:zoom+2]
else:
window = 1
samples = freqbins * window
# Run an FFT and take the absolute value to get frequency magnitudes.
freqs = np.absolute(fft(samples))
# Ignore the mean/DC values at the ends.
freqs = freqs[1:-1]
# Reverse the order of the freqs array if swaping I and Q
if self.swap_iq == True:
freqs = freqs[::-1]
# Shift FFT result positions to put center frequency in center.
freqs = np.fft.fftshift(freqs)
# Truncate the freqs array to the width of the screen if neccesary.
if freqs.size > self.width:
freq_step = self.get_freq_step() # Get the frequency step in Hz between pixels.
shiftsweep = int(self.get_lo_offset()*1000000/freq_step) # LO offset in pixels.
extra_samples = int((freqs.size - self.width)/2) # The excess samples either side of the display width in pixels.
if extra_samples > abs(shiftsweep): # check if there is room to shift the array by the LO offset.
if self.get_swap_iq() == True:
lextra = extra_samples + shiftsweep
elif self.get_swap_iq() == False:
lextra = extra_samples - shiftsweep
else:
lextra = extra_samples
rextra = freqs.size - (lextra + self.width)
freqs = freqs[lextra:-rextra]
# Convert to decibels.
freqs = 20.0*np.log10(freqs)
# Get signal strength of the center frequency.
# for i in range ( 1, 11):
# self.sig_strength = (self.get_sig_strength() + freqs[((zoom+2)/2)+i-5])
# self.sig_strength = self.get_sig_strength()/10
# Update model's min and max intensities when auto scaling each value.
if self.min_auto_scale:
min_intensity = np.min(freqs)
self.min_intensity = min_intensity if self.min_intensity is None \
else min(min_intensity, self.min_intensity)
if self.max_auto_scale:
max_intensity = np.max(freqs)
self.max_intensity = max_intensity if self.max_intensity is None \
else max(max_intensity, self.max_intensity)
# Update intensity range (length between min and max intensity).
self.range = self.max_intensity - self.min_intensity
# Return frequency intensities.
return freqs
def blackman_harris_taper(frequency_range):
window = signal.blackmanharris(len(frequency_range))
return window
def sineModelMultiRes(x, fs, w_seq, N_seq, t, B_seq):
"""
Analysis/synthesis of a sound using the sinusoidal model, without sine tracking
using multi-resolution approach.
x: input array sound, fs: sample rate
w: sequence of three analysis windows
N: sequence of three sizes of complex spectrum
t: threshold in negative dB
B: sequence of three frequency bands, represented as (min Hz, max Hz) tuples
returns y: output array sound
"""
assert len(w_seq) == len(
N_seq), "w_seq and N_seq must be sequences of the same size"
assert len(w_seq) == len(
B_seq), "w_seq and B_seq must be sequences of the same size"
k = len(w_seq)
# Each analysis frame should be the same length as the largest window
# but each hop should be the same length as the smallest window
min_window_size = min([item.size for item in w_seq])
max_window_size = max([item.size for item in w_seq])
logger.debug("min_window_size {}".format(min_window_size))
logger.debug("max_window_size {}".format(max_window_size))
hM1 = int(math.floor(min_window_size + 1) /
2) # half analysis window size by rounding
hM2 = int(math.floor(min_window_size /
2)) # half analysis window size by floor
hM1_max = int(math.floor(max_window_size + 1) / 2)
hM2_max = int(math.floor(max_window_size / 2))
max_N = max(N_seq)
Ns = 512 # FFT size for synthesis (even)
H = Ns / 4 # Hop size used for analysis and synthesis
hNs = Ns / 2 # half of synthesis FFT size
pin = max(hNs, hM1) # init sound pointer in middle of anal window
pend = x.size - pin # last sample to start a frame
yw = np.zeros(Ns) # initialize output sound frame
y = np.zeros(x.size) # initialize output array
sw = np.zeros(Ns) # initialize synthesis window
ow = triang(2 * H) # triangular window
sw[hNs - H:hNs + H] = ow # add triangular window
bh = blackmanharris(Ns) # blackmanharris window
bh = bh / sum(bh) # normalized blackmanharris window
sw[hNs - H:hNs +
H] = sw[hNs - H:hNs + H] / bh[hNs - H:hNs +
H] # normalized synthesis window
for i in range(len(w_seq)):
w_seq[i] = w_seq[i] / sum(w_seq[i]) # normalize analysis windows
logger.debug("Hop size {}".format(H))
while pin < pend: # while input sound pointer is within sound
#logger.debug("pin {}".format(pin))
# -----analysis-----
iplocs = [None] * k
ipmags = [None] * k
ipphases = [None] * k
ipfreqs = [None] * k
# The frame of audio to analyse must be as wide as the largest window
x1 = get_frame(x, pin, max_window_size)
# For each band perform analysis with specified FFT size and window.
for i, (w, N) in enumerate(zip(w_seq, N_seq)):
iplocs[i], ipmags[i], ipphases[i], ipfreqs[i] = analysis(
x1, fs, w, N, t)
# For each band, pick detected frequencies inside the band. Ignore detected frequencies outside band.
# Aggregate the detected frequencies (and associated magnitude, phase) into a single set of values.
final_ipmag = np.array([])
final_ipphase = np.array([])
final_ipfreq = np.array([])
for ipmag, ipphase, ipfreq, (freq_min,
freq_max) in zip(ipmags, ipphases,
ipfreqs, B_seq):
for pmag, pphase, pfreq in zip(ipmag, ipphase, ipfreq):
if freq_min <= pfreq < freq_max:
final_ipmag = np.append(final_ipmag, pmag)
final_ipphase = np.append(final_ipphase, pphase)
final_ipfreq = np.append(final_ipfreq, pfreq)
#logger.debug("Add {} Hz from range ({}, {})".format(pfreq, freq_min, freq_max))
# -----synthesis-----
Y = UF.genSpecSines(final_ipfreq, final_ipmag, final_ipphase, Ns,
fs) # generate sines in the spectrum
fftbuffer = np.real(ifft(Y)) # compute inverse FFT
yw[:hNs - 1] = fftbuffer[hNs + 1:] # undo zero-phase window
yw[hNs - 1:] = fftbuffer[:hNs + 1]
y[pin - hNs:pin +
hNs] += sw * yw # overlap-add and apply a synthesis window
pin += H
return y
def run(self, tf, dt, c1, c2):
np.random.seed(62)
""" Run a simulation """
n, m, k = self.n, self.m, self.k
# Total simulation time
simTime = int(tf / dt)
# Returns the three synaptic connections kernels
W12, W21, W22, delays = self.build_kernels()
# Compute delays by dividing distances by axonal velocity
delays12 = np.floor(delays[0] / c2)
delays21 = np.floor(delays[1] / c1)
delays22 = np.floor(delays[2] / c2)
maxDelay = int(
max(delays12[0].max(), delays21[0].max(), delays22[0].max()))
# Set the initial conditions and the history
self.initial_conditions(simTime)
# Initialize the cortical and striatal inputs
Cx = 0.5
Str = 0.4
# Presynaptic activities
pre12, pre21, pre22 = np.empty((m, )), np.empty((m, )), np.empty((m, ))
# Simulation
for i in range(maxDelay, simTime):
# Take into account the history of rate for each neuron according
# to its axonal delay
for idxi, ii in enumerate(range(m)):
mysum = 0.0
for jj in range(k, n):
mysum += (W12[ii, jj] *
self.X2[i - delays12[ii, jj], jj]) * self.dx
pre12[idxi] = mysum
for idxi, ii in enumerate(range(k, n)):
mysum = 0.0
for jj in range(0, m):
mysum += (W21[ii, jj] *
self.X1[i - delays21[ii, jj], jj]) * self.dx
pre21[idxi] = mysum
for idxi, ii in enumerate(range(k, n)):
mysum = 0.0
for jj in range(k, n):
mysum += (W22[ii, jj] *
self.X2[i - delays22[ii, jj], jj]) * self.dx
pre22[idxi] = mysum
# Forward Euler step
self.X1[i, :m] = (
self.X1[i - 1, :m] +
(-self.X1[i - 1, :m] + self.S1(-pre12 + Cx)) * dt / self.tau1)
self.X2[i, k:] = (
self.X2[i - 1, k:] +
(-self.X2[i - 1, k:] + self.S2(pre21 - pre22 - Str)) * dt /
self.tau2)
dx = 1.0 / float(m)
fr = self.X1.sum(axis=1) * dx / 1.0
signal = detrend(fr)
windowed = signal * blackmanharris(len(signal))
f = rfft(windowed)
i = np.argmax(np.abs(f))
# true_i = parabolic(np.log(np.abs(f)), i)[0]
return i
def tapering_window(tseries, method="Hanning"):
"""
Returns Tapered 1D time series.
Input:
1) tseries : 1D variable containing time series data.
2) method : Use any one of the teppering window given below.
"Hanning" (default)
"Hamming"
"Boxcar"
"Tukey"
"Blackman-Harris"
"Kaiser".
Output:
1) tseries_tapered : Time series after applaying tapering window
Example:
tapering_window(time_series)
tapering_window(time_series,"Tukey")
"""
length = len(tseries)
if method == "Hanning":
# The Hanning window is a taper formed by using a weighted cosine.
# w(n)= 0.5-0.5*cos(2*pi*n/(M-1)))
# with 0<=M<=1
wind_hanning = np.hanning(length)
tseries_tapered = tseries * wind_hanning
print("Hanning window is applied.....")
elif method == "Hamming":
# The Hanning window is a taper formed by using a weighted cosine.
# w(n)= 0.54-0.46*cos(2*pi*n/(M-1)))
# with 0<=M<=1
wind_hamming = np.hamming(length)
tseries_tapered = tseries * wind_hamming
print("Hamming window is applied.....")
elif method == "Boxcar":
wind_boxcar = signal.boxcar(length)
tseries_tapered = tseries * wind_boxcar
print("Boxcar window is applied.....")
elif method == "Tukey":
# Also called "Planck-taper" window is a bump function
wind_tukey = signal.tukey(length)
tseries_tapered = tseries * wind_tukey
print("Tukey window is applied.....")
elif method == "Blackman-Harris":
# A generalization of the Hamming family
# w(n)=a0-a1cos(2*pi*n/N)+a2cos(4*pi*n/N)-a3cos(6*pi*n/N)
wind_buckman = signal.blackmanharris(length)
tseries_tapered = tseries * wind_buckman
print("Blackman-Harris window is applied.....")
elif method == "Kaiser":
# The Kaiser window is a taper formed by using a Bessel function.
# w(n)=I0(beta*sqrt(1=(4*n^2/(M-1)^2))/(I0*beta)
# with
# -(M-1)/2<=n<=(M-1)/2
# The Kaiser can approximate many other windows by varying
# the beta parameter.
beta = 14.0
wind_kaiser = np.kaiser(length, beta)
tseries_tapered = tseries * wind_kaiser
print("kaiser window is applied.....")
return tseries_tapered
def sine_model(s,a_win,overlap_factor,N_fft_a,N_fft_s,thres,robot):
# Window size (analysis)
N_a = np.size(a_win)
# Window size (synthesis). We keep N_fft_synthesis and N_s identical, since
# 0-padding will not add any relevant information
N_s = N_fft_s
mid_fft_a = int((N_fft_a+1)/2)
# Normalize analysis window
a_win = a_win/np.sum(a_win)
# Hop size
H = int(round(N_a/overlap_factor))
# Total number of signal points
N_pts = np.size(s,0)
# Initialize output
y = np.zeros(N_pts)
# Build corrected Blackman-Harris window (synthesis)
s_win = np.zeros(N_fft_s)
t_win = sig.triang((2*H)-1)
# Add triangular window at the center
s_win[(N_s/2)+1-H+1:(N_s/2)+H+1] = t_win
b_win = sig.blackmanharris(N_s)
b_win = b_win/np.sum(b_win)
s_win[(N_s/2)+1-H+1:(N_s/2)+H+1] = s_win[(N_s/2)+1-H+1:(N_s/2)+H+1]/b_win[(N_s/2)+1-H+1:(N_s/2)+H+1]
# Initialize the reading pointer
p_in = int(max(0.5*(N_a-1),(0.5*N_s)-1))
# Initialize the upper limit of the pointer
p_end = N_pts-1-int(max(0.5*N_s,0.5*(N_a-1)))
# Debug variable
k = 0
while p_in < p_end:
# Fill the buffer
s_w = s[p_in-int(0.5*(N_a-1)):p_in+int(0.5*(N_a-1))+1]
# Apply analysis window
s_w = s_w*a_win
# Zero phase correction and 0-padding
s_temp = np.zeros(N_fft_a)
s_temp[0:((N_a-1)/2)] = s_w[((N_a+1)/2):]
s_temp[N_fft_a-((N_a+1)/2):] = s_w[:((N_a+1)/2)]
# Compute FFT
X = np.fft.fft(s_temp,N_fft_a)
mod_X = 20*np.log10(np.abs(X[:mid_fft_a+1]))
arg_X = np.unwrap(np.angle(X[:mid_fft_a+1]))
lower_bound = mod_X[1:mid_fft_a-1] > mod_X[0:mid_fft_a-2]
max_estimation = mod_X[1:mid_fft_a-1] > thres
upper_bound = mod_X[1:mid_fft_a-1] > mod_X[2:mid_fft_a]
# Search for the indexes where the three conditions are satisfied
peak_loc = np.where(lower_bound & max_estimation & upper_bound)
peak_loc = peak_loc[0] + 1
# Interpolated values
peak_mag = quadratic_max(mod_X[peak_loc-1],mod_X[peak_loc],mod_X[peak_loc+1])
peak_loc_interp = quadratic_argmax(peak_loc,mod_X[peak_loc-1],mod_X[peak_loc],mod_X[peak_loc+1])
peak_phase = np.interp(peak_loc_interp,np.array(range(np.size(arg_X))),arg_X)
# Fun ...(0 phase reconstruction, aka robotic voice)
if robot==1:
peak_phase = np.zeros(np.size(arg_X))
# Synthesize signal and remove zero-phase correction
Y = sine_synthesis(peak_loc_interp*N_fft_s/N_fft_a,peak_mag,peak_phase,N_fft_s,N_fft_s)
y_w = np.fft.fftshift(np.real(np.fft.ifft(Y)))
# -----------------------------------------------------------------------
# Section for debugging purposes
if (k == 9):
plt.plot(s_w,'b')
plt.title('Input signal versus output signal (time domain)')
plt.hold(True)
plt.plot(y_w,'r')
plt.grid()
plt.figure()
plt.plot(20*np.log10(X),'b')
plt.title('Input signal versus output signal (frequency domain)')
plt.hold(True)
plt.plot(20*np.log10(Y),'r')
plt.grid()
k += 1
# -----------------------------------------------------------------------
# Apply synthesis window
y_w = y_w*s_win
# Overlap-add
y[p_in-int(0.5*N_s)+1:p_in+int(0.5*N_s)+1] += y_w
# Jump to the next position
p_in += H
return y
# =============================================================================
def iq_file(self):
for path in self.chooseFileDlg.GetPaths():
iq_file = open(path,'rb').read()
iq_gps_centr = []
for line in iq_file:
line = ord(line)
iq_gps_centr.append(line)
wave1_list = []
wave1_list.append('Start')
wave1_list.append(iq_gps_centr[1])
longtitude_int = iq_gps_centr[2]
longtitude_frac_high = iq_gps_centr[3] << 8
longtitude_frac_low = iq_gps_centr[4]
longtitude_frac = longtitude_frac_high + longtitude_frac_low
longtitude = longtitude_int + longtitude_frac / (10 ** len(str(longtitude_frac)))
longtitude = float('%.6f' % longtitude)
wave1_list.append(longtitude)
wave1_list.append(iq_gps_centr[5] >> 7)
latitude_int = iq_gps_centr[5] & 0x7F
latitude_frac_high = iq_gps_centr[6] << 8
latitude_frac_low = iq_gps_centr[7]
latitude_frac = latitude_frac_high + latitude_frac_low
latitude = latitude_int + latitude_frac / (10 ** len(str(latitude_frac)))
latitude = float('%.6f' % latitude)
wave1_list.append(latitude)
height_flag = iq_gps_centr[8] >> 7
height_high = (iq_gps_centr[8] & 0x7F) << 8
height_low = iq_gps_centr[9]
height = height_high + height_low
if height_flag == 1 :
height = - height
wave1_list.append(height)
freq_centr_int_h = iq_gps_centr[10] << 6
freq_centr_int_l = iq_gps_centr[11] & 0x3F
freq_centr_frac_h = (iq_gps_centr[11] >> 6)<< 8
freq_centr_frac_l = iq_gps_centr[12]
freq_centr_int = freq_centr_int_h + freq_centr_int_l
freq_centr_frac = freq_centr_frac_h + freq_centr_frac_l
freq_centr = freq_centr_int + freq_centr_frac / (10 ** len(str(freq_centr_frac)))
freq_centr = float('%.4f' % freq_centr)
wave1_list.append(freq_centr)
bandwidth = iq_gps_centr[13] >> 4
if (bandwidth == 1) :
bandwidth_rate = 5
wave1_list.append(5)
wave1_list.append(5)
elif (bandwidth == 2):
bandwidth_rate = 2.5
wave1_list.append(2.5)
wave1_list.append(2.5)
elif (bandwidth == 3):
bandwidth_rate = 1.25
wave1_list.append(1.25)
wave1_list.append(1.25)
elif (bandwidth == 4):
bandwidth_rate = 0.625
wave1_list.append(0.625)
wave1_list.append(0.625)
elif (bandwidth == 5):
bandwidth_rate = 0.125
wave1_list.append(0.125)
wave1_list.append(0.125)
wave1_list.append(iq_gps_centr[14])
wave1_list.append('')
# print wave1_list
# print len(wave1_list)
a = path.index('IQ')
filename = path[(a + 3) : -3]
wave1_file = open(r'./LocalData/Wave2/' + filename + '.wave2','w')
for i in range(len(wave1_list)):
wave1_file.write(str(wave1_list[i]) + '\n')
wave1_file.close()
N = iq_gps_centr[14]
for j in range(N):
IData = []
QData = []
for i in range(2000):
HighI1 = ((iq_gps_centr[6001 * (j + 1) - 5985 + i * 3]) >> 4) << 8
LowI1 = iq_gps_centr[6001 * (j + 1) - 5984 + i * 3]
if (HighI1 >= 2048):
I1 = -(2 ** 12 - HighI1 - LowI1)
else :
I1 = (HighI1 + LowI1)
IData.append(I1)
HighQ1 = ((iq_gps_centr[6001 * (j + 1) - 5985 + i * 3]) & 0x0F) << 8
LowQ1 = iq_gps_centr[6001 * (j + 1) - 5983 + i * 3]
if (HighQ1 >= 2048):
Q1 = -(2 ** 12 - HighQ1 - LowQ1)
else :
Q1 = (HighQ1 + LowQ1)
QData.append(Q1)
IQData = []
for i in range(2000):
data1 = complex(IData[i]/2047,-QData[i]/2047)
IQData.append(data1)
for i in range(48):
IQData.append(0)
n = 2048
y = IQData[:]
w = signal.blackmanharris(n)
y = y*w
y_fft = np.fft.fft(y)
y_fftshift = np.fft.fftshift(y_fft)
yk = (1 / sqrt(sum(abs(w * w))/ 2048)) * y_fftshift
pk = [] ##### pk:相对平均功率谱
fk = [] ##### fk:对应的实际频率值
angle = [] #### angle:对应的相位谱
for k in range(-1024,1024):
fk.append(freq_centr + k * bandwidth_rate / 2048)
for i in range(len(yk)):
pk.append(-57.206 + 20 * log10(abs(yk[i])))
if (yk[i].real == 0)and(yk[i].imag > 0) :
angle.append(90)
elif (yk[i].real == 0)and(yk[i].imag < 0) :
angle.append(-90)
elif (yk[i].real == 0)and(yk[i].imag == 0) :
angle.append(0)
else :
angle.append(57.3 * atan(yk[i].imag / yk[i].real))
angle[i] = '%.2f' % angle[i]
if self.am_fm_mode.GetSelection() == 0 : ###am
data = self.am_mode(IData, QData)
elif(self.am_fm_mode.GetSelection() == 1 ): ###fm
data = self.fm_mode(IData, QData) #### data:解调后对应的值
if self.spec_mode.GetValue():
if(self.parent.IQ2SpecFrame_test == None):
self.parent.IQ2SpecFrame_test = DrawPanel(self.parent,fk,pk,angle,data,self.chooseFileDlg.GetPaths(),self.am_fm_mode.GetSelection(),self.choosefilemode)
self.parent.IQ2SpecFrame_test.Activate()
self.parent.IQ2SpecFrame_test.spec.set_txt(filename, longtitude, latitude, height, freq_centr, bandwidth_rate)
# self.parent.IQ2SpecFrame_test.spec.setLbl_draw(fk,pk)
self.parent.IQ2SpecFrame_test.spec.filePath(self.chooseFileDlg.GetPaths())
self.parent.IQ2SpecFrame_test.wave.filePath(self.chooseFileDlg.GetPaths())
self.parent.IQ2SpecFrame_test.wave.am_fm_mode_refresh(self.am_fm_mode.GetSelection())
if self.water_mode.GetValue():
if(self.parent.WaterFrame_pl == None):
self.parent.WaterFrame_pl = IQ2_Water(self.parent,fk,pk,self.chooseFileDlg.GetPaths(),self.choosefilemode)
self.parent.WaterFrame_pl.Activate()
self.parent.WaterFrame_pl.set_txt(filename, longtitude, latitude, height, freq_centr, bandwidth_rate)
self.parent.WaterFrame_pl.fileDraw(self.chooseFileDlg.GetPaths())
self.parent.WaterFrame_pl.setLbl_draw(fk,pk)
wave1_file = open(r'./LocalData/Wave2/' + filename + '.wave2','a')
for i in range(2000):
wave1_file.write(str('%.4f' % data[i]) + '\n')
wave1_file.close()
wave1_file = open(r'./LocalData/Wave2/' + filename + '.wave2','a')
wave1_file.write('end')
wave1_file.close()
Thd(x, fs)
ThdN(x, fs)
elif c == 'w':
sRate = 44100.0
t = np.arange(0, 2.0, 1/sRate)
samples = np.sin(2*np.pi*440.0*t)
writeWaveFile('test1.wav', samples, int(sRate))
sampleRate = 44100
samples = KarplusStrong(1*sampleRate, sampleRate, 391)
writeWaveFile('test2.wav', samples, int(sampleRate))
samples -= np.mean(samples)
windowed = samples * signal.blackmanharris(len(samples))
f = np.fft.rfft(windowed)
i = np.argmax(np.abs(f))
ThdValue = rms_harmony(f, i) / np.abs(f[i])
print('freq = %f and thd = %f' %(i, ThdValue))
#Thd(samples, sampleRate)
#ThdN(samples, sampleRate)
plt.plot(np.abs(f))
#plt.legend(['test1', 'test2'], loc='best')
plt.grid()
plt.show()
hold(True)
from scipy import signal as si
b = si.kaiser(N, 3)
gfiltpak.gfreqz(b,
a,
color='m',
magfig=mag_p,
angfig=ang_p,
label="kaiser",
threedb=True)
hold(True)
b = si.blackmanharris(N)
gfiltpak.gfreqz(b, a, color='g', magfig=mag_p, angfig=ang_p, ylimmag=[-500, 0])
hold(True)
b = si.blackman(N)
gfiltpak.gfreqz(b, a, color='y', magfig=mag_p, angfig=ang_p)
# Show
mag_p.legend(('r', 'k', '3dB', 'b-h', 'b'), numpoints=4, fancybox=True)
ang_p.legend(('r', 'k', 'b-h', 'b'), numpoints=2, fancybox=True)
##############################################################
## IIR filter
c = 1
b = [1]
root_r = 0.10
def test_blackman_harris(self):
size = randint(0, 1000)
generated = windowing.blackman_harris(size)
reference = signal.blackmanharris(size)
for g, r in zip(generated, reference):
self.assertAlmostEqual(g, r)
[coords_xy, coords_xy, coords_z], fg_lightcone)
highres_lightcone_fg = f_lc(
np.array([xx.flatten(), yy.flatten(),
zz.flatten()]).T).reshape(Ngrid, Ngrid, len(new_coords_z))
# interpolate the eor across frequency to make sure we have the same dimension as foregrounds
f_lc_fg = scipy.interpolate.RegularGridInterpolator(
[coords_xy, coords_xy, coords_z], lightcone_eor)
highres_lightcone_eor = f_lc(
np.array([xx.flatten(), yy.flatten(),
zz.flatten()]).T).reshape(Ngrid, Ngrid, len(new_coords_z))
# Find the PS of foregrounds plus eor
P_both, kperp, kparal = get_power(
(highres_lightcone_fg + highres_lightcone_eor) *
signal.blackmanharris(len(new_coords_z)), [500, 500, Lz_Mpc],
bins=50,
res_ndim=2,
bin_ave=False,
get_variance=False)
# Find the PS of foregrounds only
P_fg = get_power(highres_lightcone_fg *
signal.blackmanharris(len(new_coords_z)), [500, 500, Lz_Mpc],
bins=50,
res_ndim=2,
bin_ave=False,
get_variance=False)[0]
# Find the PS of eor only
P_eor = get_power(highres_lightcone_eor *
def sineModel_MultiRes(x, fs, w1, w2, w3, N1, N2, N3, t, B1, B2, B3):
"""
Week 10, Project: A multi-resolution sinusoidal model
Analysis/synthesis of a sound using the sinusoidal model, without sine tracking
Using Multi-resolution sine model
x: input array sound, w: analysis window, N: size of complex spectrum, t: threshold in negative dB
N1, N2, N3: size of the 3 complex spectrum
B1, B2, B3: Frequency band edges (Upper limits) of the 3 frequency bands
[0 - B1] is the first frequency band
[B1 - B2] is the second frequency band
[B2 - B3] is the third frequency band
returns y: output array sound
"""
hM1_1 = int(math.floor(
(w1.size + 1) / 2)) # half analysis for 1st window size by rounding
hM1_2 = int(math.floor(w1.size /
2)) # half analysis for 1st window size by floor
hM2_1 = int(math.floor(
(w2.size + 1) / 2)) # half analysis for 2nd window size by rounding
hM2_2 = int(math.floor(w2.size /
2)) #half analysis for 2nd window size by floor
hM3_1 = int(math.floor(
(w3.size + 1) / 2)) # half analysis for 3rd window size by rounding
hM3_2 = int(math.floor(w3.size /
2)) #half analysis for 3rd window size by floor
Ns = 512 # FFT size for synthesis (even)
H = Ns // 4 # Hop size used for analysis and synthesis
hNs = Ns // 2 # half of synthesis FFT size
pin = max(hNs, hM1_1, hM2_1,
hM3_1) # init sound pointer in middle of biggest anal window
pend = x.size - pin # last sample to start a frame
fftbuffer = np.zeros(max(N1, N2, N3)) # initialize buffer for FFT
yw = np.zeros(Ns) # initialize output sound frame
y = np.zeros(x.size) # initialize output array
w_1 = w1 / sum(w1) # normalize the 1st analysis window
w_2 = w2 / sum(w2) # normalize the 2nd analysis window
w_3 = w3 / sum(w3) # normalize the 3rd analysis window
sw = np.zeros(Ns) # initialize synthesis window
ow = triang(2 * H) # triangular window
sw[hNs - H:hNs + H] = ow # add triangular window
bh = blackmanharris(Ns) # blackmanharris window
bh = bh / sum(bh) # normalized blackmanharris window
sw[hNs - H:hNs +
H] = sw[hNs - H:hNs + H] / bh[hNs - H:hNs +
H] # normalized synthesis window
while pin < pend: # while input sound pointer is within sound
# -----analysis-----
#Selecting THREE FRAMES for the same CENTRAL PIN POINT, but FOR DIFFERENT LENGTHS
x1 = x[pin - hM1_1:pin + hM1_2] # select frame for window size 1
x2 = x[pin - hM2_1:pin + hM2_2] # select frame for window size2
x3 = x[pin - hM3_1:pin + hM3_2] # select frame for window size3
mX1, pX1 = DFT.dftAnal(x1, w1, N1) # compute dft for 1st frame
mX2, pX2 = DFT.dftAnal(x2, w2, N2) # compute dft for 2nd frame
mX3, pX3 = DFT.dftAnal(x3, w3, N3) # compute dft for 3rd frame
ploc1 = UF.peakDetection(mX1,
t) # detect locations of peaks for 1st frame
ploc2 = UF.peakDetection(mX2,
t) # detect locations of peaks for 2nd frame
ploc3 = UF.peakDetection(mX3,
t) # detect locations of peaks for 3rd frame
iploc1, ipmag1, ipphase1 = UF.peakInterp(
mX1, pX1,
ploc1) # refine peak values by interpolation for the 1st frame
iploc2, ipmag2, ipphase2 = UF.peakInterp(
mX2, pX2,
ploc2) # refine peak values by interpolation for the 2nd frame
iploc3, ipmag3, ipphase3 = UF.peakInterp(
mX3, pX3,
ploc3) # refine peak values by interpolation for the 3rd frame
ipfreq1 = fs * iploc1 / float(
N1) # convert peak locations of 1st frame to Hertz
ipfreq2 = fs * iploc2 / float(
N2) # convert peak locations of 2nd frame to Hertz
ipfreq3 = fs * iploc3 / float(
N3) # convert peak locations of 3rd frame to Hertz
# Looking for indices of peak frequencies
# in each band, for each window calculation
indice_1 = np.logical_and(ipfreq1 > 0, ipfreq1 < B1)
indice_2 = np.logical_and(ipfreq2 >= B1, ipfreq2 < B2)
indice_3 = np.logical_and(ipfreq3 >= B2, ipfreq3 < B3)
# Getting peaks which fall in selected frequency bands
ipfreq = np.concatenate(
(ipfreq1[indice_1], ipfreq2[indice_2], ipfreq3[indice_3]))
ipmag = np.concatenate(
(ipmag1[indice_1], ipmag2[indice_2], ipmag3[indice_3]))
ipphase = np.concatenate(
(ipphase1[indice_1], ipphase2[indice_2], ipphase3[indice_3]))
# -----synthesis-----
Y = UF.genSpecSines(ipfreq, ipmag, ipphase, Ns,
fs) # generate sines in the spectrum
fftbuffer = np.real(ifft(Y)) # compute inverse FFT
yw[:hNs - 1] = fftbuffer[hNs + 1:] # undo zero-phase window
yw[hNs - 1:] = fftbuffer[:hNs + 1]
y[pin - hNs:pin +
hNs] += sw * yw # overlap-add and apply a synthesis window
pin += H # advance sound pointer
return y
def harmonicModel(x, fs, w, N, t, nH, minf0, maxf0, f0et):
#Analysis/synthesis of a sound using the sinusoidal harmonic model
#x: input sound, fs: sampling rate, w: analysis window,
#N: FFT size (minimum 512), t: threshold in negative dB,
#nH: maximum number of harmonics, minf0: minimum f0 frequency in Hz,
#maxf0: maximim f0 frequency in Hz,
#f0et: error threshold in the f0 detection (ex: 5),
#returns y: output array sound
hN = N / 2 # size of positive spectrum
hM1 = int(math.floor(
(w.size + 1) / 2)) # half analysis window size by rounding
hM2 = int(math.floor(w.size / 2)) # half analysis window size by floor
x = np.append(
np.zeros(hM2),
x) # add zeros at beginning to center first window at sample 0
x = np.append(x,
np.zeros(hM1)) # add zeros at the end to analyze last sample
Ns = 512 # FFT size for synthesis (even)
H = Ns / 4 # Hop size used for analysis and synthesis
hNs = Ns / 2
pin = max(hNs, hM1) # init sound pointer in middle of anal window
pend = x.size - max(hNs, hM1) # last sample to start a frame
fftbuffer = np.zeros(N) # initialize buffer for FFT
yh = np.zeros(Ns) # initialize output sound frame
y = np.zeros(x.size) # initialize output array
w = w / sum(w) # normalize analysis window
sw = np.zeros(Ns) # initialize synthesis window
ow = triang(2 * H) # overlapping window
sw[hNs - H:hNs + H] = ow
bh = blackmanharris(Ns) # synthesis window
bh = bh / sum(bh) # normalize synthesis window
sw[hNs - H:hNs +
H] = sw[hNs - H:hNs + H] / bh[hNs - H:hNs + H] # window for overlap-add
hfreqp = []
f0t = 0
f0stable = 0
while pin < pend:
#-----analysis-----
x1 = x[pin - hM1:pin + hM2] # select frame
mX, pX = DFT.dftAnal(x1, w, N) # compute dft
ploc = UF.peakDetection(mX, t) # detect peak locations
iploc, ipmag, ipphase = UF.peakInterp(mX, pX,
ploc) # refine peak values
ipfreq = fs * iploc / N
f0t = UF.f0Twm(ipfreq, ipmag, f0et, minf0, maxf0, f0stable) # find f0
if ((f0stable==0)&(f0t>0)) \
or ((f0stable>0)&(np.abs(f0stable-f0t)<f0stable/5.0)):
f0stable = f0t # consider a stable f0 if it is close to the previous one
else:
f0stable = 0
hfreq, hmag, hphase = harmonicDetection(ipfreq, ipmag, ipphase, f0t,
nH, hfreqp,
fs) # find harmonics
hfreqp = hfreq
#-----synthesis-----
Yh = UF.genSpecSines(hfreq, hmag, hphase, Ns,
fs) # generate spec sines
fftbuffer = np.real(ifft(Yh)) # inverse FFT
yh[:hNs - 1] = fftbuffer[hNs + 1:] # undo zero-phase window
yh[hNs - 1:] = fftbuffer[:hNs + 1]
y[pin - hNs:pin + hNs] += sw * yh # overlap-add
pin += H # advance sound pointer
y = np.delete(
y,
range(hM2)) # delete half of first window which was added in stftAnal
y = np.delete(y,
range(y.size - hM1,
y.size)) # add zeros at the end to analyze last sample
return y
def spsModel(x, fs, w, N, t, stocf):
"""
Analysis/synthesis of a sound using the sinusoidal plus stochastic model
x: input sound, fs: sampling rate, w: analysis window,
N: FFT size (minimum 512), t: threshold in negative dB,
stocf: decimation factor of mag spectrum for stochastic analysis
returns y: output sound, ys: sinusoidal component, yst: stochastic component
"""
hN = N // 2 # size of positive spectrum
hM1 = int(math.floor(
(w.size + 1) / 2)) # half analysis window size by rounding
hM2 = int(math.floor(w.size / 2)) # half analysis window size by floor
Ns = 512 # FFT size for synthesis (even)
H = Ns // 4 # Hop size used for analysis and synthesis
hNs = Ns // 2
pin = max(hNs,
hM1) # initialize sound pointer in middle of analysis window
pend = x.size - max(hNs, hM1) # last sample to start a frame
fftbuffer = np.zeros(N) # initialize buffer for FFT
ysw = np.zeros(Ns) # initialize output sound frame
ystw = np.zeros(Ns) # initialize output sound frame
ys = np.zeros(x.size) # initialize output array
yst = np.zeros(x.size) # initialize output array
w = w / sum(w) # normalize analysis window
sw = np.zeros(Ns)
ow = triang(2 * H) # overlapping window
sw[hNs - H:hNs + H] = ow
bh = blackmanharris(Ns) # synthesis window
bh = bh / sum(bh) # normalize synthesis window
wr = bh # window for residual
sw[hNs - H:hNs + H] = sw[hNs - H:hNs + H] / bh[hNs - H:hNs + H]
sws = H * hanning(Ns) / 2 # synthesis window for stochastic
while pin < pend:
#-----analysis-----
x1 = x[pin - hM1:pin + hM2] # select frame
mX, pX = DFT.dftAnal(x1, w, N) # compute dft
ploc = UF.peakDetection(mX, t) # find peaks
iploc, ipmag, ipphase = UF.peakInterp(
mX, pX, ploc
) # refine peak values iploc, ipmag, ipphase = UF.peakInterp(mX, pX, ploc) # refine peak values
ipfreq = fs * iploc / float(N) # convert peak locations to Hertz
ri = pin - hNs - 1 # input sound pointer for residual analysis
xw2 = x[ri:ri + Ns] * wr # window the input sound
fftbuffer = np.zeros(Ns) # reset buffer
fftbuffer[:hNs] = xw2[hNs:] # zero-phase window in fftbuffer
fftbuffer[hNs:] = xw2[:hNs]
X2 = fft(fftbuffer) # compute FFT for residual analysis
#-----synthesis-----
Ys = UF.genSpecSines(ipfreq, ipmag, ipphase, Ns,
fs) # generate spec of sinusoidal component
Xr = X2 - Ys
# get the residual complex spectrum
mXr = 20 * np.log10(abs(Xr[:hNs])) # magnitude spectrum of residual
mXrenv = resample(
np.maximum(-200, mXr),
mXr.size * stocf) # decimate the magnitude spectrum and avoid -Inf
stocEnv = resample(mXrenv, hNs) # interpolate to original size
pYst = 2 * np.pi * np.random.rand(hNs) # generate phase random values
Yst = np.zeros(Ns, dtype=complex)
Yst[:hNs] = 10**(stocEnv / 20) * np.exp(
1j * pYst) # generate positive freq.
Yst[hNs + 1:] = 10**(stocEnv[:0:-1] / 20) * np.exp(
-1j * pYst[:0:-1]) # generate negative freq.
fftbuffer = np.zeros(Ns)
fftbuffer = np.real(ifft(Ys)) # inverse FFT of harmonic spectrum
ysw[:hNs - 1] = fftbuffer[hNs + 1:] # undo zero-phase window
ysw[hNs - 1:] = fftbuffer[:hNs + 1]
fftbuffer = np.zeros(Ns)
fftbuffer = np.real(ifft(Yst)) # inverse FFT of stochastic spectrum
ystw[:hNs - 1] = fftbuffer[hNs + 1:] # undo zero-phase window
ystw[hNs - 1:] = fftbuffer[:hNs + 1]
ys[ri:ri + Ns] += sw * ysw # overlap-add for sines
yst[ri:ri + Ns] += sws * ystw # overlap-add for stochastic
pin += H # advance sound pointer
y = ys + yst # sum of sinusoidal and residual components
return y, ys, yst
