def main(inputFile='../../sounds/ocean.wav', H=256, stocf=.1):
# ------- analysis parameters -------------------
# inputFile: input sound file (monophonic with sampling rate of 44100)
# H: hop size
# stocf: decimation factor used for the stochastic approximation
# --------- computation -----------------
# read input sound
(fs, x) = UF.wavread(inputFile)
# compute stochastic model
mYst = STM.stochasticModelAnal(x, H, stocf)
# synthesize sound from stochastic model
y = STM.stochasticModelSynth(mYst, H)
outputFile = 'output_sounds/' + os.path.basename(inputFile)[:-4] + '_stochasticModel.wav'
# write output sound
UF.wavwrite(y, fs, outputFile)
# --------- plotting --------------------
# create figure to plot
plt.figure(figsize=(12, 9))
# plot the input sound
plt.subplot(3,1,1)
plt.plot(np.arange(x.size)/float(fs), x)
plt.axis([0, x.size/float(fs), min(x), max(x)])
plt.ylabel('amplitude')
plt.xlabel('time (sec)')
plt.title('input sound: x')
# plot stochastic representation
plt.subplot(3,1,2)
numFrames = int(mYst[:,0].size)
frmTime = H*np.arange(numFrames)/float(fs)
binFreq = np.arange(stocf*H)*float(fs)/(stocf*2*H)
plt.pcolormesh(frmTime, binFreq, np.transpose(mYst))
plt.autoscale(tight=True)
plt.xlabel('time (sec)')
plt.ylabel('frequency (Hz)')
plt.title('stochastic approximation')
# plot the output sound
plt.subplot(3,1,3)
plt.plot(np.arange(y.size)/float(fs), y)
plt.axis([0, y.size/float(fs), min(y), max(y)])
plt.ylabel('amplitude')
plt.xlabel('time (sec)')
plt.tight_layout()
plt.show()
def extractHarmSpec(inputFile='../../sounds/ocean.wav',
H=256,
N=512,
stocf=.1):
"""
inputFile: input sound file (monophonic with sampling rate of 44100)
H: hop size, N: fft size
stocf: decimation factor used for the stochastic approximation (bigger than 0, maximum 1)
"""
# read input sound
(fs, x) = UF.wavread(inputFile)
# compute stochastic model
stocEnv = STM.stochasticModelAnal(x, H, N, stocf)
# synthesize sound from stochastic model
y = STM.stochasticModelSynth(stocEnv, H, N)
outputFile = 'output_sounds/' + os.path.basename(
inputFile)[:-4] + '_stochasticModel.wav'
# write output sound
UF.wavwrite(y, fs, outputFile)
# create figure to plot
plt.figure(figsize=(12, 9))
# plot the input sound
plt.subplot(3, 1, 1)
plt.plot(np.arange(x.size) / float(fs), x)
plt.axis([0, x.size / float(fs), min(x), max(x)])
plt.ylabel('amplitude')
plt.xlabel('time (sec)')
plt.title('input sound: x')
# plot stochastic representation
plt.subplot(3, 1, 2)
numFrames = int(stocEnv[:, 0].size)
frmTime = H * np.arange(numFrames) / float(fs)
binFreq = np.arange(stocf * N / 2) * float(fs) / (stocf * N)
plt.pcolormesh(frmTime, binFreq, np.transpose(stocEnv))
plt.autoscale(tight=True)
plt.xlabel('time (sec)')
plt.ylabel('frequency (Hz)')
plt.title('stochastic approximation')
# plot the output sound
plt.subplot(3, 1, 3)
plt.plot(np.arange(y.size) / float(fs), y)
plt.axis([0, y.size / float(fs), min(y), max(y)])
plt.ylabel('amplitude')
plt.xlabel('time (sec)')
plt.tight_layout()
plt.show()
def main(inputFile='../../sounds/ocean.wav', H=256, N=512, stocf=.1):
"""
inputFile: input sound file (monophonic with sampling rate of 44100)
H: hop size, N: fft size
stocf: decimation factor used for the stochastic approximation (bigger than 0, maximum 1)
"""
# read input sound
(fs, x) = UF.wavread(inputFile)
# compute stochastic model
stocEnv = STM.stochasticModelAnal(x, H, N, stocf)
# synthesize sound from stochastic model
y = STM.stochasticModelSynth(stocEnv, H, N)
outputFile = 'output_sounds/' + os.path.basename(inputFile)[:-4] + '_stochasticModel.wav'
# write output sound
UF.wavwrite(y, fs, outputFile)
# create figure to plot
plt.figure(figsize=(12, 9))
# plot the input sound
plt.subplot(3,1,1)
plt.plot(np.arange(x.size)/float(fs), x)
plt.axis([0, x.size/float(fs), min(x), max(x)])
plt.ylabel('amplitude')
plt.xlabel('time (sec)')
plt.title('input sound: x')
# plot stochastic representation
plt.subplot(3,1,2)
numFrames = int(stocEnv[:,0].size)
frmTime = H*np.arange(numFrames)/float(fs)
binFreq = np.arange(stocf*(N/2+1))*float(fs)/(stocf*N)
plt.pcolormesh(frmTime, binFreq, np.transpose(stocEnv))
plt.autoscale(tight=True)
plt.xlabel('time (sec)')
plt.ylabel('frequency (Hz)')
plt.title('stochastic approximation')
# plot the output sound
plt.subplot(3,1,3)
plt.plot(np.arange(y.size)/float(fs), y)
plt.axis([0, y.size/float(fs), min(y), max(y)])
plt.ylabel('amplitude')
plt.xlabel('time (sec)')
plt.tight_layout()
plt.show(block=False)
def hpsModelAnal(x, fs, w, N, H, t, nH, minf0, maxf0, f0et, harmDevSlope, minSineDur, Ns, stocf): """ Analysis of a sound using the harmonic plus stochastic model x: input sound, fs: sampling rate, w: analysis window; N: FFT size, 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), harmDevSlope: slope of harmonic deviation; minSineDur: minimum length of harmonics returns hfreq, hmag, hphase: harmonic frequencies, magnitude and phases; stocEnv: stochastic residual """ # perform harmonic analysis hfreq, hmag, hphase = HM.harmonicModelAnal(x, fs, w, N, H, t, nH, minf0, maxf0, f0et, harmDevSlope, minSineDur) # subtract sinusoids from original sound xr = UF.sineSubtraction(x, Ns, H, hfreq, hmag, hphase, fs) # perform stochastic analysis of residual stocEnv = STM.stochasticModelAnal(xr, H, H*2, stocf) return hfreq, hmag, hphase, stocEnv
def hpsModelAnal(x, fs, w, N, H, t, nH, minf0, maxf0, f0et, harmDevSlope, minSineDur, Ns, stocf): """ Analysis of a sound using the harmonic plus stochastic model x: input sound, fs: sampling rate, w: analysis window; N: FFT size, 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), harmDevSlope: slope of harmonic deviation; minSineDur: minimum length of harmonics returns hfreq, hmag, hphase: harmonic frequencies, magnitude and phases; stocEnv: stochastic residual """ # perform harmonic analysis hfreq, hmag, hphase = HM.harmonicModelAnal(x, fs, w, N, H, t, nH, minf0, maxf0, f0et, harmDevSlope, minSineDur) # subtract sinusoids from original sound xr = UF.sineSubtraction(x, Ns, H, hfreq, hmag, hphase, fs) # perform stochastic analysis of residual stocEnv = STM.stochasticModelAnal(xr, H, H*2, stocf) return hfreq, hmag, hphase, stocEnv
def spsModelAnal(x, fs, w, N, H, t, minSineDur, maxnSines, freqDevOffset, freqDevSlope, stocf): """ Analysis of a sound using the sinusoidal plus stochastic model x: input sound, fs: sampling rate, w: analysis window; N: FFT size, t: threshold in negative dB, minSineDur: minimum duration of sinusoidal tracks maxnSines: maximum number of parallel sinusoids freqDevOffset: frequency deviation allowed in the sinusoids from frame to frame at frequency 0 freqDevSlope: slope of the frequency deviation, higher frequencies have bigger deviation stocf: decimation factor used for the stochastic approximation returns hfreq, hmag, hphase: harmonic frequencies, magnitude and phases; stocEnv: stochastic residual """ # perform sinusoidal analysis tfreq, tmag, tphase = SM.sineModelAnal(x, fs, w, N, H, t, maxnSines, minSineDur, freqDevOffset, freqDevSlope) Ns = 512 xr = UF.sineSubtraction(x, Ns, H, tfreq, tmag, tphase, fs) # subtract sinusoids from original sound stocEnv = STM.stochasticModelAnal(xr, H, H*2, stocf) # compute stochastic model of residual return tfreq, tmag, tphase, stocEnv
def main(inputFile='../../sounds/ocean.wav', H=256, N=512, stocf=.1): """ inputFile: input sound file (monophonic with sampling rate of 44100) H: hop size, N: fft size stocf: decimation factor used for the stochastic approximation (bigger than 0, maximum 1) """ # read input sound (fs, x) = UF.wavread(inputFile) # compute stochastic model stocEnv = STM.stochasticModelAnal(x, H, N, stocf) # synthesize sound from stochastic model y = STM.stochasticModelSynth(stocEnv, H, N) outputFile = 'output_sounds/' + os.path.basename(inputFile)[:-4] + '_stochasticModel.wav' # write output sound UF.wavwrite(y, fs, outputFile) return x, fs, stocEnv, y
def spsModelAnal(x, fs, w, N, H, t, minSineDur, maxnSines, freqDevOffset,
freqDevSlope, stocf):
"""
Analysis of a sound using the sinusoidal plus stochastic model
x: input sound, fs: sampling rate, w: analysis window; N: FFT size, t: threshold in negative dB,
minSineDur: minimum duration of sinusoidal tracks
maxnSines: maximum number of parallel sinusoids
freqDevOffset: frequency deviation allowed in the sinusoids from frame to frame at frequency 0
freqDevSlope: slope of the frequency deviation, higher frequencies have bigger deviation
stocf: decimation factor used for the stochastic approximation
returns hfreq, hmag, hphase: harmonic frequencies, magnitude and phases; stocEnv: stochastic residual
"""
# perform sinusoidal analysis
tfreq, tmag, tphase = SM.sineModelAnal(x, fs, w, N, H, t, maxnSines,
minSineDur, freqDevOffset,
freqDevSlope)
Ns = N #512
xr = UF.sineSubtraction(x, Ns, H, tfreq, tmag, tphase,
fs) # subtract sinusoids from original sound
#stocEnv = STM.stochasticModelAnal(xr, H, H*2, stocf) # compute stochastic model of residual
stocEnv = STM.stochasticModelAnal(xr, H, N, stocf)
return tfreq, tmag, tphase, stocEnv
def extractHarmSpec(inputFile='../../sounds/rain.wav',
stocf=0.1,
timeScaling=np.array([0, 0, 1, 2])):
"""
function to perform a time scaling using the stochastic model
inputFile: name of input sound file
stocf: decimation factor used for the stochastic approximation
timeScaling: time scaling factors, in time-value pairs
"""
# hop size
H = 128
# read input sound
(fs, x) = UF.wavread(inputFile)
# perform stochastic analysis
mYst = STC.stochasticModelAnal(x, H, H * 2, stocf)
# perform time scaling of stochastic representation
ystocEnv = STCT.stochasticTimeScale(mYst, timeScaling)
# synthesize output sound
y = STC.stochasticModelSynth(ystocEnv, H, H * 2)
# write output sound
outputFile = 'output_sounds/' + os.path.basename(
inputFile)[:-4] + '_stochasticModelTransformation.wav'
UF.wavwrite(y, fs, outputFile)
# create figure to plot
plt.figure(figsize=(12, 9))
# plot the input sound
plt.subplot(4, 1, 1)
plt.plot(np.arange(x.size) / float(fs), x)
plt.axis([0, x.size / float(fs), min(x), max(x)])
plt.ylabel('amplitude')
plt.xlabel('time (sec)')
plt.title('input sound: x')
# plot stochastic representation
plt.subplot(4, 1, 2)
numFrames = int(mYst[:, 0].size)
frmTime = H * np.arange(numFrames) / float(fs)
binFreq = np.arange(stocf * H) * float(fs) / (stocf * 2 * H)
plt.pcolormesh(frmTime, binFreq, np.transpose(mYst))
plt.autoscale(tight=True)
plt.xlabel('time (sec)')
plt.ylabel('frequency (Hz)')
plt.title('stochastic approximation')
# plot modified stochastic representation
plt.subplot(4, 1, 3)
numFrames = int(ystocEnv[:, 0].size)
frmTime = H * np.arange(numFrames) / float(fs)
binFreq = np.arange(stocf * H) * float(fs) / (stocf * 2 * H)
plt.pcolormesh(frmTime, binFreq, np.transpose(ystocEnv))
plt.autoscale(tight=True)
plt.xlabel('time (sec)')
plt.ylabel('frequency (Hz)')
plt.title('modified stochastic approximation')
# plot the output sound
plt.subplot(4, 1, 4)
plt.plot(np.arange(y.size) / float(fs), y)
plt.axis([0, y.size / float(fs), min(y), max(y)])
plt.ylabel('amplitude')
plt.xlabel('time (sec)')
plt.tight_layout()
plt.show()
import stftTransformations as STFTT
import stochasticModel as STOC
import math
import stft as STFT
(fs, x1) = UF.wavread('../../../sounds/orchestra.wav')
(fs, x2) = UF.wavread('../../../sounds/speech-male.wav')
w1 = np.hamming(1024)
N1 = 1024
H1 = 256
w2 = np.hamming(1024)
N2 = 1024
smoothf = .2
balancef = 0.5
y = STFTT.stftMorph(x1, x2, fs, w1, N1, w2, N2, H1, smoothf, balancef)
mX2 = STOC.stochasticModelAnal(x2, H1, H1 * 2, smoothf)
mX, pX = STFT.stftAnal(x1, fs, w1, N1, H1)
mY, pY = STFT.stftAnal(y, fs, w1, N1, H1)
maxplotfreq = 10000.0
plt.figure(1, figsize=(12, 9))
plt.subplot(311)
numFrames = int(mX[:, 0].size)
frmTime = H1 * np.arange(numFrames) / float(fs)
binFreq = fs * np.arange(N1 * maxplotfreq / fs) / N1
plt.pcolormesh(frmTime, binFreq,
np.transpose(mX[:, :N1 * maxplotfreq / fs + 1]))
plt.title('mX (orchestra.wav)')
plt.autoscale(tight=True)
plt.subplot(312)
from scipy.fftpack import fft, ifft
import time
import sys, os
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), '../../../software/models/'))
import utilFunctions as UF
import stochasticModel as STM
import stft as STFT
(fs, x) = UF.wavread('../../../sounds/ocean.wav')
w = np.hamming(512)
N = 512
H = 256
stocf = .1
mYst = STM.stochasticModelAnal(x, H, N, stocf)
y = STM.stochasticModelSynth(mYst, H, N)
mX, pX = STFT.stftAnal(x, w, N, H)
plt.figure(1, figsize=(9, 7))
plt.subplot(411)
plt.plot(np.arange(x.size)/float(fs), x,'b')
plt.title('x (ocean.wav)')
plt.axis([0,x.size/float(fs),min(x),max(x)])
plt.subplot(412)
numFrames = int(mX[:,0].size)
frmTime = H*np.arange(numFrames)/float(fs)
binFreq = np.arange(mX[0,:].size)*float(fs)/N
plt.pcolormesh(frmTime, binFreq, np.transpose(mX))
plt.title('mX; M=512, N=512, H=256')
import sys, os
sys.path.append(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'../../../software/models/'))
import utilFunctions as UF
import stochasticModel as STM
import stft as STFT
(fs, x) = UF.wavread('../../../sounds/ocean.wav')
w = np.hamming(512)
N = 512
H = 256
stocf = .1
mYst = STM.stochasticModelAnal(x, H, N, stocf)
y = STM.stochasticModelSynth(mYst, H, N)
mX, pX = STFT.stftAnal(x, w, N, H)
plt.figure(1, figsize=(9, 7))
plt.subplot(411)
plt.plot(np.arange(x.size) / float(fs), x, 'b')
plt.title('x (ocean.wav)')
plt.axis([0, x.size / float(fs), min(x), max(x)])
plt.subplot(412)
numFrames = int(mX[:, 0].size)
frmTime = H * np.arange(numFrames) / float(fs)
binFreq = np.arange(mX[0, :].size) * float(fs) / N
plt.pcolormesh(frmTime, binFreq, np.transpose(mX))
plt.title('mX; M=512, N=512, H=256')
import sys, os
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), '../software/models/'))
import utilFunctions as UF
import stochasticModel as STM
(fs, x) = UF.wavread("../../sounds/ocean.wav")
H = 128
stocf = .2
stocEnv = STM.stochasticModelAnal(x, H, H*2, stocf)
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), "../models/"))
import stochasticModel as STC
import utilFunctions as UF
def stochasticTimeScale(stocEnv, timeScaling):
# time scaling of the stochastic representation of a sound
# stocEnv: stochastic envelope
# timeScaling: scaling factors, in time-value pairs
# returns ystocEnv: stochastic envelope
L = stocEnv[:, 0].size # number of input frames
outL = int(L * timeScaling[-1] / timeScaling[-2]) # number of synthesis frames
timeScalingEnv = interp1d(timeScaling[::2] / timeScaling[-2], timeScaling[1::2] / timeScaling[-1])
indexes = (L - 1) * timeScalingEnv(np.arange(outL) / float(outL))
ystocEnv = stocEnv[0, :] # first output frame is same than input
for l in indexes[1:]:
ystocEnv = np.vstack((ystocEnv, stocEnv[round(l), :]))
return ystocEnv
if __name__ == "__main__":
(fs, x) = UF.wavread(os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../sounds/rain.wav"))
H = 256
stocf = 0.2
mYst = STC.stochasticModelAnal(x, H, stocf)
timeScaling = np.array([0, 0, 1, 2])
ystocEnv = stochasticTimeScale(mYst, timeScaling)
y = STC.stochasticModelSynth(ystocEnv, H)
UF.play(y, fs)
def main (inputFile='../../sounds/rain.wav', stocf=0.1, timeScaling = np.array([0, 0, 1, 2])):
"""
function to perform a time scaling using the stochastic model
inputFile: name of input sound file
stocf: decimation factor used for the stochastic approximation
timeScaling: time scaling factors, in time-value pairs
"""
# hop size
H = 128
# read input sound
(fs, x) = UF.wavread(inputFile)
# perform stochastic analysis
mYst = STC.stochasticModelAnal(x, H, H*2, stocf)
# perform time scaling of stochastic representation
ystocEnv = STCT.stochasticTimeScale(mYst, timeScaling)
# synthesize output sound
y = STC.stochasticModelSynth(ystocEnv, H, H*2)
# write output sound
outputFile = 'output_sounds/' + os.path.basename(inputFile)[:-4] + '_stochasticModelTransformation.wav'
UF.wavwrite(y, fs, outputFile)
# create figure to plot
plt.figure(figsize=(12, 9))
# plot the input sound
plt.subplot(4,1,1)
plt.plot(np.arange(x.size)/float(fs), x)
plt.axis([0, x.size/float(fs), min(x), max(x)])
plt.ylabel('amplitude')
plt.xlabel('time (sec)')
plt.title('input sound: x')
# plot stochastic representation
plt.subplot(4,1,2)
numFrames = int(mYst[:,0].size)
frmTime = H*np.arange(numFrames)/float(fs)
binFreq = np.arange(stocf*H)*float(fs)/(stocf*2*H)
plt.pcolormesh(frmTime, binFreq, np.transpose(mYst))
plt.autoscale(tight=True)
plt.xlabel('time (sec)')
plt.ylabel('frequency (Hz)')
plt.title('stochastic approximation')
# plot modified stochastic representation
plt.subplot(4,1,3)
numFrames = int(ystocEnv[:,0].size)
frmTime = H*np.arange(numFrames)/float(fs)
binFreq = np.arange(stocf*H)*float(fs)/(stocf*2*H)
plt.pcolormesh(frmTime, binFreq, np.transpose(ystocEnv))
plt.autoscale(tight=True)
plt.xlabel('time (sec)')
plt.ylabel('frequency (Hz)')
plt.title('modified stochastic approximation')
# plot the output sound
plt.subplot(4,1,4)
plt.plot(np.arange(y.size)/float(fs), y)
plt.axis([0, y.size/float(fs), min(y), max(y)])
plt.ylabel('amplitude')
plt.xlabel('time (sec)')
plt.tight_layout()
plt.show()
import sys, os
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), '../software/models/'))
import utilFunctions as UF
import stochasticModel as STM
# Read input sound
(fs, x) = UF.wavread('../sounds/ocean.wav')
# Compute stochastic model
H = 128
stocf = .2
stocEnv = STM.stochasticModelAnal(x, H, H*2, stocf)
# Synthesize sound from stochastic model
y = STM.stochasticModelSynth(stocEnv, H, N)
import stftTransformations as STFTT
import stochasticModel as STOC
import math
import stft as STFT
(fs, x1) = UF.wavread('../../../sounds/orchestra.wav')
(fs, x2) = UF.wavread('../../../sounds/speech-male.wav')
w1 = np.hamming(1024)
N1 = 1024
H1 = 256
w2 = np.hamming(1024)
N2 = 1024
smoothf = .2
balancef = 0.5
y = STFTT.stftMorph(x1, x2, fs, w1, N1, w2, N2, H1, smoothf, balancef)
mX2 = STOC.stochasticModelAnal(x2,H1,H1*2, smoothf)
mX,pX = STFT.stftAnal(x1, w1, N1, H1)
mY,pY = STFT.stftAnal(y, w1, N1, H1)
maxplotfreq = 10000.0
plt.figure(1, figsize=(12, 9))
plt.subplot(311)
numFrames = int(mX[:,0].size)
frmTime = H1*np.arange(numFrames)/float(fs)
binFreq = fs*np.arange(N1*maxplotfreq/fs)/N1
plt.pcolormesh(frmTime, binFreq, np.transpose(mX[:,:int(N1*maxplotfreq/fs+1)]))
plt.title('mX (orchestra.wav)')
plt.autoscale(tight=True)
plt.subplot(312)
numFrames = int(mX2[:,0].size)
def main(
inputFile="../../sounds/bendir.wav",
window="hamming",
M=2001,
N=2048,
t=-80,
minSineDur=0.02,
maxnSines=150,
freqDevOffset=10,
freqDevSlope=0.001,
stocf=0.2,
):
# ------- analysis parameters -------------------
# inputFile: input sound file (monophonic with sampling rate of 44100)
# window: analysis window type (rectangular, hanning, hamming, blackman, blackmanharris)
# M: analysis window size
# N: fft size (power of two, bigger or equal than M)
# t: magnitude threshold of spectral peaks
# minSineDur: minimum duration of sinusoidal tracks
# maxnSines: maximum number of parallel sinusoids
# freqDevOffset: frequency deviation allowed in the sinusoids from frame to frame at frequency 0
# freqDevSlope: slope of the frequency deviation, higher frequencies have bigger deviation
# stocf: decimation factor used for the stochastic approximation
# size of fft used in synthesis
Ns = 512
# hop size (has to be 1/4 of Ns)
H = 128
# --------- computation -----------------
# read input sound
(fs, x) = UF.wavread(inputFile)
# compute analysis window
w = get_window(window, M)
# perform sinusoidal analysis
tfreq, tmag, tphase = SM.sineModelAnal(x, fs, w, N, H, t, maxnSines, minSineDur, freqDevOffset, freqDevSlope)
# subtract sinusoids from original sound
Ns = 512
xr = UF.sineSubtraction(x, Ns, H, tfreq, tmag, tphase, fs)
# compute stochastic model of residual
mYst = STM.stochasticModelAnal(xr, H, stocf)
# synthesize sinusoids
ys = SM.sineModelSynth(tfreq, tmag, tphase, Ns, H, fs)
# synthesize stochastic component
yst = STM.stochasticModelSynth(mYst, H)
# sum sinusoids and stochastic
y = yst[: min(yst.size, ys.size)] + ys[: min(yst.size, ys.size)]
# output sound file (monophonic with sampling rate of 44100)
outputFileSines = "output_sounds/" + os.path.basename(inputFile)[:-4] + "_spsModel_sines.wav"
outputFileStochastic = "output_sounds/" + os.path.basename(inputFile)[:-4] + "_spsModel_stochastic.wav"
outputFile = "output_sounds/" + os.path.basename(inputFile)[:-4] + "_spsModel.wav"
# write sounds files for sinusoidal, residual, and the sum
UF.wavwrite(ys, fs, outputFileSines)
UF.wavwrite(yst, fs, outputFileStochastic)
UF.wavwrite(y, fs, outputFile)
# --------- plotting --------------------
# plot stochastic component
plt.figure(figsize=(12, 9))
# frequency range to plot
maxplotfreq = 10000.0
# plot the input sound
plt.subplot(3, 1, 1)
plt.plot(np.arange(x.size) / float(fs), x)
plt.axis([0, x.size / float(fs), min(x), max(x)])
plt.ylabel("amplitude")
plt.xlabel("time (sec)")
plt.title("input sound: x")
plt.subplot(3, 1, 2)
numFrames = int(mYst[:, 0].size)
sizeEnv = int(mYst[0, :].size)
frmTime = H * np.arange(numFrames) / float(fs)
binFreq = (0.5 * fs) * np.arange(sizeEnv * maxplotfreq / (0.5 * fs)) / sizeEnv
plt.pcolormesh(frmTime, binFreq, np.transpose(mYst[:, : sizeEnv * maxplotfreq / (0.5 * fs) + 1]))
plt.autoscale(tight=True)
# plot sinusoidal frequencies on top of stochastic component
sines = tfreq * np.less(tfreq, maxplotfreq)
sines[sines == 0] = np.nan
numFrames = int(sines[:, 0].size)
frmTime = H * np.arange(numFrames) / float(fs)
plt.plot(frmTime, sines, color="k", ms=3, alpha=1)
plt.xlabel("time(s)")
plt.ylabel("Frequency(Hz)")
plt.autoscale(tight=True)
plt.title("sinusoidal + stochastic spectrogram")
# plot the output sound
plt.subplot(3, 1, 3)
plt.plot(np.arange(y.size) / float(fs), y)
plt.axis([0, y.size / float(fs), min(y), max(y)])
plt.ylabel("amplitude")
plt.xlabel("time (sec)")
plt.title("output sound: y")
plt.tight_layout()
plt.show()
