def getHPCPEssentia(XAudio, Fs, winSize, hopSize, squareRoot=False, NChromaBins=36, NHarmonics = 0):
"""
Wrap around the essentia library to compute HPCP features
:param XAudio: A flat array of raw audio samples
:param Fs: Sample rate
:param winSize: Window size of each STFT window
:param hopSize: Hop size between STFT windows
:param squareRoot: Do square root compression?
:param NChromaBins: How many chroma bins (default 36)
:returns H: An (NChromaBins x NWindows) matrix of all \
chroma windows
"""
import essentia
from essentia import Pool, array
import essentia.standard as ess
spectrum = ess.Spectrum()
window = ess.Windowing(size=winSize, type='hann')
spectralPeaks = ess.SpectralPeaks()
hpcp = ess.HPCP(size=NChromaBins, harmonics=NHarmonics)
H = []
for frame in ess.FrameGenerator(array(XAudio), frameSize=winSize, hopSize=hopSize, startFromZero=True):
S = spectrum(window(frame))
freqs, mags = spectralPeaks(S)
H.append(hpcp(freqs, mags))
H = np.array(H)
H = H.T
if squareRoot:
H = sqrtCompress(H)
return H
def get_beat_chunks(filename, bpm_restrict=None):
audio = std.MonoLoader(filename=filename)()
hpcp = std.HPCP()
spectrum = std.Spectrum()
speaks = std.SpectralPeaks()
large_speaks = std.SpectralPeaks(maxPeaks=2000)
tivs = []
sr = 44100
bpm = get_tempo(filename)
tivs_framewise = []
if bpm_restrict != None and bpm_restrict != bpm:
raise ValueError
sec_beat = (60 / bpm)
beats = np.arange(0, len(audio) / sr, sec_beat)
beats = np.append(beats, len(audio) / sr)
for i in range(1, len(beats)):
segmented_audio = audio[int(beats[i - 1] * sr):int(beats[i] * sr)]
cutter = std.FrameGenerator(segmented_audio)
for sec in cutter:
spec = spectrum(sec)
freq, mag = speaks(spec)
chroma = hpcp(freq, mag)
tivs_framewise.append(chroma)
np2_seg_audio = zeropad_next_power_2(segmented_audio)
spec = spectrum(np2_seg_audio)
freq, mag = speaks(spec)
chroma = hpcp(freq, mag)
tivs.append(chroma)
# Calculate the whole TIV
np2_whole = zeropad_next_power_2(audio)
spec = spectrum(np2_whole)
freq, mag = large_speaks(spec)
chroma_whole = hpcp(freq, mag)
return mt.TIVCollection.from_pcp(np.array(tivs).T), mt.TIV.from_pcp(chroma_whole), mt.TIVCollection.from_pcp(np.array(tivs_framewise).T)
def calc_chromagram(self):
# save the results in the stft_pool
self.chromagram = []
hpcp = es.HPCP(
size=12, # we will need higher resolution for Key estimation
referenceFrequency=440, # assume tuning frequency is 44100.
bandPreset=False,
weightType='cosine',
nonLinear=False,
windowSize=1.,
sampleRate=self.sample_rate)
spectrum = es.Spectrum(size=self.fft_size)
spectral_peaks = es.SpectralPeaks(sampleRate=self.sample_rate)
for frame in es.FrameGenerator(self.audio,
frameSize=self.frame_size,
hopSize=self.hop_size,
startFromZero=True):
frame = array(frame * self.window)
freqs, mags = spectral_peaks(spectrum(frame))
chroma = hpcp(freqs, mags)
self.chromagram.append(chroma)
self.chromagram = array(self.chromagram)
self.timeAxSec = np.arange(len(
self.chromagram)) * self.hop_size / float(self.sample_rate)
def file_to_hpcp(loop):
loop = e.array(loop)
windowing = es.Windowing(type='blackmanharris62')
spectrum = es.Spectrum()
spectral_peaks = es.SpectralPeaks(orderBy='magnitude',
magnitudeThreshold=0.001,
maxPeaks=20,
minFrequency=20,
maxFrequency=8000)
hpcp = es.HPCP(maxFrequency=8000)
spec_group = []
hpcp_group = []
for frame in es.FrameGenerator(loop, frameSize=1024, hopSize=512):
windowed = windowing(frame)
fft = spectrum(windowed)
frequencies, magnitudes = spectral_peaks(fft)
final_hpcp = hpcp(frequencies, magnitudes)
spec_group.append(fft)
hpcp_group.append(final_hpcp)
mean_hpcp = np.mean(np.array(hpcp_group).T, axis=1)
#normalize to 1
mean_hpcp = mean_hpcp / mean_hpcp.max()
return mean_hpcp
def FeatureExtraction_Recording(recording, params):
numBins = params.numbins
fs = params.fs
# LOAD Audio file
Audio = ess.MonoLoader(filename=recording.path, sampleRate=fs)()
Audio = ess.DCRemoval()(Audio) # PREPROCESSING / DC removal
Audio = ess.EqualLoudness()(Audio) # PREPROCESSING - Equal Loudness Filter
# Windowing Parameters (first converting from msec to number of samples)
# assuring windowSize and hopSize are even
windowSize = round(fs * params.windowSize / 1000)
windowSize = int(windowSize / 2) * 2
hopSize = round(fs * params.hopSize / 1000)
hopSize = int(hopSize / 2) * 2
tonic = float(recording.tonic)
# FRAME-BASED Spectral Analysis
hpcp = []
for frame in ess.FrameGenerator(Audio,
frameSize=windowSize,
hopSize=hopSize,
startFromZero=True):
frame = ess.Windowing(size=windowSize,
type=params.windowFunction)(frame)
mX = ess.Spectrum(size=windowSize)(frame)
mX[mX < np.finfo(float).eps] = np.finfo(float).eps
# EXTRACT frequency and magnitude information of the harmonic spectral peaks
freq, mag = ess.SpectralPeaks()(mX)
# harmonic pitch-class profiles
hpcp.append(
ess.HPCP(normalized='unitSum',
referenceFrequency=tonic,
size=numBins,
windowSize=12 / numBins)(freq, mag))
recording.chroma_framebased = np.array(hpcp)
# FEATURE SUMMARIZATION
mean_chroma = []
# global Mean of HPCP vectors
std_chroma = []
# global standard deviation of HPCP vectors
for j in range(numBins):
tmp = []
for i in range(len(recording.chroma_framebased)):
tmp.append(recording.chroma_framebased[i][j])
mean_chroma.append(np.mean(tmp))
std_chroma.append(np.std(tmp))
recording.chroma_mean = mean_chroma
recording.chroma_std = std_chroma
def compute_beatsync_features(ticks, audio):
"""Computes the HPCP and MFCC beat-synchronous features given a set
of beats (ticks)."""
MFCC = STFTFeature(FRAME_SIZE, HOP_SIZE, WINDOW_TYPE,
ES.MFCC(numberCoefficients=14), ticks, SAMPLE_RATE)
HPCP = STFTFeature(FRAME_SIZE, HOP_SIZE, WINDOW_TYPE, ES.HPCP(),
ticks, SAMPLE_RATE)
logging.info("Computing Beat-synchronous MFCCs...")
mfcc = MFCC.compute_features(audio)
logging.info("Computing Beat-synchronous HPCPs...")
hpcp = HPCP.compute_features(audio)
logging.info("Computing Beat-synchronous Tonnetz...")
tonnetz = utils.chroma_to_tonnetz(hpcp)
return mfcc.tolist(), hpcp.tolist(), tonnetz.tolist()
def compute_features(audio, beats=None):
"""Computes the HPCP and MFCC beat-synchronous features given a set
of beats (beats)."""
beatsync_str = ""
if beats is not None:
beatsync_str = "Beat-synchronous "
MFCC = STFTFeature(msaf.Anal.frame_size, msaf.Anal.hop_size,
msaf.Anal.window_type,
ES.MFCC(numberCoefficients=msaf.Anal.mfcc_coeff),
msaf.Anal.sample_rate, beats)
HPCP = STFTFeature(msaf.Anal.frame_size, msaf.Anal.hop_size,
msaf.Anal.window_type, ES.HPCP(), msaf.Anal.sample_rate,
beats)
logging.info("Computing %sMFCCs..." % beatsync_str)
mfcc = MFCC.compute_features(audio)
logging.info("Computing %sHPCPs..." % beatsync_str)
hpcp = HPCP.compute_features(audio)
#plt.imshow(hpcp.T, interpolation="nearest", aspect="auto"); plt.show()
logging.info("Computing %sTonnetz..." % beatsync_str)
tonnetz = utils.chroma_to_tonnetz(hpcp)
return mfcc, hpcp, tonnetz
def chroma_hpcp(self,
frameSize=4096,
hopSize=2048,
windowType='blackmanharris62',
harmonicsPerPeak=8,
magnitudeThreshold=1e-05,
maxPeaks=1000,
whitening=True,
referenceFrequency=440,
minFrequency=40,
maxFrequency=5000,
nonLinear=False,
numBins=12,
display=False):
'''
Compute Harmonic Pitch Class Profiles (HPCP) for the input audio files using essentia standard mode using
the default parameters as mentioned in [1].
Please refer to the following paper for detailed explanantion of the algorithm.
[1]. Gómez, E. (2006). Tonal Description of Polyphonic Audio for Music Content Processing.
For full list of parameters of essentia standard mode HPCP please refer to http://essentia.upf.edu/documentation/reference/std_HPCP.html
Parameters
harmonicsPerPeak : (integer ∈ [0, ∞), default = 0) :
number of harmonics for frequency contribution, 0 indicates exclusive fundamental frequency contribution
maxFrequency : (real ∈ (0, ∞), default = 5000) :
the maximum frequency that contributes to the HPCP [Hz] (the difference between the max and split frequencies must not be less than 200.0 Hz)
minFrequency : (real ∈ (0, ∞), default = 40) :
the minimum frequency that contributes to the HPCP [Hz] (the difference between the min and split frequencies must not be less than 200.0 Hz)
nonLinear : (bool ∈ {true, false}, default = false) :
apply non-linear post-processing to the output (use with normalized='unitMax'). Boosts values close to 1, decreases values close to 0.
normalized (string ∈ {none, unitSum, unitMax}, default = unitMax) :
whether to normalize the HPCP vector
referenceFrequency : (real ∈ (0, ∞), default = 440) :
the reference frequency for semitone index calculation, corresponding to A3 [Hz]
sampleRate : (real ∈ (0, ∞), default = 44100) :
the sampling rate of the audio signal [Hz]
numBins : (integer ∈ [12, ∞), default = 12) :
the size of the output HPCP (must be a positive nonzero multiple of 12)
whitening : (boolean (True, False), default = False)
Optional step of computing spectral whitening to the output from speakPeak magnitudes
'''
audio = array(self.audio_vector)
#print audio.shape
frameGenerator = estd.FrameGenerator(audio,
frameSize=frameSize,
hopSize=hopSize)
window = estd.Windowing(type=windowType)
spectrum = estd.Spectrum()
# Refer http://essentia.upf.edu/documentation/reference/std_SpectralPeaks.html
spectralPeaks = estd.SpectralPeaks(magnitudeThreshold=0,
maxFrequency=maxFrequency,
minFrequency=minFrequency,
maxPeaks=maxPeaks,
orderBy="frequency",
sampleRate=self.fs)
# http://essentia.upf.edu/documentation/reference/std_SpectralWhitening.html
spectralWhitening = estd.SpectralWhitening(maxFrequency=maxFrequency,
sampleRate=self.fs)
# http://essentia.upf.edu/documentation/reference/std_HPCP.html
hpcp = estd.HPCP(sampleRate=self.fs,
maxFrequency=maxFrequency,
minFrequency=minFrequency,
referenceFrequency=referenceFrequency,
nonLinear=nonLinear,
harmonics=harmonicsPerPeak,
size=numBins)
pool = Pool()
#compute hpcp for each frame and add the results to the pool
for frame in frameGenerator:
spectrum_mag = spectrum(window(frame))
frequencies, magnitudes = spectralPeaks(spectrum_mag)
if whitening:
w_magnitudes = spectralWhitening(spectrum_mag, frequencies,
magnitudes)
hpcp_vector = hpcp(frequencies, w_magnitudes)
else:
hpcp_vector = hpcp(frequencies, magnitudes)
pool.add('tonal.hpcp', hpcp_vector)
if display:
display_chroma(np.swapaxes(pool['tonal.hpcp']), 0, 1)
return pool['tonal.hpcp']
def hpcpgram(audio,
sampleRate=44100,
frameSize=4096,
hopSize=2048,
numBins=12,
windowType='blackmanharris62',
minFrequency=100,
maxFrequency=4000,
whitening=False,
maxPeaks=100,
magnitudeThreshold=1e-05,
**kwargs):
"""
Compute Harmonic Pitch Class Profile (HPCP) Grams for overlapped frames of a given input audio signal
For additional list of parameters of essentia standard mode HPCP please refer to
http://essentia.upf.edu/documentation/reference/std_HPCP.html
References:
[1]. Gómez, E. (2006). Tonal Description of Polyphonic Audio for Music Content Processing.
Inputs
audio (2d vector): audio signal
Parameters:
sampleRate : (real ∈ (0, ∞), default = 44100) :
the sampling rate of the audio signal [Hz]
frameSize (integer ∈ [1, ∞), default = 1024) :
the output frame size
hopSize (integer ∈ [1, ∞), default = 512) :
the hop size between frames
numBins : (integer ∈ [12, ∞), default = 12) :
the size of the output HPCP (must be a positive nonzero multiple of 12)
windowType (string ∈ {hamming, hann, hannnsgcq, triangular, square, blackmanharris62, blackmanharris70, blackmanharris74, blackmanharris92}, default = blackmanharris62) :
the window type, which can be 'hamming', 'hann', 'triangular', 'square' or 'blackmanharrisXX'
maxFrequency : (real ∈ (0, ∞), default = 4000) :
the maximum frequency that contributes to the SpectralPeaks and HPCP algorithms computation [Hz] (the difference between the max and split frequencies must not be less than 200.0 Hz)
minFrequency : (real ∈ (0, ∞), default = 100) :
the minimum frequency that contributes to the SpectralPeaks and HPCP algorithm computation [Hz] (the difference between the min and split frequencies must not be less than 200.0 Hz)
maxPeaks (integer ∈ [1, ∞), default = 100) :
the maximum number of returned peaks while calculating SpectralPeaks
magnitudeThreshold (real ∈ (-∞, ∞), default = 0) :
peaks below this given threshold are not outputted while calculating Spectral Peaks
whitening : (boolean (True, False), default = False)
Optional step of computing spectral whitening to the output from speakPeak magnitudes
kwargs : additional keyword arguments
Arguments to parameterize HPCP alogithms.
see standard mode HPCP algorithm (http://essentia.upf.edu/documentation/reference/std_HPCP.html).
Returns: hpcpgram of overlapped frames of input audio signal (2D vector)
"""
frameGenerator = es.FrameGenerator(array(audio),
frameSize=frameSize,
hopSize=hopSize)
window = es.Windowing(type=windowType)
spectrum = es.Spectrum()
# Refer http://essentia.upf.edu/documentation/reference/std_SpectralPeaks.html
spectralPeaks = es.SpectralPeaks(magnitudeThreshold=magnitudeThreshold,
maxFrequency=maxFrequency,
minFrequency=minFrequency,
maxPeaks=maxPeaks,
sampleRate=sampleRate)
# http://essentia.upf.edu/documentation/reference/std_SpectralWhitening.html
spectralWhitening = es.SpectralWhitening(maxFrequency=maxFrequency,
sampleRate=sampleRate)
# http://essentia.upf.edu/documentation/reference/std_HPCP.html
hpcp = es.HPCP(sampleRate=sampleRate,
maxFrequency=maxFrequency,
minFrequency=minFrequency,
size=numBins,
**kwargs)
pool = Pool()
#compute hpcp for each frame and add the results to the pool
for frame in frameGenerator:
spectrum_mag = spectrum(window(frame))
frequencies, magnitudes = spectralPeaks(spectrum_mag)
if whitening:
w_magnitudes = spectralWhitening(spectrum_mag, frequencies,
magnitudes)
hpcp_vector = hpcp(frequencies, w_magnitudes)
else:
hpcp_vector = hpcp(frequencies, magnitudes)
pool.add('tonal.hpcp', hpcp_vector)
return pool['tonal.hpcp']
# retrieve filenames from folder:
soundfiles = os.listdir(infolder)
if '.DS_Store' in soundfiles:
soundfiles.remove('.DS_Store')
print "\nANALYSIS..."
for item in soundfiles:
# Load the Algorithms:
#loader = estd.MonoLoader(filename='/Users/angel/Desktop/sine.wav')
#loader = estd.MonoLoader(filename=infolder + '/' +item)
window = estd.Windowing(size=window_size, type="blackmanharris62")
rfft = estd.Spectrum(size=window_size)
speaks = estd.SpectralPeaks(orderBy="magnitude",
magnitudeThreshold=magnitude_threshold,
minFrequency=min_frequency,
maxFrequency=max_frequency,
maxPeaks=max_peaks)
hpcp = estd.HPCP(size=12)
key = estd.Key(useThreeChords=True, profileType=profile)
pool = e.Pool()
# Chain them together
audio = loader()
lll = []
for frame in estd.FrameGenerator(audio,
frameSize=window_size,
hopSize=hop_size):
p1, p2 = speaks(rfft(window(frame)))
lll.append(hpcp(p1, p2))
print kk
loader = estd.MonoLoader(filename=audio_folder + '/' +item,
sampleRate=sample_rate)
window = estd.Windowing(size=window_size,
type="blackmanharris62")
rfft = estd.Spectrum(size=window_size)
speaks = estd.SpectralPeaks(orderBy="magnitude",
magnitudeThreshold=magnitude_threshold,
minFrequency=min_frequency,
maxFrequency=max_frequency,
maxPeaks=max_peaks,
sampleRate=sample_rate)
hpcp = estd.HPCP(bandPreset=band_preset,
harmonics = harmonics,
minFrequency=min_frequency,
maxFrequency=max_frequency,
nonLinear=non_linear,
normalized=normalize,
sampleRate=sample_rate,
weightType=weight_type,
windowSize=weight_window_size)
key = estd.Key(numHarmonics=harmonics_key,
slope=slope,
usePolyphony=polyphony,
useThreeChords=three_chords,
profileType=profile)
pool = e.Pool() # I don't need a pool!
audio = loader()
hpcp_list = []
hpcp_average = [0] * 12
for frame in estd.FrameGenerator(audio, frameSize=window_size, hopSize=hop_size):
p1, p2 = speaks(rfft(window(frame)))
def estimate_key(input_audio_file, output_text_file=None, key_profile=None):
"""
This function estimates the overall key of an audio track
optionaly with extra modal information.
:type input_audio_file: str
:type output_text_file: str
"""
if key_profile is not None:
global USE_THREE_PROFILES
global WITH_MODAL_DETAILS
global KEY_PROFILE
KEY_PROFILE = key_profile
USE_THREE_PROFILES = False
WITH_MODAL_DETAILS = False
loader = estd.MonoLoader(filename=input_audio_file, sampleRate=SAMPLE_RATE)
cut = estd.FrameCutter(frameSize=WINDOW_SIZE, hopSize=HOP_SIZE)
window = estd.Windowing(size=WINDOW_SIZE, type=WINDOW_SHAPE)
rfft = estd.Spectrum(size=WINDOW_SIZE)
sw = estd.SpectralWhitening(maxFrequency=MAX_HZ, sampleRate=SAMPLE_RATE)
speaks = estd.SpectralPeaks(magnitudeThreshold=SPECTRAL_PEAKS_THRESHOLD,
maxFrequency=MAX_HZ,
minFrequency=MIN_HZ,
maxPeaks=SPECTRAL_PEAKS_MAX,
sampleRate=SAMPLE_RATE)
hpcp = estd.HPCP(
bandPreset=HPCP_BAND_PRESET,
#bandSplitFrequency=HPCP_SPLIT_HZ,
harmonics=HPCP_HARMONICS,
maxFrequency=MAX_HZ,
minFrequency=MIN_HZ,
nonLinear=HPCP_NON_LINEAR,
normalized=HPCP_NORMALIZE,
referenceFrequency=HPCP_REFERENCE_HZ,
sampleRate=SAMPLE_RATE,
size=HPCP_SIZE,
weightType=HPCP_WEIGHT_TYPE,
windowSize=HPCP_WEIGHT_WINDOW_SEMITONES,
maxShifted=HPCP_SHIFT)
if HIGHPASS_CUTOFF is not None:
hpf = estd.HighPass(cutoffFrequency=HIGHPASS_CUTOFF,
sampleRate=SAMPLE_RATE)
audio = hpf(hpf(hpf(loader())))
else:
audio = loader()
duration = len(audio)
n_slices = 1 + (duration // HOP_SIZE)
chroma = np.empty([n_slices, HPCP_SIZE], dtype='float64')
for slice_n in range(n_slices):
spek = rfft(window(cut(audio)))
p1, p2 = speaks(spek)
if SPECTRAL_WHITENING:
p2 = sw(spek, p1, p2)
pcp = hpcp(p1, p2)
if not DETUNING_CORRECTION or DETUNING_CORRECTION_SCOPE == 'average':
chroma[slice_n] = pcp
elif DETUNING_CORRECTION and DETUNING_CORRECTION_SCOPE == 'frame':
pcp = shift_pcp(pcp, HPCP_SIZE)
chroma[slice_n] = pcp
else:
raise NameError("SHIFT_SCOPE must be set to 'frame' or 'average'.")
chroma = np.sum(chroma, axis=0)
if PCP_THRESHOLD is not None:
chroma = normalize_pcp_peak(chroma)
chroma = pcp_gate(chroma, PCP_THRESHOLD)
if DETUNING_CORRECTION and DETUNING_CORRECTION_SCOPE == 'average':
chroma = shift_pcp(chroma, HPCP_SIZE)
chroma = np.roll(
chroma, -3) # Adjust to essentia's HPCP calculation starting on A...
if USE_THREE_PROFILES:
estimation_1 = template_matching_3(chroma, KEY_PROFILE)
else:
estimation_1 = template_matching_2(chroma, KEY_PROFILE)
key_1 = estimation_1[0] + '\t' + estimation_1[1]
correlation_value = estimation_1[2]
if WITH_MODAL_DETAILS:
estimation_2 = template_matching_modal(chroma)
key_2 = estimation_2[0] + '\t' + estimation_2[1]
key_verbose = key_1 + '\t' + key_2
key = key_verbose.split('\t')
# Assign monotonic tracks to minor:
if key[3] == 'monotonic' and key[0] == key[2]:
key = '{0}\tminor'.format(key[0])
else:
key = key_1
else:
key = key_1
if output_text_file is not None:
textfile = open(output_text_file, 'w')
textfile.write(key + '\t' + str(correlation_value) + '\n')
textfile.close()
return key, correlation_value
sampleRate=samplerate)
window = esst.Windowing(type='blackmanharris92',
size=framesize)
rfft = esst.Spectrum(size=framesize)
peaks = esst.SpectralPeaks(minFrequency=minfreq,
maxFrequency=maxfreq,
maxPeaks=maxpeaks,
magnitudeThreshold=magthres,
sampleRate=samplerate,
orderBy=orderby)
hpcp = esst.HPCP(bandPreset=bandpreset,
harmonics=partials,
normalized=normalize,
minFrequency=minfreq,
maxFrequency=maxfreq,
sampleRate=samplerate,
weightType=weight)
audio = loader()
peakF = []
peakA = []
chroma = []
absmt = abs(magthres)
for frame in esst.FrameGenerator(audio, frameSize=framesize, hopSize=hopsize):
p1, p2 = peaks(8.685889638065209 * np.log(rfft(window(frame))))
# p1, p2 = peaks(rfft(window(frame)))
peakF.append(p1)
peakA.append(absmt+p2)
chroma.append(hpcp(p1,absmt+p2))
def key_aes(input_audio_file, output_text_file, **kwargs):
"""
This function estimates the overall key of an audio track
optionally with extra modal information.
:type input_audio_file: str
:type output_text_file: str
"""
if not kwargs:
kwargs = KEY_SETTINGS
loader = estd.MonoLoader(filename=input_audio_file,
sampleRate=kwargs["SAMPLE_RATE"])
cut = estd.FrameCutter(frameSize=kwargs["WINDOW_SIZE"],
hopSize=kwargs["HOP_SIZE"])
window = estd.Windowing(size=kwargs["WINDOW_SIZE"],
type=kwargs["WINDOW_SHAPE"])
rfft = estd.Spectrum(size=kwargs["WINDOW_SIZE"])
sw = estd.SpectralWhitening(maxFrequency=kwargs["MAX_HZ"],
sampleRate=kwargs["SAMPLE_RATE"])
speaks = estd.SpectralPeaks(
magnitudeThreshold=kwargs["SPECTRAL_PEAKS_THRESHOLD"],
maxFrequency=kwargs["MAX_HZ"],
minFrequency=kwargs["MIN_HZ"],
maxPeaks=kwargs["SPECTRAL_PEAKS_MAX"],
sampleRate=kwargs["SAMPLE_RATE"])
hpcp = estd.HPCP(bandPreset=kwargs["HPCP_BAND_PRESET"],
splitFrequency=kwargs["HPCP_SPLIT_HZ"],
harmonics=kwargs["HPCP_HARMONICS"],
maxFrequency=kwargs["MAX_HZ"],
minFrequency=kwargs["MIN_HZ"],
nonLinear=kwargs["HPCP_NON_LINEAR"],
normalized=kwargs["HPCP_NORMALIZE"],
referenceFrequency=kwargs["HPCP_REFERENCE_HZ"],
sampleRate=kwargs["SAMPLE_RATE"],
size=kwargs["HPCP_SIZE"],
weightType=kwargs["HPCP_WEIGHT_TYPE"],
windowSize=kwargs["HPCP_WEIGHT_WINDOW_SEMITONES"],
maxShifted=kwargs["HPCP_SHIFT"])
audio = loader()
if kwargs["HIGHPASS_CUTOFF"] is not None:
hpf = estd.HighPass(cutoffFrequency=kwargs["HIGHPASS_CUTOFF"],
sampleRate=kwargs["SAMPLE_RATE"])
audio = hpf(hpf(hpf(audio)))
if kwargs["DURATION"] is not None:
audio = audio[(kwargs["START_TIME"] *
kwargs["SAMPLE_RATE"]):(kwargs["DURATION"] *
kwargs["SAMPLE_RATE"])]
duration = len(audio)
number_of_frames = int(duration / kwargs["HOP_SIZE"])
chroma = []
for bang in range(number_of_frames):
spek = rfft(window(cut(audio)))
p1, p2 = speaks(spek)
if kwargs["SPECTRAL_WHITENING"]:
p2 = sw(spek, p1, p2)
pcp = hpcp(p1, p2)
if np.sum(pcp) > 0:
if not kwargs["DETUNING_CORRECTION"] or kwargs[
"DETUNING_CORRECTION_SCOPE"] == 'average':
chroma.append(pcp)
elif kwargs["DETUNING_CORRECTION"] and kwargs[
"DETUNING_CORRECTION_SCOPE"] == 'frame':
pcp = _detuning_correction(pcp, kwargs["HPCP_SIZE"])
chroma.append(pcp)
else:
raise NameError(
"SHIFT_SCOPE musts be set to 'frame' or 'average'.")
if not chroma:
return 'Silence'
chroma = np.sum(chroma, axis=0)
chroma = norm_peak(chroma)
if kwargs["PCP_THRESHOLD"] is not None:
chroma = vector_threshold(chroma, kwargs["PCP_THRESHOLD"])
if kwargs["DETUNING_CORRECTION"] and kwargs[
"DETUNING_CORRECTION_SCOPE"] == 'average':
chroma = _detuning_correction(chroma, kwargs["HPCP_SIZE"])
# Adjust to essentia's HPCP calculation starting on A (pc = 9)
chroma = np.roll(chroma, -3 * (kwargs["HPCP_SIZE"] // 12))
estimation_1 = estimate_key(chroma,
kwargs["KEY_PROFILE"],
kwargs["PROFILE_INTERPOLATION"],
conf_thres=kwargs["NOKEY_THRESHOLD"],
vocabulary=kwargs["KEY_VOCABULARY"])
key_1 = estimation_1[0]
correlation_value = estimation_1[1]
if kwargs["WITH_MODAL_DETAILS"]:
estimation_2 = _key7(chroma, kwargs["PROFILE_INTERPOLATION"])
key_2 = estimation_2[0] + '\t' + estimation_2[1]
key_verbose = key_1 + '\t' + key_2
key = key_verbose.split('\t')
# Assign monotonic track to minor:
if key[3] == 'monotonic' and key[0] == key[2]:
key = '{0}\tminor'.format(key[0])
else:
key = key_1
else:
key = key_1
textfile = open(output_text_file, 'w')
textfile.write(key)
textfile.close()
return key, correlation_value
sampleRate=sample_rate)
cut = estd.FrameCutter(frameSize=window_size, hopSize=hop_size)
window = estd.Windowing(size=window_size, type=window_type)
rfft = estd.Spectrum(size=window_size)
sw = estd.SpectralWhitening(maxFrequency=max_frequency,
sampleRate=sample_rate)
speaks = estd.SpectralPeaks(magnitudeThreshold=magnitude_threshold,
maxFrequency=max_frequency,
minFrequency=min_frequency,
maxPeaks=max_peaks,
sampleRate=sample_rate)
hpcp = estd.HPCP(harmonics=harmonics,
maxFrequency=max_frequency,
minFrequency=min_frequency,
nonLinear=non_linear,
normalized=normalize,
referenceFrequency=reference_frequency,
sampleRate=sample_rate,
size=hpcp_size,
weightType=weight_type,
windowSize=weight_window_size)
audio = loader()
duration = len(audio)
if analysis_portion > 0:
if duration < (sample_rate * analysis_portion):
number_of_frames = duration / hop_size
else:
number_of_frames = (sample_rate * analysis_portion) / hop_size
else:
number_of_frames = duration / hop_size
chroma = []
for bang in range(number_of_frames):
def hpcp(self,
frameSize=4096,
windowType='blackmanharris62',
harmonicsPerPeak=8,
magnitudeThreshold=0,
maxPeaks=100,
whitening=True,
referenceFrequency=440,
minFrequency=100,
maxFrequency=3500,
nonLinear=False,
numBins=12,
display=False):
"""
Compute Harmonic Pitch Class Profiles (HPCP) for the input audio files using essentia standard mode using
the default parameters as mentioned in [1].
Please refer to the following paper for detailed explanantion of the algorithm.
[1]. Gómez, E. (2006). Tonal Description of Polyphonic Audio for Music Content Processing.
For full list of parameters of essentia standard mode HPCP
please refer to http://essentia.upf.edu/documentation/reference/std_HPCP.html
Returns
hpcp: ndarray(n_frames, 12)
The HPCP coefficients at each time frame
"""
audio = array(self.audio_vector)
frameGenerator = estd.FrameGenerator(audio, frameSize=frameSize, hopSize=self.hop_length)
# framecutter = estd.FrameCutter(frameSize=frameSize, hopSize=self.hop_length)
windowing = estd.Windowing(type=windowType)
spectrum = estd.Spectrum()
# Refer http://essentia.upf.edu/documentation/reference/streaming_SpectralPeaks.html
spectralPeaks = estd.SpectralPeaks(magnitudeThreshold=magnitudeThreshold,
maxFrequency=maxFrequency,
minFrequency=minFrequency,
maxPeaks=maxPeaks,
orderBy="frequency",
sampleRate=self.fs)
# http://essentia.upf.edu/documentation/reference/streaming_SpectralWhitening.html
spectralWhitening = estd.SpectralWhitening(maxFrequency= maxFrequency,
sampleRate=self.fs)
# http://essentia.upf.edu/documentation/reference/streaming_HPCP.html
hpcp = estd.HPCP(sampleRate=self.fs,
maxFrequency=maxFrequency,
minFrequency=minFrequency,
referenceFrequency=referenceFrequency,
nonLinear=nonLinear,
harmonics=harmonicsPerPeak,
size=numBins)
pool = Pool()
#compute hpcp for each frame and add the results to the pool
for frame in frameGenerator:
spectrum_mag = spectrum(windowing(frame))
frequencies, magnitudes = spectralPeaks(spectrum_mag)
if whitening:
w_magnitudes = spectralWhitening(spectrum_mag,
frequencies,
magnitudes)
hpcp_vector = hpcp(frequencies, w_magnitudes)
else:
hpcp_vector = hpcp(frequencies, magnitudes)
pool.add('tonal.hpcp',hpcp_vector)
if display:
display_chroma(pool['tonal.hpcp'].T, self.hop_length)
return pool['tonal.hpcp']
def key_ecir(input_audio_file, output_text_file, **kwargs):
if not kwargs:
kwargs = KEY_SETTINGS
loader = estd.MonoLoader(filename=input_audio_file,
sampleRate=kwargs["SAMPLE_RATE"])
cut = estd.FrameCutter(frameSize=kwargs["WINDOW_SIZE"],
hopSize=kwargs["HOP_SIZE"])
window = estd.Windowing(size=kwargs["WINDOW_SIZE"],
type=kwargs["WINDOW_SHAPE"])
rfft = estd.Spectrum(size=kwargs["WINDOW_SIZE"])
sw = estd.SpectralWhitening(maxFrequency=kwargs["MAX_HZ"],
sampleRate=kwargs["SAMPLE_RATE"])
speaks = estd.SpectralPeaks(
magnitudeThreshold=kwargs["SPECTRAL_PEAKS_THRESHOLD"],
maxFrequency=kwargs["MAX_HZ"],
minFrequency=kwargs["MIN_HZ"],
maxPeaks=kwargs["SPECTRAL_PEAKS_MAX"],
sampleRate=kwargs["SAMPLE_RATE"])
hpcp = estd.HPCP(bandPreset=kwargs["HPCP_BAND_PRESET"],
splitFrequency=kwargs["HPCP_SPLIT_HZ"],
harmonics=kwargs["HPCP_HARMONICS"],
maxFrequency=kwargs["MAX_HZ"],
minFrequency=kwargs["MIN_HZ"],
nonLinear=kwargs["HPCP_NON_LINEAR"],
normalized=kwargs["HPCP_NORMALIZE"],
referenceFrequency=kwargs["HPCP_REFERENCE_HZ"],
sampleRate=kwargs["SAMPLE_RATE"],
size=kwargs["HPCP_SIZE"],
weightType=kwargs["HPCP_WEIGHT_TYPE"],
windowSize=kwargs["HPCP_WEIGHT_WINDOW_SEMITONES"],
maxShifted=kwargs["HPCP_SHIFT"])
key = estd.Key(numHarmonics=kwargs["KEY_HARMONICS"],
pcpSize=kwargs["HPCP_SIZE"],
profileType=kwargs["KEY_PROFILE"],
slope=kwargs["KEY_SLOPE"],
usePolyphony=kwargs["KEY_POLYPHONY"],
useThreeChords=kwargs["KEY_USE_THREE_CHORDS"])
audio = loader()
if kwargs["HIGHPASS_CUTOFF"] is not None:
hpf = estd.HighPass(cutoffFrequency=kwargs["HIGHPASS_CUTOFF"],
sampleRate=kwargs["SAMPLE_RATE"])
audio = hpf(hpf(hpf(audio)))
if kwargs["DURATION"] is not None:
audio = audio[(kwargs["START_TIME"] *
kwargs["SAMPLE_RATE"]):(kwargs["DURATION"] *
kwargs["SAMPLE_RATE"])]
duration = len(audio)
number_of_frames = int(duration / kwargs["HOP_SIZE"])
chroma = []
for bang in range(number_of_frames):
spek = rfft(window(cut(audio)))
p1, p2 = speaks(spek) # p1 = frequencies; p2 = magnitudes
if kwargs["SPECTRAL_WHITENING"]:
p2 = sw(spek, p1, p2)
vector = hpcp(p1, p2)
sum_vector = np.sum(vector)
if sum_vector > 0:
if kwargs["DETUNING_CORRECTION"] == False or kwargs[
"DETUNING_CORRECTION_SCOPE"] == 'average':
chroma.append(vector)
elif kwargs["DETUNING_CORRECTION"] and kwargs[
"DETUNING_CORRECTION_SCOPE"] == 'frame':
vector = _detuning_correction(vector, kwargs["HPCP_SIZE"])
chroma.append(vector)
else:
print("SHIFT_SCOPE must be set to 'frame' or 'average'")
chroma = np.mean(chroma, axis=0)
if kwargs["DETUNING_CORRECTION"] and kwargs[
"DETUNING_CORRECTION_SCOPE"] == 'average':
chroma = _detuning_correction(chroma, kwargs["HPCP_SIZE"])
key = key(chroma.tolist())
confidence = (key[2], key[3])
key = key[0] + '\t' + key[1]
textfile = open(output_text_file, 'w')
textfile.write(key + '\n')
textfile.close()
return key, confidence
def key_detector():
reloj()
# create directory to write the results with an unique time id:
if results_to_file or results_to_csv:
uniqueTime = str(int(tiempo()))
wd = os.getcwd()
temp_folder = wd + '/KeyDetection_' + uniqueTime
os.mkdir(temp_folder)
if results_to_csv:
import csv
csvFile = open(temp_folder + '/Estimation_&_PCP.csv', 'w')
lineWriter = csv.writer(csvFile, delimiter=',')
# retrieve files and filenames according to the desired settings:
if analysis_mode == 'title':
allfiles = os.listdir(audio_folder)
if '.DS_Store' in allfiles: allfiles.remove('.DS_Store')
for item in collection:
collection[collection.index(item)] = ' > ' + item + '.'
for item in genre:
genre[genre.index(item)] = ' < ' + item + ' > '
for item in modality:
modality[modality.index(item)] = ' ' + item + ' < '
analysis_files = []
for item in allfiles:
if any(e1 for e1 in collection if e1 in item):
if any(e2 for e2 in genre if e2 in item):
if any(e3 for e3 in modality if e3 in item):
analysis_files.append(item)
song_instances = len(analysis_files)
print song_instances, 'songs matching the selected criteria:'
print collection, genre, modality
if limit_analysis == 0:
pass
elif limit_analysis < song_instances:
analysis_files = sample(analysis_files, limit_analysis)
print "taking", limit_analysis, "random samples...\n"
else:
analysis_files = os.listdir(audio_folder)
if '.DS_Store' in analysis_files:
analysis_files.remove('.DS_Store')
print len(analysis_files), '\nsongs in folder.\n'
groundtruth_files = os.listdir(groundtruth_folder)
if '.DS_Store' in groundtruth_files:
groundtruth_files.remove('.DS_Store')
# ANALYSIS
# ========
if verbose:
print "ANALYSING INDIVIDUAL SONGS..."
print "============================="
if confusion_matrix:
matrix = 24 * 24 * [0]
mirex_scores = []
for item in analysis_files:
# INSTANTIATE ESSENTIA ALGORITHMS
# ===============================
loader = estd.MonoLoader(filename=audio_folder + '/' + item,
sampleRate=sample_rate)
cut = estd.FrameCutter(frameSize=window_size, hopSize=hop_size)
window = estd.Windowing(size=window_size, type=window_type)
rfft = estd.Spectrum(size=window_size)
sw = estd.SpectralWhitening(maxFrequency=max_frequency,
sampleRate=sample_rate)
speaks = estd.SpectralPeaks(magnitudeThreshold=magnitude_threshold,
maxFrequency=max_frequency,
minFrequency=min_frequency,
maxPeaks=max_peaks,
sampleRate=sample_rate)
hpcp = estd.HPCP(bandPreset=band_preset,
harmonics=harmonics,
maxFrequency=max_frequency,
minFrequency=min_frequency,
nonLinear=non_linear,
normalized=normalize,
referenceFrequency=reference_frequency,
sampleRate=sample_rate,
size=hpcp_size,
splitFrequency=split_frequency,
weightType=weight_type,
windowSize=weight_window_size)
key = estd.Key(numHarmonics=num_harmonics,
pcpSize=hpcp_size,
profileType=profile_type,
slope=slope,
usePolyphony=use_polyphony,
useThreeChords=use_three_chords)
# ACTUAL ANALYSIS
# ===============
audio = loader()
duration = len(audio)
if skip_first_minute and duration > (sample_rate * 60):
audio = audio[sample_rate * 60:]
duration = len(audio)
if first_n_secs > 0:
if duration > (first_n_secs * sample_rate):
audio = audio[:first_n_secs * sample_rate]
duration = len(audio)
if avoid_edges > 0:
initial_sample = (avoid_edges * duration) / 100
final_sample = duration - initial_sample
audio = audio[initial_sample:final_sample]
duration = len(audio)
number_of_frames = duration / hop_size
chroma = []
for bang in range(number_of_frames):
spek = rfft(window(cut(audio)))
p1, p2 = speaks(spek) # p1 are frequencies; p2 magnitudes
if spectral_whitening:
p2 = sw(spek, p1, p2)
vector = hpcp(p1, p2)
sum_vector = np.sum(vector)
if sum_vector > 0:
if shift_spectrum == False or shift_scope == 'average':
chroma.append(vector)
elif shift_spectrum and shift_scope == 'frame':
vector = shift_vector(vector, hpcp_size)
chroma.append(vector)
else:
print "shift_scope must be set to 'frame' or 'average'"
chroma = np.mean(chroma, axis=0)
if shift_spectrum and shift_scope == 'average':
chroma = shift_vector(chroma, hpcp_size)
estimation = key(chroma.tolist())
result = estimation[0] + ' ' + estimation[1]
confidence = estimation[2]
if results_to_csv:
chroma = list(chroma)
# MIREX EVALUATION:
# ================
if analysis_mode == 'title':
ground_truth = item[item.find(' = ') + 3:item.rfind(' < ')]
if verbose and confidence < confidence_threshold:
print item[:item.rfind(' = ')]
print 'G:', ground_truth, '|| P:',
if results_to_csv:
title = item[:item.rfind(' = ')]
lineWriter.writerow([
title, ground_truth, chroma[0], chroma[1], chroma[2],
chroma[3], chroma[4], chroma[5], chroma[6], chroma[7],
chroma[8], chroma[9], chroma[10], chroma[11], chroma[12],
chroma[13], chroma[14], chroma[15], chroma[16], chroma[17],
chroma[18], chroma[19], chroma[20], chroma[21], chroma[22],
chroma[23], chroma[24], chroma[25], chroma[26], chroma[27],
chroma[28], chroma[29], chroma[30], chroma[31], chroma[32],
chroma[33], chroma[34], chroma[35], result
])
ground_truth = key_to_list(ground_truth)
estimation = key_to_list(result)
score = mirex_score(ground_truth, estimation)
mirex_scores.append(score)
else:
filename_to_match = item[:item.rfind('.')] + '.txt'
print filename_to_match
if filename_to_match in groundtruth_files:
groundtruth_file = open(
groundtruth_folder + '/' + filename_to_match, 'r')
ground_truth = groundtruth_file.readline()
if "\t" in ground_truth:
ground_truth = re.sub("\t", " ", ground_truth)
if results_to_csv:
lineWriter.writerow([
filename_to_match, chroma[0], chroma[1], chroma[2],
chroma[3], chroma[4], chroma[5], chroma[6], chroma[7],
chroma[8], chroma[9], chroma[10], chroma[11],
chroma[12], chroma[13], chroma[14], chroma[15],
chroma[16], chroma[17], chroma[18], chroma[19],
chroma[20], chroma[21], chroma[22], chroma[23],
chroma[24], chroma[25], chroma[26], chroma[27],
chroma[28], chroma[29], chroma[30], chroma[31],
chroma[32], chroma[33], chroma[34], chroma[35], result
])
ground_truth = key_to_list(ground_truth)
estimation = key_to_list(result)
score = mirex_score(ground_truth, estimation)
mirex_scores.append(score)
else:
print "FILE NOT FOUND... Skipping it from evaluation.\n"
continue
# CONFUSION MATRIX:
# ================
if confusion_matrix:
xpos = (ground_truth[0] +
(ground_truth[0] * 24)) + (-1 *
(ground_truth[1] - 1) * 24 * 12)
ypos = ((estimation[0] - ground_truth[0]) +
(-1 * (estimation[1] - 1) * 12))
matrix[(xpos + ypos)] = +matrix[(xpos + ypos)] + 1
if verbose and confidence < confidence_threshold:
print result, '(%.2f)' % confidence, '|| SCORE:', score, '\n'
# WRITE RESULTS TO FILE:
# =====================
if results_to_file:
with open(temp_folder + '/' + item[:-3] + 'txt', 'w') as textfile:
textfile.write(result)
textfile.close()
if results_to_csv:
csvFile.close()
print len(mirex_scores), "files analysed in", reloj(), "secs.\n"
if confusion_matrix:
matrix = np.matrix(matrix)
matrix = matrix.reshape(24, 24)
print matrix
if results_to_file:
np.savetxt(
temp_folder + '/_confusion_matrix.csv',
matrix,
fmt='%i',
delimiter=',',
header=
'C,C#,D,Eb,E,F,F#,G,G#,A,Bb,B,Cm,C#m,Dm,Ebm,Em,Fm,F#m,Gm,G#m,Am,Bbm,Bm'
)
# MIREX RESULTS
# =============
evaluation_results = mirex_evaluation(mirex_scores)
# WRITE INFO TO FILE
# ==================
if results_to_file:
settings = "SETTINGS\n========\nAvoid edges ('%' of duration disregarded at both ends (0 = complete)) = " + str(
avoid_edges
) + "\nfirst N secs = " + str(
first_n_secs
) + "\nshift spectrum to fit tempered scale = " + str(
shift_spectrum
) + "\nspectral whitening = " + str(
spectral_whitening
) + "\nsample rate = " + str(sample_rate) + "\nwindow size = " + str(
window_size
) + "\nhop size = " + str(hop_size) + "\nmagnitude threshold = " + str(
magnitude_threshold
) + "\nminimum frequency = " + str(
min_frequency
) + "\nmaximum frequency = " + str(
max_frequency
) + "\nmaximum peaks = " + str(max_peaks) + "\nband preset = " + str(
band_preset
) + "\nsplit frequency = " + str(
split_frequency
) + "\nharmonics = " + str(harmonics) + "\nnon linear = " + str(
non_linear
) + "\nnormalize = " + str(
normalize
) + "\nreference frequency = " + str(
reference_frequency
) + "\nhpcp size = " + str(
hpcp_size
) + "\nweigth type = " + weight_type + "\nweight window size in semitones = " + str(
weight_window_size
) + "\nharmonics key = " + str(num_harmonics) + "\nslope = " + str(
slope) + "\nprofile = " + profile_type + "\npolyphony = " + str(
use_polyphony) + "\nuse three chords = " + str(
use_three_chords)
results_for_file = "\n\nEVALUATION RESULTS\n==================\nCorrect: " + str(
evaluation_results[0]) + "\nFifth: " + str(
evaluation_results[1]) + "\nRelative: " + str(
evaluation_results[2]) + "\nParallel: " + str(
evaluation_results[3]) + "\nError: " + str(
evaluation_results[4]) + "\nWeighted: " + str(
evaluation_results[5])
write_to_file = open(temp_folder + '/_SUMMARY.txt', 'w')
write_to_file.write(settings)
write_to_file.write(results_for_file)
if analysis_mode == 'title':
corpus = "\n\nANALYSIS CORPUS\n===============\n" + str(
collection) + '\n' + str(
genre) + '\n' + str(modality) + '\n\n' + str(
len(mirex_scores)) + " files analysed.\n"
write_to_file.write(corpus)
write_to_file.close()
def __init__(self,
bassline_filename,
drum_filename,
grid,
frame_size,
hop_size,
fft_size,
sample_rate,
xlim,
beats=[],
onsets=[],
bassline_onsets=[],
midi_tracks=[],
drum_analysisResults=[],
parent=None,
group_title="TRANSCRIBER",
prefix_text=[],
PYIN_midi=[],
YIN_times=[]):
self._width = 12
self._height = 7
self._dpi = 100
#
self.drum_analysisResults = drum_analysisResults
self.grid = grid
# Create QGroupBox and set the parent canvas (if any)
QtWidgets.QGroupBox.__init__(self, group_title)
self.setParent(parent)
self.tabs_widget = QtWidgets.QTabWidget(self)
if bassline_filename:
self.bassline_widget = QtWidgets.QWidget(self)
self.chroma_widget = QtWidgets.QWidget(self)
self.tabs_widget.addTab(self.bassline_widget, "Spectrogram")
self.tabs_widget.addTab(self.chroma_widget, "Chroma")
self.saveFileName = os.path.join(
os.path.dirname(bassline_filename), prefix_text + ".txt")
if drum_filename:
self.drum_spectrogram_widget = QtWidgets.QWidget(self)
self.drum_widget = QtWidgets.QWidget(self)
self.tabs_widget.addTab(self.drum_spectrogram_widget,
"drums spectrogram")
self.tabs_widget.addTab(
self.drum_widget, "drums transcription (onsets in band bands)")
self.saveFileName = os.path.join(os.path.dirname(drum_filename),
prefix_text + ".txt")
self.main_layout = QtWidgets.QGridLayout(self)
self.main_layout.setAlignment(Qt.AlignCenter)
self.resize(1200, 800)
self.main_layout.addWidget(self.tabs_widget, 0, 0)
self.main_layout.setColumnStretch(0, 1)
self.main_layout.setRowStretch(0, 1)
# ------ --------- --------- Drum Spectrogram ------ STARTS HERE
if drum_filename:
options = {
"filename": drum_filename,
"fft_size": fft_size,
"frame_size": frame_size,
"hop_size": hop_size,
"sample_rate": sample_rate,
"xlim": xlim,
"ylim": (20, 500),
"width": self._width,
"height": self._height,
"dpi": self._dpi,
"y_isHz": False,
"playable": False,
"saveFilename": self.saveFileName
}
self.DrumSpectrogramCanvas = SpectrogramCanvas(
parent=self.drum_spectrogram_widget, **options)
# Draw Beats
for beat in beats:
self.DrumSpectrogramCanvas.get_stft_ax().axvline(x=beat,
ymin=0,
ymax=1000,
color='g')
# Draw Onsets
for onset in onsets:
self.DrumSpectrogramCanvas.get_stft_ax().scatter(onset,
50,
c='red',
marker='o')
# ------ --------- --------- Drum Spectrogram ------ ENDS HERE
# ------ --------- --------- Drum Transcription ------ STARTS HERE
self.drum_onset_dots = []
self.DrumCanvas = DrumCanvas(parent=self.drum_widget, **options)
# connect save button
self.key_pressed_cid = self.DrumCanvas.get_fig(
).canvas.mpl_connect('key_press_event', self.on_drum_key_press)
if self.drum_analysisResults:
self.draw_drum_results(self.DrumCanvas.get_fig(),
self.DrumCanvas.get_ax())
for grid_line in self.grid:
self.DrumCanvas.get_ax().axvline(x=grid_line,
ymin=0,
ymax=1000,
color='b')
for beat in beats:
self.DrumCanvas.get_ax().axvline(x=beat,
ymin=0,
ymax=1000,
color='g')
for onset in onsets:
self.DrumCanvas.get_ax().scatter(onset,
0.5,
c='red',
marker='o')
self.bassline_filename = None
# ------ --------- --------- Drum Transcription ------ ENDS HERE
# ------ --------- --------- Bassline Transcription ------ STARTS HERE
if bassline_filename:
options = {
"filename": bassline_filename,
"fft_size": fft_size,
"frame_size": frame_size,
"hop_size": hop_size,
"sample_rate": sample_rate,
"xlim": xlim,
"ylim": (20, 500),
"width": self._width,
"height": self._height,
"dpi": self._dpi,
"y_isHz": False,
"playable": False,
"saveFilename": self.saveFileName
}
self.BasslineCanvas = SpectrogramCanvas(
parent=self.bassline_widget, **options)
self.chromaCanvas = ChromaCanvas(parent=self.chroma_widget,
**options)
# Load Audio for chroma calculations
loader = es.MonoLoader(filename=bassline_filename,
sampleRate=sample_rate)
self.audio = loader()
xvals = np.arange(len(self.audio)) / float(sample_rate)
xlim = [0, max(xvals) + .25]
self.chromaCanvas.get_ax().set_xlim(xlim)
# Calculate Chromagram
self.chromagram = []
hpcp = es.HPCP(
size=12, # we will need higher resolution for Key estimation
referenceFrequency=440, # assume tuning frequency is 44100.
bandPreset=False,
weightType='cosine',
nonLinear=False,
windowSize=1.,
sampleRate=sample_rate)
spectrum = es.Spectrum(size=fft_size)
spectral_peaks = es.SpectralPeaks(sampleRate=sample_rate)
for frame in es.FrameGenerator(self.audio,
frameSize=8192,
hopSize=hop_size,
startFromZero=True):
frame = array(frame * get_window("hann", 8192))
freqs, mags = spectral_peaks(spectrum(frame))
chroma = hpcp(freqs, mags)
self.chromagram.append(chroma)
self.chromagram = array(self.chromagram)
self.timeAxSec = np.arange(len(
self.chromagram)) * hop_size / (sample_rate)
# plot chromagram
pitchClasses = [
"A", "A#", "B", "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#"
]
self.chromaCanvas.get_ax().cla()
self.chromaCanvas.get_ax().set_xlim(xlim)
self.chromaCanvas.get_ax().set_ylim(*(-1, 13))
y_ax = np.arange(13)
self.chromaCanvas.get_ax().set_yticks(y_ax[:12] + .5)
self.chromaCanvas.get_ax().set_yticklabels(pitchClasses)
self.chromaCanvas.get_ax().pcolormesh(self.timeAxSec, y_ax,
self.chromagram.T)
self.chromaCanvas.get_ax().set_ylabel("Pitch Class")
self.chromaCanvas.get_fig().canvas.draw()
self.InteractiveCanvas = MidiCanvas(
parent=self.bassline_widget,
ax=self.BasslineCanvas.get_stft_ax(),
fig=self.BasslineCanvas.get_stft_fig(),
horizontal_snap_grid=grid,
snapVerticallyFlag=True,
snap_offset_flag=True,
doubleClickColor="y",
xlim=xlim,
ylim=(20, 500),
width=self._width,
height=self._height,
dpi=self._dpi,
x_sensitivity=.02,
y_sensitivity=5,
standalone=False,
y_isHz=False,
midi_tracks=midi_tracks,
filename=bassline_filename,
ax_chroma=self.chromaCanvas.get_ax(),
fig_chroma=self.chromaCanvas.get_fig(),
saveFileName=self.saveFileName)
# Draw Beats
for beat in beats:
self.BasslineCanvas.get_stft_ax().axvline(x=beat,
ymin=0,
ymax=1000,
color='g')
self.chromaCanvas.get_ax().axvline(x=beat,
ymin=0,
ymax=1000,
color='g')
# Draw Onsets
for onset in bassline_onsets:
self.BasslineCanvas.get_stft_ax().scatter(onset,
50,
c='red',
marker='o')
if PYIN_midi != []:
self.BasslineCanvas.get_stft_ax().plot(YIN_times, PYIN_midi)
self.BasslineCanvas.get_stft_ax().set_title(
"Green: Beats, Red: Onsets, Blue: Grid")
self.chromaCanvas.get_ax().set_title("Green: Beats")
# show canvases
self.BasslineCanvas.get_stft_fig().canvas.show()
self.chromaCanvas.get_fig().canvas.show()
# ------ --------- --------- Bassline Transcription ------ ENDS HERE
self.show()
import essentia.standard as ess
# matplotlib without any blocking GUI
import matplotlib as mpl
mpl.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
M = 1024
N = 1024
H = 512
fs = 44100
spectrum = ess.Spectrum(size=N)
window = ess.Windowing(size=M, type='hann')
spectralPeaks = ess.SpectralPeaks()
hpcp = ess.HPCP()
x = ess.MonoLoader(filename='../../../sounds/cello-double.wav',
sampleRate=fs)()
hpcps = []
for frame in ess.FrameGenerator(x, frameSize=M, hopSize=H, startFromZero=True):
mX = spectrum(window(frame))
spectralPeaks_freqs, spectralPeaks_mags = spectralPeaks(mX)
hpcp_vals = hpcp(spectralPeaks_freqs, spectralPeaks_mags)
hpcps.append(hpcp_vals)
hpcps = np.array(hpcps)
plt.figure(1, figsize=(9.5, 7))
plt.subplot(2, 1, 1)
plt.plot(np.arange(x.size) / float(fs), x, 'b')
plt.show()
audio = es.MonoLoader(filename=filename)()
rhythm_extractor = es.RhythmExtractor2013(method="multifeature")
bpm, beats, beats_confidence, _, beats_intervals = rhythm_extractor(audio)
print("bpm", bpm)
bps = 2 #bpm / 60
print("bps", bps)
hpcps = []
for b in range(int(track_length_sec * bps)):
parts = 5
spectrum = None
for i in range(parts):
frame = audio[int(b * fs_rate + i * fs_rate / bps / parts):int(
b * fs_rate + (i + 1) * fs_rate / bps / parts)] # for one beat
# frame = audio[s *fs_rate: (s+1)* fs_rate]
if spectrum is None:
spectrum = es.Spectrum()(frame)
else:
spectrum += es.Spectrum()(frame)
es_frequencies, es_magnitudes = es.SpectralPeaks()(spectrum)
hpcp = es.HPCP()(es_frequencies, es_magnitudes)
hpcps.append(hpcp)
for h in hpcps:
names = [
"a", "b", "h", "c", "cis", "d", "dis", "e", "f", "fis", "g", "gis"
]
print([f"{name}-{v:0.2}" for name, v in zip(names, h) if v > 0.1])
chords = es.ChordsDetection()(essentia.array(hpcps))
print(chords)
def gen_frame_HPCP(spectral_info):
"""Generates HPCP for a single frame"""
spectrum, freqs, mags = spectral_info
return es.HPCP(**HPCP_params)(freqs, mags)
