def getKritiStartBoundary(onsFn,onsTs):
logger = log.get_logger("rhythm")
logger.info('Obtaining Start of piece boundary...')
peakLocs, peakVals = findpeaks(onsFn, imode = 'n', pmode = 'p', wdTol = 0, ampTol = 0.4, prominence = 10.0)
offsetIndex = peakLocs[0]
offsetIndex = getNearestIndex(onsTs[offsetIndex]-3.0,onsTs) # Start three seconds
return offsetIndex
def getKritiStartBoundary(onsFn, onsTs):
logger = log.get_logger("rhythm")
logger.info('Obtaining Start of piece boundary...')
peakLocs, peakVals = findpeaks(onsFn, imode='n', pmode='p', wdTol=0, ampTol=0.4, prominence=10.0)
offsetIndex = peakLocs[0]
offsetIndex = getNearestIndex(onsTs[offsetIndex] - 3.0, onsTs) # Start three seconds
return offsetIndex
def DPSearch(cands,param):
logger = log.get_logger("rhythm")
logger.info('Searching through candidates...')
TM = (cands.TransMatCausal).copy()
ts = (cands.ts).copy()
pers = (cands.pers).copy()
Locs = (cands.Locs).copy()
D,N = TM.shape
if D != N:
print "Transition Matrix not square!!!!"
return -1
backlink = -np.ones(Locs.size)
cumscore = (cands.Wts).copy()
startIndex = getNearestIndex(param.backSearch[0]*pers.max(),ts) + 1
for t in range(startIndex,cumscore.size):
startSearch = getNearestIndex(ts[t]-pers[t]*param.backSearch[0],ts)
endSearch = getNearestIndex(ts[t]-pers[t]*param.backSearch[1],ts)
timerange = range(startSearch,endSearch+1);
scorecands = cumscore[timerange] + param.alphaDP*TM[timerange,t]; # CAUTION, See the 100!
val = scorecands.max()
Ind = scorecands.argmax()
cumscore[t] = val + cands.Wts[t];
backlink[t] = timerange[Ind];
pass
# Backtrace
aksharaLocs = np.array([cumscore.argmax()]).astype(int)
while ((backlink[aksharaLocs[0]] > 0) and (aksharaLocs.size < N)):
aksharaLocs = np.append(backlink[aksharaLocs[0]],aksharaLocs)
aksharaLocs = aksharaLocs.astype(int)
aksharaTimes = ts[aksharaLocs]
return aksharaLocs, aksharaTimes
def PreProcessAudio(fname):
'''
Pre-process data so that an audio file can be input. Right now, just does nothing. No preprocessing done
'''
logger = log.get_logger("rhythm")
logger.info('Pre-processing audio... [Nothing for now]')
return True
def getMatraPeriodEstimateFromTC(TCper, tcparams):
logger = log.get_logger("rhythm")
logger.info('Computing akshara pulse period...')
histFn, binEdges = np.histogram(TCper, tcparams.Nbins,
(0.0, 60.0 / tcparams.minBPM))
binCentres = np.zeros(histFn.size)
for p in range(histFn.size):
binCentres[p] = (binEdges[p] + binEdges[p + 1]) / 2.0
wtol = int(tcparams.wtolHistAv)
peaks, peakVals = findpeaks(histFn,
imode='n',
pmode='p',
wdTol=wtol + 1.0,
ampTol=0.0,
prominence=1e-6)
sortInd = np.argsort(-peakVals)
topHistBins = peaks[sortInd]
kk, = (topHistBins > (histFn.size - wtol - 1)).nonzero()
topHistBins = np.delete(topHistBins, kk)
kk, = (topHistBins < (wtol + 1)).nonzero()
topHistBins = np.delete(topHistBins, kk)
topHistBins = (topHistBins[0]).copy()
topHistBins = topHistBins.astype(int)
indRange = range(topHistBins - wtol - 1, topHistBins + wtol)
wdw = (binCentres[indRange]).copy()
wdwWts = (histFn[indRange]).copy()
wdwWts = wdwWts.astype(float)
wdwWts = wdwWts / wdwWts.sum()
matraEst = (wdw * wdwWts).sum()
return matraEst
def estimateAksharaCandidates(tstamps,onsFn,TCper,TCts,medIAI,akParams):
logger = log.get_logger("rhythm")
logger.info('Estimating akshara candidates...')
ts = tstamps[1] - tstamps[0]
medIAISamp = medIAI/ts
wtolPeaks = np.floor(akParams.pwtol*medIAISamp)
peakLocs, peakVals = findpeaks(onsFn, imode = 'q', pmode = 'p', wdTol = wtolPeaks, ampTol = akParams.thres)
# We get time ordered peaks
Npeaks = peakLocs.size
tPeaks = ts*peakLocs
transMat = np.zeros((Npeaks,Npeaks))
akPers = np.round(TCper[getNearestIndices(tPeaks,TCts)]/ts)
for k in range(peakLocs.size):
distVals = np.abs(peakLocs[k] - peakLocs)/akPers[k]
farAwayParam = np.floor(distVals)
dtVals = distVals - farAwayParam
iind, = (dtVals > 0.5).nonzero()
dtVals[iind] = 1.0 - dtVals[iind]
closeIndices, = (np.abs(peakLocs[k]-peakLocs) < akParams.ignoreTooClose*medIAISamp).nonzero()
farAwayParam[closeIndices] = 100.0 # Arbitrarily large
transMat[k,:] = np.exp(-(farAwayParam-1)/akParams.decayCoeff)*scistats.norm.pdf(dtVals,0,0.1)
transMat[k,:] = transMat[k,:]/(transMat[k,:]).sum()
pass
akCandLocs = peakLocs
akCandTs = tPeaks
akCandWts = peakVals
akCandTransMat = transMat
return akCandLocs, akCandTs, akCandWts, akCandTransMat
def estimateAksharaCandidates(tstamps, onsFn, TCper, TCts, medIAI, akParams):
logger = log.get_logger("rhythm")
logger.info('Estimating akshara candidates...')
ts = tstamps[1] - tstamps[0]
medIAISamp = medIAI / ts
wtolPeaks = np.floor(akParams.pwtol * medIAISamp)
peakLocs, peakVals = findpeaks(onsFn,
imode='q',
pmode='p',
wdTol=wtolPeaks,
ampTol=akParams.thres)
# We get time ordered peaks
Npeaks = peakLocs.size
tPeaks = ts * peakLocs
transMat = np.zeros((Npeaks, Npeaks))
akPers = np.round(TCper[getNearestIndices(tPeaks, TCts)] / ts)
for k in range(peakLocs.size):
distVals = np.abs(peakLocs[k] - peakLocs) / akPers[k]
farAwayParam = np.floor(distVals)
dtVals = distVals - farAwayParam
iind, = (dtVals > 0.5).nonzero()
dtVals[iind] = 1.0 - dtVals[iind]
closeIndices, = (np.abs(peakLocs[k] - peakLocs) <
akParams.ignoreTooClose * medIAISamp).nonzero()
farAwayParam[closeIndices] = 100.0 # Arbitrarily large
transMat[k, :] = np.exp(
-(farAwayParam - 1) / akParams.decayCoeff) * scistats.norm.pdf(
dtVals, 0, 0.1)
transMat[k, :] = transMat[k, :] / (transMat[k, :]).sum()
pass
akCandLocs = peakLocs
akCandTs = tPeaks
akCandWts = peakVals
akCandTransMat = transMat
return akCandLocs, akCandTs, akCandWts, akCandTransMat
def DPSearch(cands, param):
logger = log.get_logger("rhythm")
logger.info('Searching through candidates...')
TM = (cands.TransMatCausal).copy()
ts = (cands.ts).copy()
pers = (cands.pers).copy()
Locs = (cands.Locs).copy()
D, N = TM.shape
if D != N:
print("Transition Matrix not square!!!!")
return -1
backlink = -np.ones(Locs.size)
cumscore = (cands.Wts).copy()
startIndex = getNearestIndex(param.backSearch[0] * pers.max(), ts) + 1
for t in range(startIndex, cumscore.size):
startSearch = getNearestIndex(ts[t] - pers[t] * param.backSearch[0],
ts)
endSearch = getNearestIndex(ts[t] - pers[t] * param.backSearch[1], ts)
timerange = range(startSearch, endSearch + 1)
scorecands = cumscore[timerange] + param.alphaDP * TM[timerange, t]
# CAUTION, See the 100!
val = scorecands.max()
Ind = scorecands.argmax()
cumscore[t] = val + cands.Wts[t]
backlink[t] = timerange[Ind]
pass
# Backtrace
aksharaLocs = np.array([cumscore.argmax()]).astype(int)
while ((backlink[aksharaLocs[0]] > 0) and (aksharaLocs.size < N)):
aksharaLocs = np.append(backlink[aksharaLocs[0]], aksharaLocs)
aksharaLocs = aksharaLocs.astype(int)
aksharaTimes = ts[aksharaLocs]
return aksharaLocs, aksharaTimes
def PreProcessAudio(fname):
'''
Pre-process data so that an audio file can be input. Right now, just does nothing. No preprocessing done
'''
logger = log.get_logger("rhythm")
logger.info('Pre-processing audio... [Nothing for now]')
return True
def compute_fourierCoefficients(s,win,noverlap,f,fs):
logger = log.get_logger("rhythm")
winLen = win.size
hopSize = winLen - noverlap
T = np.arange(0,winLen,1)/fs
winNum = np.fix((s.size-noverlap)/(winLen-noverlap));
x = np.zeros((winNum,f.size))
x = x.astype(complex)
t = np.arange(winLen/2.0,s.size-winLen/2.0,hopSize)/fs;
twoPiT = 2.0*math.pi*T;
for f0 in range(f.size):
twoPiFt = f[f0]*twoPiT
cosine_fn = np.cos(twoPiFt)
sine_fn = np.sin(twoPiFt)
for w in range(winNum):
start = w*hopSize.astype(int)
stop = start + winLen
sig = s[range(start,stop)] * win
co = (sig*cosine_fn).sum()
si = (sig*sine_fn).sum()
x[w,f0] = co + 1j*si
if not np.mod(f0,100):
logger.info(str(f0) + '/' + str(f.size) + '...')
x = x.transpose()
return x,f,t
def compute_fourierCoefficients(s, win, noverlap, f, fs):
logger = log.get_logger("rhythm")
winLen = win.size
hopSize = winLen - noverlap
T = np.arange(0, winLen, 1) / fs
winNum = np.fix((s.size - noverlap) / (winLen - noverlap))
x = np.zeros((winNum, f.size))
x = x.astype(complex)
t = np.arange(winLen / 2.0, s.size - winLen / 2.0, hopSize) / fs
twoPiT = 2.0 * math.pi * T
for f0 in range(f.size):
twoPiFt = f[f0] * twoPiT
cosine_fn = np.cos(twoPiFt)
sine_fn = np.sin(twoPiFt)
for w in range(winNum):
start = w * hopSize.astype(int)
stop = start + winLen
sig = s[range(start, stop)] * win
co = (sig * cosine_fn).sum()
si = (sig * sine_fn).sum()
x[w, f0] = co + 1j * si
if not np.mod(f0, 100):
logger.info(str(f0) + '/' + str(f.size) + '...')
x = x.transpose()
return x, f, t
def __init__(self, **kwargs):
"""Set up the logger, and run a setup method if it's been defined."""
self.logger = log.get_logger(self._slug, self._version)
self.settings = Settings()
self.add_settings(**kwargs)
self.setup()
self.redis = None
if "redis_host" in self.settings and 'redis' in globals():
self.redis = redis.StrictRedis(host=self.settings["redis_host"])
# This cache is used for a single process when redis is not installed
self.cache = {}
def __init__(self, **kwargs):
"""Set up the logger, and run a setup method if it's been defined."""
self.logger = log.get_logger(self._slug, self._version)
self.settings = Settings()
self.add_settings(**kwargs)
self.setup()
self.redis = None
if "redis_host" in self.settings and 'redis' in globals():
self.redis = redis.StrictRedis(host=self.settings["redis_host"])
# This cache is used for a single process when redis is not installed
self.cache = {}
def getOnsetFunctions(fname):
logger = log.get_logger("rhythm")
zeropadLen = params.Nfft - params.frmSize
zz = np.zeros((zeropadLen, ), dtype='float32')
frameCounter = 0
bufferFrame = np.zeros((params.Nfft / 2 + 1, ))
logger.info('Reading audio file...')
audio = ess.MonoLoader(filename=fname)()
fft = ess.FFT(size=params.Nfft) # this gives us a complex FFT
c2p = ess.CartesianToPolar(
) # and this turns it into a pair (magnitude, phase)
pool = es.Pool()
w = ess.Windowing(type="hamming")
fTicks = params.fTicks
poolName = 'features.flux'
logger.info('Extracting Onset functions...')
for frame in ess.FrameGenerator(audio,
frameSize=params.frmSize,
hopSize=params.hop):
frmTime = params.hop / params.Fs * frameCounter + params.frmSize / (
2.0 * params.Fs)
zpFrame = np.hstack((frame, zz))
mag, phase, = c2p(fft(w(zpFrame)))
magFlux = mag - bufferFrame
bufferFrame = np.copy(
mag) # Copying for the next iteration to compute flux
for bands in range(params.numBands):
chosenInd = (fTicks >= params.fBands[bands, 0]) & (
fTicks <= params.fBands[bands, 1])
magFluxBand = magFlux[chosenInd]
magFluxBand = (magFluxBand + abs(magFluxBand)) / 2
oFn = magFluxBand.sum()
if (math.isnan(oFn)):
print("NaN found here")
pass
pool.add(poolName + str(bands), oFn)
pass
pool.add('features.time', frmTime)
frameCounter += 1
if not np.mod(frameCounter, 10000):
logger.info(
str(frameCounter) + '/' + str(audio.size / params.hop) + '...')
logger.info('Total frames processed = ' + str(frameCounter))
timeStamps = es.array([pool['features.time']])
all_feat = timeStamps
for bands in range(params.numBands):
feat_flux = es.array([pool[poolName + str(bands)]])
all_feat = np.vstack((all_feat, feat_flux))
pass
return np.transpose(all_feat)
def tempogram_viaDFT(fn,param):
logger = log.get_logger("rhythm")
logger.info('Computing Tempogram...')
winLen = np.round(param.tempoWindow*param.featureRate)
winLen = winLen + np.mod(winLen,2) - 1
window = hanning(winLen)
ggk = np.zeros(np.round(winLen/2.0))
novelty = np.append(ggk, fn.copy())
novelty = np.append(novelty, ggk)
TG, BPM, T = compute_fourierCoefficients(novelty,window,winLen-param.stepsize, param.BPM/60.0, param.featureRate)
BPM = BPM*60.0
T = T - T[0]
tempogram = TG/math.sqrt(winLen) / sum(window) * winLen;
return tempogram, T, BPM
def tempogram_viaDFT(fn, param):
logger = log.get_logger("rhythm")
logger.info('Computing Tempogram...')
winLen = np.round(param.tempoWindow * param.featureRate)
winLen = winLen + np.mod(winLen, 2) - 1
window = hanning(winLen)
ggk = np.zeros(np.round(winLen / 2.0))
novelty = np.append(ggk, fn.copy())
novelty = np.append(novelty, ggk)
TG, BPM, T = compute_fourierCoefficients(novelty, window, winLen - param.stepsize, param.BPM / 60.0,
param.featureRate)
BPM = BPM * 60.0
T = T - T[0]
tempogram = TG / math.sqrt(winLen) / sum(window) * winLen;
return tempogram, T, BPM
def getOnsetFunctions(fname):
logger = log.get_logger("rhythm")
zeropadLen = params.Nfft - params.frmSize
zz = np.zeros((zeropadLen,),dtype = 'float32')
frameCounter = 0
bufferFrame = np.zeros((params.Nfft/2+1,))
logger.info('Reading audio file...')
audio = ess.MonoLoader(filename = fname)()
fft = ess.FFT(size = params.Nfft) # this gives us a complex FFT
c2p = ess.CartesianToPolar() # and this turns it into a pair (magnitude, phase)
pool = es.Pool()
w = ess.Windowing(type = "hamming")
fTicks = params.fTicks
poolName ='features.flux'
logger.info('Extracting Onset functions...')
for frame in ess.FrameGenerator(audio, frameSize = params.frmSize, hopSize = params.hop):
frmTime = params.hop/params.Fs*frameCounter + params.frmSize/(2.0*params.Fs)
zpFrame = np.hstack((frame,zz))
mag, phase, = c2p(fft(w(zpFrame)))
magFlux = mag - bufferFrame
bufferFrame = np.copy(mag) # Copying for the next iteration to compute flux
for bands in range(params.numBands):
chosenInd = (fTicks >= params.fBands[bands,0]) & (fTicks <= params.fBands[bands,1])
magFluxBand = magFlux[chosenInd]
magFluxBand = (magFluxBand + abs(magFluxBand))/2
oFn = magFluxBand.sum()
if (math.isnan(oFn)):
print "NaN found here"
pass
pool.add(poolName + str(bands), oFn)
pass
pool.add('features.time', frmTime);
frameCounter += 1
if not np.mod(frameCounter,10000):
logger.info(str(frameCounter) + '/' + str(audio.size/params.hop) + '...')
logger.info('Total frames processed = ' + str(frameCounter))
timeStamps = es.array([ pool['features.time'] ])
all_feat = timeStamps
for bands in range(params.numBands):
feat_flux = es.array([ pool[poolName + str(bands)] ])
all_feat = np.vstack((all_feat,feat_flux))
pass
return np.transpose(all_feat)
def correctOctaveErrors(x, per, tol):
logger = log.get_logger("rhythm")
logger.info('Correcting octave errors in IAI estimation...')
y = x.copy()
flag = np.zeros(x.size)
for k in range(x.size):
if ((np.abs(x[k] - per) / per) > tol):
if isScaleRelated(x[k], per, tol / 2.0):
if x[k] > per:
scale = np.round(x[k] / per)
y[k] = x[k] / scale
flag[k] = 1.0
else:
scale = np.round(per / x[k])
y[k] = x[k] * scale
flag[k] = 1.0
else:
y[k] = per
flag[k] = -1
pass
pass
pass
return y, flag
def correctOctaveErrors(x,per,tol):
logger = log.get_logger("rhythm")
logger.info('Correcting octave errors in IAI estimation...')
y = x.copy()
flag = np.zeros(x.size)
for k in range(x.size):
if ((np.abs(x[k]-per)/per) > tol):
if isScaleRelated(x[k],per,tol/2.0):
if x[k] > per:
scale = np.round(x[k]/per)
y[k] = x[k]/scale
flag[k] = 1.0
else:
scale = np.round(per/x[k])
y[k] = x[k]*scale
flag[k] = 1.0
else:
y[k] = per
flag[k] = -1
pass
pass
pass
return y,flag
def getMatraPeriodEstimateFromTC(TCper,tcparams):
logger = log.get_logger("rhythm")
logger.info('Computing akshara pulse period...')
histFn, binEdges = np.histogram(TCper,tcparams.Nbins,(0.0,60.0/tcparams.minBPM))
binCentres = np.zeros(histFn.size)
for p in range(histFn.size):
binCentres[p] = (binEdges[p] + binEdges[p+1])/2.0
wtol = int(tcparams.wtolHistAv)
peaks, peakVals = findpeaks(histFn, imode = 'n', pmode = 'p', wdTol = wtol+1.0, ampTol = 0.0, prominence = 1e-6)
sortInd = np.argsort(-peakVals)
topHistBins = peaks[sortInd]
kk, = (topHistBins > (histFn.size - wtol - 1)).nonzero()
topHistBins = np.delete(topHistBins,kk)
kk, = (topHistBins < (wtol+1)).nonzero()
topHistBins = np.delete(topHistBins,kk)
topHistBins = (topHistBins[0]).copy()
topHistBins = topHistBins.astype(int)
indRange = range(topHistBins-wtol-1,topHistBins+wtol)
wdw = (binCentres[indRange]).copy()
wdwWts = (histFn[indRange]).copy()
wdwWts = wdwWts.astype(float)
wdwWts = wdwWts/wdwWts.sum()
matraEst = (wdw*wdwWts).sum()
return matraEst
def getTempoCurve(tg,tcparams):
'''
% Given the tempogram, it returns the best tempo curve using DP
% tempoGram is a DxN Tempogram matrix computed with D tempo values and N time instances
% params - parameter structure with following fields
% params.BPM (Dx1) = BPM at which the tempogram was computed. Note that params.BPM(1)
% corresponds to tempoGram(1,:)
% params.ts (1xN) = time stamps at which the tempogram was computed
% params.theta (1x1) = smoothing parameter, higher the value, more smooth
% is the curve. Set theta = 0 for a maximum vote tempo across time
'''
logger = log.get_logger("rhythm")
logger.info('Computing IAI curve...')
(D,N) = tg.shape
DP = np.zeros(tg.shape)
pIndex = np.zeros(tg.shape)
DP[:,0] = tg[:,0]
ind, = (tcparams.BPM<tcparams.minBPM).nonzero()
tg[ind,:] = -1000000.0;
BPMCOl = (tcparams.BPM).reshape(((tcparams.BPM).size,1))
xx = np.arange(-tcparams.octTol,tcparams.octTol+1)
penalGaussian = scistats.norm.pdf(xx,0,tcparams.octTol/3)
penalGaussian = penalGaussian.reshape((penalGaussian.size,1))
penalGaussian = penalGaussian/(penalGaussian.max())
for i in range(1,N):
for jj in range(D):
# Octave jumps to be penalized
penalArray = np.zeros((D,1))
# Lower octave first
if (tcparams.BPM[jj]/2.0 > tcparams.BPM[0]):
octLow = getNearestIndex(tcparams.BPM[jj]/2.0,tcparams.BPM)
if octLow <= tcparams.octTol:
gg = np.arange(octLow+tcparams.octTol)
gg = gg.astype(int)
penalArray[gg,:] = penalGaussian[-gg.size:]
else:
gg = np.arange(octLow-tcparams.octTol,octLow+tcparams.octTol+1)
gg = gg.astype(int)
penalArray[gg,:] = penalGaussian
# Higher octave now
if (tcparams.BPM[jj]/2.0 < tcparams.BPM[0]):
octHigh = getNearestIndex(tcparams.BPM[jj]*2.0,tcparams.BPM)
if octHigh >= ((tcparams.BPM).size - tcparams.octTol):
gg = np.arange(octHigh-tcparams.octTol,D+1)
gg = gg.astype(int)
penalArray[gg,:] = penalGaussian[gg]
else:
gg = np.arange(octHigh-tcparams.octTol,octHigh+tcparams.octTol+1)
gg = gg.astype(int)
penalArray[gg,:] = penalGaussian
# Now the DP
bpmnow = np.abs(tcparams.BPM[jj] - BPMCOl)
fnNow = (DP[:,i-1]).reshape((DP[:,i-1]).size,1) - tcparams.theta * bpmnow - tcparams.delta*penalArray
# fnNow = (DP[:,i-1]).reshape((DP[:,i-1]).size,1) - params.theta * bpmnow
DP[jj,i] = fnNow.max()
pIndex[jj,i] = fnNow.argmax()
DP[jj,i] = DP[jj,i] + tg[jj,i]
if not np.mod(i,100):
logger.info(str(i)+'/'+ str(N)+'...')
# backtracking now
tc = np.zeros(N)
zn = (np.zeros(N)).astype(int)
zn[N-1] = (DP[:,-1]).argmax()
tc[N-1] = tcparams.BPM[zn[N-1]]
for p in range(N-1,0,-1):
zn[p-1] = pIndex[zn[p],p]
tc[p-1] = tcparams.BPM[zn[p-1]]
# Return
return tc
def getTempoCurve(tg, tcparams):
'''
% Given the tempogram, it returns the best tempo curve using DP
% tempoGram is a DxN Tempogram matrix computed with D tempo values and N time instances
% params - parameter structure with following fields
% params.BPM (Dx1) = BPM at which the tempogram was computed. Note that params.BPM(1)
% corresponds to tempoGram(1,:)
% params.ts (1xN) = time stamps at which the tempogram was computed
% params.theta (1x1) = smoothing parameter, higher the value, more smooth
% is the curve. Set theta = 0 for a maximum vote tempo across time
'''
logger = log.get_logger("rhythm")
logger.info('Computing IAI curve...')
(D, N) = tg.shape
DP = np.zeros(tg.shape)
pIndex = np.zeros(tg.shape)
DP[:, 0] = tg[:, 0]
ind, = (tcparams.BPM < tcparams.minBPM).nonzero()
tg[ind, :] = -1000000.0
BPMCOl = (tcparams.BPM).reshape(((tcparams.BPM).size, 1))
xx = np.arange(-tcparams.octTol, tcparams.octTol + 1)
penalGaussian = scistats.norm.pdf(xx, 0, tcparams.octTol / 3)
penalGaussian = penalGaussian.reshape((penalGaussian.size, 1))
penalGaussian = penalGaussian / (penalGaussian.max())
for i in range(1, N):
for jj in range(D):
# Octave jumps to be penalized
penalArray = np.zeros((D, 1))
# Lower octave first
if (tcparams.BPM[jj] / 2.0 > tcparams.BPM[0]):
octLow = getNearestIndex(tcparams.BPM[jj] / 2.0, tcparams.BPM)
if octLow <= tcparams.octTol:
gg = np.arange(octLow + tcparams.octTol)
gg = gg.astype(int)
penalArray[gg, :] = penalGaussian[-gg.size:]
else:
gg = np.arange(octLow - tcparams.octTol,
octLow + tcparams.octTol + 1)
gg = gg.astype(int)
penalArray[gg, :] = penalGaussian
# Higher octave now
if (tcparams.BPM[jj] / 2.0 < tcparams.BPM[0]):
octHigh = getNearestIndex(tcparams.BPM[jj] * 2.0, tcparams.BPM)
if octHigh >= ((tcparams.BPM).size - tcparams.octTol):
gg = np.arange(octHigh - tcparams.octTol, D + 1)
gg = gg.astype(int)
penalArray[gg, :] = penalGaussian[gg]
else:
gg = np.arange(octHigh - tcparams.octTol,
octHigh + tcparams.octTol + 1)
gg = gg.astype(int)
penalArray[gg, :] = penalGaussian
# Now the DP
bpmnow = np.abs(tcparams.BPM[jj] - BPMCOl)
fnNow = (DP[:, i - 1]).reshape(
(DP[:, i - 1]).size,
1) - tcparams.theta * bpmnow - tcparams.delta * penalArray
# fnNow = (DP[:,i-1]).reshape((DP[:,i-1]).size,1) - params.theta * bpmnow
DP[jj, i] = fnNow.max()
pIndex[jj, i] = fnNow.argmax()
DP[jj, i] = DP[jj, i] + tg[jj, i]
if not np.mod(i, 100):
logger.info(str(i) + '/' + str(N) + '...')
# backtracking now
tc = np.zeros(N)
zn = (np.zeros(N)).astype(int)
zn[N - 1] = (DP[:, -1]).argmax()
tc[N - 1] = tcparams.BPM[zn[N - 1]]
for p in range(N - 1, 0, -1):
zn[p - 1] = pIndex[zn[p], p]
tc[p - 1] = tcparams.BPM[zn[p - 1]]
# Return
return tc
logger.info(
str(frameCounter) + '/' + str(audio.size / params.hop) + '...')
logger.info('Total frames processed = ' + str(frameCounter))
timeStamps = es.array([pool['features.time']])
all_feat = timeStamps
for bands in range(params.numBands):
feat_flux = es.array([pool[poolName + str(bands)]])
all_feat = np.vstack((all_feat, feat_flux))
pass
return np.transpose(all_feat)
##################################################################################
if __name__ == '__main__':
# An example to run the module correctly
logger = log.get_logger("rhythm")
logger.info('Started Processing...')
# fname = '/media/Code/UPFWork/PhD/Data/CMCMDa/mp3/adi/10014_1313_Bhagyadalakshmi.mp3'
# fname = '/media/Data/Data/CompMusicDB/Carnatic/audio/T._M._Krishna/Carnatic_Vocal/2_Ninnenera.mp3'
# fname = '/media/Data/Data/CompMusicDB/Carnatic/audio/T._M._Krishna/December_Season_2008/CD_2/2-01_Etavunara.mp3'
# fname = '2-01_Etavunara_part.mp3'
fname = '/media/Data/Data/CompMusicDB/Carnatic/audio/Aneesh_Vidyashankar/Pure_Expressions/7_Jagadoddharana.mp3'
logger.info(fname)
# Get onset functions
onsFns = getOnsetFunctions(fname)
onsFn = onsFns[:, 6].copy()
onsTs = onsFns[:, 0].copy()
onsFnLow = onsFns[:, 1].copy()
onsFn = normMax(smoothNovelty(onsFn, params.onsParams.pdSmooth))
onsFnLow = normMax(smoothNovelty(onsFnLow, params.onsParams.pdSmooth))
sectStart = np.array([0.0])
pool.add('features.time', frmTime);
frameCounter += 1
if not np.mod(frameCounter,10000):
logger.info(str(frameCounter) + '/' + str(audio.size/params.hop) + '...')
logger.info('Total frames processed = ' + str(frameCounter))
timeStamps = es.array([ pool['features.time'] ])
all_feat = timeStamps
for bands in range(params.numBands):
feat_flux = es.array([ pool[poolName + str(bands)] ])
all_feat = np.vstack((all_feat,feat_flux))
pass
return np.transpose(all_feat)
##################################################################################
if __name__ == '__main__':
# An example to run the module correctly
logger = log.get_logger("rhythm")
logger.info('Started Processing...')
# fname = '/media/Code/UPFWork/PhD/Data/CMCMDa/mp3/adi/10014_1313_Bhagyadalakshmi.mp3'
# fname = '/media/Data/Data/CompMusicDB/Carnatic/audio/T._M._Krishna/Carnatic_Vocal/2_Ninnenera.mp3'
# fname = '/media/Data/Data/CompMusicDB/Carnatic/audio/T._M._Krishna/December_Season_2008/CD_2/2-01_Etavunara.mp3'
# fname = '2-01_Etavunara_part.mp3'
fname = '/media/Data/Data/CompMusicDB/Carnatic/audio/Aneesh_Vidyashankar/Pure_Expressions/7_Jagadoddharana.mp3'
logger.info(fname)
# Get onset functions
onsFns = getOnsetFunctions(fname)
onsFn = onsFns[:,6].copy()
onsTs = onsFns[:,0].copy()
onsFnLow = onsFns[:,1].copy()
onsFn = normMax(smoothNovelty(onsFn,params.onsParams.pdSmooth))
onsFnLow = normMax(smoothNovelty(onsFnLow,params.onsParams.pdSmooth))
sectStart = np.array([0.0])
