Example #1
0
    def __init__(self,
                 samplerate=44100,
                 winsize=1024,
                 hopsize=512,
                 filters=40,
                 coeffs=13):
        super(AubioAnalyser, self).__init__()
        self.winsize = winsize
        self.hopsize = hopsize
        self.coeffs = coeffs
        self.filters = filters
        self.descriptors = {}
        self.methods = [
            "default", "energy", "hfc", "complex", "phase", "specdiff", "kl",
            "mkl", "specflux", "centroid", "slope", "rolloff", "spread",
            "skewness", "kurtosis", "decrease"
        ]

        for method in self.methods:
            self.descriptors[method] = aubio.specdesc(method, self.winsize)

        self.pvocoder = aubio.pvoc(self.winsize, self.hopsize)
        self.mfcc_feature = aubio.mfcc(winsize, filters, coeffs, samplerate)
        self.mfccs = numpy.zeros([
            self.coeffs,
        ])
Example #2
0
 def test_kl(self):
     o = specdesc("kl")
     c = cvec()
     assert_equal(0.0, o(c))
     a = arange(c.length, dtype="float32")
     c.norm = a
     assert_almost_equal(sum(a * log(1.0 + a / 1.0e-1)) / o(c), 1.0, decimal=6)
Example #3
0
 def test_mkl(self):
     o = specdesc("mkl")
     c = cvec()
     assert_equal( 0., o(c))
     a = arange(c.length, dtype=float_type)
     c.norm = a
     assert_almost_equal( sum(log(1.+ a/1.e-1 ) ) / o(c), 1, decimal=6)
Example #4
0
 def test_kl(self):
     o = specdesc("kl")
     c = cvec()
     assert_equal( 0., o(c))
     a = arange(c.length, dtype='float32')
     c.norm = a
     assert_almost_equal( sum(a * log(1.+ a/1.e-1 ) ) / o(c), 1., decimal=6)
Example #5
0
    def test_members(self):
        o = specdesc()

        for method in methods:
          o = specdesc(method, buf_size)
          assert_equal ([o.buf_size, o.method], [buf_size, method])

          spec = cvec(buf_size)
          spec.norm[0] = 1
          spec.norm[1] = 1./2.
          #print "%20s" % method, str(o(spec))
          o(spec)
          spec.norm = random.random_sample((len(spec.norm),)).astype('float32')
          spec.phas = random.random_sample((len(spec.phas),)).astype('float32')
          #print "%20s" % method, str(o(spec))
          assert (o(spec) != 0.)
Example #6
0
    def test_members(self):
        o = specdesc()

        for method in methods:
            o = specdesc(method, buf_size)
            assert_equal ([o.buf_size, o.method], [buf_size, method])

            spec = cvec(buf_size)
            spec.norm[0] = 1
            spec.norm[1] = 1./2.
            #print "%20s" % method, str(o(spec))
            o(spec)
            spec.norm = random.random_sample((len(spec.norm),)).astype(float_type)
            spec.phas = random.random_sample((len(spec.phas),)).astype(float_type)
            #print "%20s" % method, str(o(spec))
            assert (o(spec) != 0.)
Example #7
0
 def test_hfc(self):
     o = specdesc("hfc")
     c = cvec()
     assert_equal( 0., o(c))
     a = arange(c.length, dtype=float_type)
     c.norm = a
     assert_equal (a, c.norm)
     assert_equal ( sum(a*(a+1)), o(c))
Example #8
0
 def test_hfc(self):
     o = specdesc("hfc")
     c = cvec()
     assert_equal( 0., o(c))
     a = arange(c.length, dtype='float32')
     c.norm = a
     assert_equal (a, c.norm)
     assert_equal ( sum(a*(a+1)), o(c))
Example #9
0
 def test_phase(self):
     o = specdesc("phase", buf_size)
     spec = cvec(buf_size)
     # phase of zeros is zero
     assert_equal(o(spec), 0.0)
     spec.phas = random.random_sample((len(spec.phas),)).astype("float32")
     # phase of random is not zero
     spec.norm[:] = 1
     assert o(spec) != 0.0
Example #10
0
 def test_specdiff(self):
     o = specdesc("phase", buf_size)
     spec = cvec(buf_size)
     # specdiff of zeros is zero
     assert_equal (o(spec), 0.)
     spec.phas = random.random_sample((len(spec.phas),)).astype(float_type)
     # phase of random is not zero
     spec.norm[:] = 1
     assert (o(spec) != 0.)
Example #11
0
 def test_specdiff(self):
     o = specdesc("phase", buf_size)
     spec = cvec(buf_size)
     # specdiff of zeros is zero
     assert_equal (o(spec), 0.)
     spec.phas = random.random_sample((len(spec.phas),)).astype('float32')
     # phase of random is not zero
     spec.norm[:] = 1
     assert (o(spec) != 0.)
Example #12
0
 def test_specflux(self):
     o = specdesc("specflux")
     c = cvec()
     assert_equal( 0., o(c))
     a = arange(c.length, dtype=float_type)
     c.norm = a
     assert_equal( sum(a), o(c))
     assert_equal( 0, o(c))
     c.norm = zeros(c.length, dtype=float_type)
     assert_equal( 0, o(c))
Example #13
0
 def test_specflux(self):
     o = specdesc("specflux")
     c = cvec()
     assert_equal( 0., o(c))
     a = arange(c.length, dtype='float32')
     c.norm = a
     assert_equal( sum(a), o(c))
     assert_equal( 0, o(c))
     c.norm = zeros(c.length, dtype='float32')
     assert_equal( 0, o(c))
Example #14
0
 def test_kurtosis(self):
     o = specdesc("kurtosis")
     c = cvec()
     assert_equal( 0., o(c))
     a = arange(c.length, dtype=float_type)
     c.norm = a
     centroid = sum(a*a) / sum(a)
     spread = sum( (a - centroid)**2 *a) / sum(a)
     kurtosis = sum( (a - centroid)**4 *a) / sum(a) / spread **2
     assert_almost_equal (kurtosis, o(c), decimal = 2)
Example #15
0
 def test_kurtosis(self):
     o = specdesc("kurtosis")
     c = cvec()
     assert_equal( 0., o(c))
     a = arange(c.length, dtype='float32')
     c.norm = a
     centroid = sum(a*a) / sum(a)
     spread = sum( (a - centroid)**2 *a) / sum(a)
     kurtosis = sum( (a - centroid)**4 *a) / sum(a) / spread **2
     assert_almost_equal (kurtosis, o(c), decimal = 2)
Example #16
0
    def test_spread(self):
        o = specdesc("spread")
        c = cvec(2048)
        ramp = arange(c.length, dtype=float_type)
        assert_equal( 0., o(c))

        a = ramp
        c.norm = a
        centroid = sum(a*a) / sum(a)
        spread = sum( a * pow(ramp - centroid, 2.) ) / sum(a)
        assert_almost_equal (o(c), spread, decimal = 1)
Example #17
0
    def test_spread(self):
        o = specdesc("spread")
        c = cvec(2048)
        ramp = arange(c.length, dtype='float32')
        assert_equal( 0., o(c))

        a = ramp
        c.norm = a
        centroid = sum(a*a) / sum(a)
        spread = sum( a * pow(ramp - centroid, 2.) ) / sum(a)
        assert_almost_equal (o(c), spread, decimal = 1)
Example #18
0
 def test_complex(self):
     o = specdesc("complex")
     c = cvec()
     assert_equal( 0., o(c))
     a = arange(c.length, dtype='float32')
     c.norm = a
     assert_equal (a, c.norm)
     # the previous run was on zeros, so previous frames are still 0
     # so we have sqrt ( abs ( r2 ^ 2) ) == r2
     assert_equal ( sum(a), o(c))
     # second time. c.norm = a, so, r1 = r2, and the euclidian distance is 0
     assert_equal ( 0, o(c))
Example #19
0
 def test_complex(self):
     o = specdesc("complex")
     c = cvec()
     assert_equal( 0., o(c))
     a = arange(c.length, dtype=float_type)
     c.norm = a
     assert_equal (a, c.norm)
     # the previous run was on zeros, so previous frames are still 0
     # so we have sqrt ( abs ( r2 ^ 2) ) == r2
     assert_equal ( sum(a), o(c))
     # second time. c.norm = a, so, r1 = r2, and the euclidian distance is 0
     assert_equal ( 0, o(c))
    def test_spread(self):
        o = specdesc("spread")
        c = cvec()
        assert_equal( 0., o(c))
        a = arange(c.length, dtype='float32')
        c.norm = a
        centroid = sum(a*a) / sum(a)
        spread = sum( (a - centroid)**2 *a) / sum(a)
        assert_almost_equal (spread, o(c), decimal = 2)

        c.norm = a * 3
        assert_almost_equal (spread, o(c), decimal = 2)
Example #21
0
 def test_hfc(self):
     o = specdesc("hfc", buf_size)
     spec = cvec(buf_size)
     # hfc of zeros is zero
     assert_equal(o(spec), 0.0)
     # hfc of ones is sum of all bin numbers
     spec.norm[:] = 1
     expected = sum(range(buf_size / 2 + 2))
     assert_equal(o(spec), expected)
     # changing phase doesn't change anything
     spec.phas[:] = 1
     assert_equal(o(spec), sum(range(buf_size / 2 + 2)))
Example #22
0
    def test_centroid(self):
        o = specdesc("centroid")
        c = cvec()
        # make sure centroid of zeros is zero
        assert_equal( 0., o(c))
        a = arange(c.length, dtype=float_type)
        c.norm = a
        centroid = sum(a*a) / sum(a)
        assert_almost_equal (centroid, o(c), decimal = 2)

        c.norm = a * .5 
        assert_almost_equal (centroid, o(c), decimal = 2)
Example #23
0
 def test_hfc(self):
     o = specdesc("hfc", buf_size)
     spec = cvec(buf_size)
     # hfc of zeros is zero
     assert_equal (o(spec), 0.)
     # hfc of ones is sum of all bin numbers
     spec.norm[:] = 1
     expected = sum(range(buf_size/2 + 2))
     assert_equal (o(spec), expected)
     # changing phase doesn't change anything
     spec.phas[:] = 1
     assert_equal (o(spec), sum(range(buf_size/2 + 2)))
Example #24
0
    def test_centroid(self):
        o = specdesc("centroid")
        c = cvec()
        # make sure centroid of zeros is zero
        assert_equal( 0., o(c))
        a = arange(c.length, dtype='float32')
        c.norm = a
        centroid = sum(a*a) / sum(a)
        assert_almost_equal (centroid, o(c), decimal = 2)

        c.norm = a * .5 
        assert_almost_equal (centroid, o(c), decimal = 2)
Example #25
0
    def test_skewness(self):
        o = specdesc("skewness")
        c = cvec()
        assert_equal( 0., o(c))
        a = arange(c.length, dtype='float32')
        c.norm = a
        centroid = sum(a*a) / sum(a)
        spread = sum( (a - centroid)**2 *a) / sum(a)
        skewness = sum( (a - centroid)**3 *a) / sum(a) / spread **1.5
        assert_almost_equal (skewness, o(c), decimal = 2)

        c.norm = a * 3
        assert_almost_equal (skewness, o(c), decimal = 2)
Example #26
0
 def test_rolloff(self):
     o = specdesc("rolloff")
     c = cvec()
     assert_equal( 0., o(c))
     a = arange(c.length * 2, 0, -2, dtype=float_type)
     c.norm = a
     cumsum = .95*sum(a*a)
     i = 0; rollsum = 0
     while rollsum < cumsum:
         rollsum += a[i]*a[i]
         i+=1
     rolloff = i 
     assert_equal (rolloff, o(c))
Example #27
0
    def test_skewness(self):
        o = specdesc("skewness")
        c = cvec()
        assert_equal( 0., o(c))
        a = arange(c.length, dtype=float_type)
        c.norm = a
        centroid = sum(a*a) / sum(a)
        spread = sum( (a - centroid)**2 *a) / sum(a)
        skewness = sum( (a - centroid)**3 *a) / sum(a) / spread **1.5
        assert_almost_equal (skewness, o(c), decimal = 2)

        c.norm = a * 3
        assert_almost_equal (skewness, o(c), decimal = 2)
Example #28
0
    def __init__(self):
        super(AubioSpecdesc, self).__init__()
        self.input_blocksize = 1024
        self.input_stepsize = self.input_blocksize / 4

        # Aubio Specdesc Initialisation
        self.block_read = 0
        self.pvoc = pvoc(self.input_blocksize, self.input_stepsize)
        self.methods = [
            'default', 'energy', 'hfc', 'complex', 'phase', 'specdiff', 'kl',
            'mkl', 'specflux', 'centroid', 'slope', 'rolloff', 'spread', 'skewness',
            'kurtosis', 'decrease']
        self.specdesc = {}
        self.specdesc_results = {}
        for method in self.methods:
            self.specdesc[method] = specdesc(method, self.input_blocksize)
            self.specdesc_results[method] = []
Example #29
0
    def __init__(self, samplerate=44100, winsize=1024, hopsize=512, filters=40,
                 coeffs=13):
        super(AubioAnalyser, self).__init__()
        self.winsize = winsize
        self.hopsize = hopsize
        self.coeffs = coeffs
        self.filters = filters
        self.descriptors = {}
        self.methods = ["default", "energy", "hfc", "complex", "phase",
                        "specdiff", "kl", "mkl", "specflux", "centroid",
                        "slope", "rolloff", "spread", "skewness", "kurtosis",
                        "decrease"]

        for method in self.methods:
            self.descriptors[method] = aubio.specdesc(method, self.winsize)

        self.pvocoder = aubio.pvoc(self.winsize, self.hopsize)
        self.mfcc_feature = aubio.mfcc(winsize, filters, coeffs, samplerate)
        self.mfccs = numpy.zeros([self.coeffs, ])
Example #30
0
 def setup(self,
           channels=None,
           samplerate=None,
           blocksize=None,
           totalframes=None):
     super(AubioSpecdesc, self).setup(channels, samplerate, blocksize,
                                      totalframes)
     self.block_read = 0
     self.pvoc = pvoc(self.input_blocksize, self.input_stepsize)
     self.methods = [
         'default', 'energy', 'hfc', 'complex', 'phase', 'specdiff', 'kl',
         'mkl', 'specflux', 'centroid', 'slope', 'rolloff', 'spread',
         'skewness', 'kurtosis', 'decrease'
     ]
     self.specdesc = {}
     self.specdesc_results = {}
     for method in self.methods:
         self.specdesc[method] = specdesc(method, self.input_blocksize)
         self.specdesc_results[method] = []
Example #31
0
    def test_decrease(self):
        o = specdesc("decrease")
        c = cvec()
        assert_equal( 0., o(c))
        a = arange(c.length * 2, 0, -2, dtype=float_type)
        k = arange(c.length, dtype=float_type)
        c.norm = a
        decrease = sum((a[1:] - a [0]) / k[1:]) / sum(a[1:]) 
        assert_almost_equal (decrease, o(c), decimal = 5)

        a = arange(0, c.length * 2, +2, dtype=float_type)
        c.norm = a
        decrease = sum((a[1:] - a [0]) / k[1:]) / sum(a[1:]) 
        assert_almost_equal (decrease, o(c), decimal = 5)

        a = arange(0, c.length * 2, +2, dtype=float_type)
        c.norm = a * 2
        decrease = sum((a[1:] - a [0]) / k[1:]) / sum(a[1:]) 
        assert_almost_equal (decrease, o(c), decimal = 5)
Example #32
0
    def test_decrease(self):
        o = specdesc("decrease")
        c = cvec()
        assert_equal( 0., o(c))
        a = arange(c.length * 2, 0, -2, dtype='float32')
        k = arange(c.length, dtype='float32')
        c.norm = a
        decrease = sum((a[1:] - a [0]) / k[1:]) / sum(a[1:]) 
        assert_almost_equal (decrease, o(c), decimal = 5)

        a = arange(0, c.length * 2, +2, dtype='float32')
        c.norm = a
        decrease = sum((a[1:] - a [0]) / k[1:]) / sum(a[1:]) 
        assert_almost_equal (decrease, o(c), decimal = 5)

        a = arange(0, c.length * 2, +2, dtype='float32')
        c.norm = a * 2
        decrease = sum((a[1:] - a [0]) / k[1:]) / sum(a[1:]) 
        assert_almost_equal (decrease, o(c), decimal = 5)
Example #33
0
 def setup(self, channels=None, samplerate=None,
           blocksize=None, totalframes=None):
     super(
         AubioSpecdesc,
         self).setup(
         channels,
         samplerate,
         blocksize,
         totalframes)
     self.block_read = 0
     self.pvoc = pvoc(self.input_blocksize, self.input_stepsize)
     self.methods = [
         'default', 'energy', 'hfc', 'complex', 'phase', 'specdiff', 'kl',
         'mkl', 'specflux', 'centroid', 'slope', 'rolloff', 'spread', 'skewness',
         'kurtosis', 'decrease']
     self.specdesc = {}
     self.specdesc_results = {}
     for method in self.methods:
         self.specdesc[method] = specdesc(method, self.input_blocksize)
         self.specdesc_results[method] = []
Example #34
0
    def __init__(self, sample_rate=None, buffersize=None):
        self.sample_rate = sample_rate or self.sample_rate
        self.buffersize = buffersize or self.buffersize
        self.window_size = self.buffersize * 2
        self.stream = None

        self.onset = aubio.onset(
            'specflux', self.window_size, self.buffersize, self.sample_rate)
        self.onset.set_threshold(0.3)
        self.onset.set_silence(-20.)
        self.tempo = aubio.tempo(
            'default', self.window_size, self.buffersize, self.sample_rate)

        self.energy = aubio.specdesc('specflux', self.buffersize * 2)
        self.pv = aubio.pvoc(self.buffersize * 2, self.buffersize)

        self.pitch = aubio.pitch(
            "yinfft", self.window_size, self.buffersize, self.sample_rate)
        self.pitch.set_unit("midi")
        self.pitch.set_tolerance(0.8)

        self.py_audio = pyaudio.PyAudio()
Example #35
0
    def test_slope(self):
        o = specdesc("slope")
        c = cvec()
        assert_equal( 0., o(c))
        a = arange(c.length * 2, 0, -2, dtype=float_type)
        k = arange(c.length, dtype=float_type)
        c.norm = a
        num = len(a) * sum(k*a) - sum(k)*sum(a)
        den = (len(a) * sum(k**2) - sum(k)**2)
        slope = num/den/sum(a)
        assert_almost_equal (slope, o(c), decimal = 5)

        a = arange(0, c.length * 2, +2, dtype=float_type)
        c.norm = a
        num = len(a) * sum(k*a) - sum(k)*sum(a)
        den = (len(a) * sum(k**2) - sum(k)**2)
        slope = num/den/sum(a)
        assert_almost_equal (slope, o(c), decimal = 5)

        a = arange(0, c.length * 2, +2, dtype=float_type)
        c.norm = a * 2
        assert_almost_equal (slope, o(c), decimal = 5)
Example #36
0
    def test_slope(self):
        o = specdesc("slope")
        c = cvec()
        assert_equal( 0., o(c))
        a = arange(c.length * 2, 0, -2, dtype='float32')
        k = arange(c.length, dtype='float32')
        c.norm = a
        num = len(a) * sum(k*a) - sum(k)*sum(a)
        den = (len(a) * sum(k**2) - sum(k)**2)
        slope = num/den/sum(a)
        assert_almost_equal (slope, o(c), decimal = 5)

        a = arange(0, c.length * 2, +2, dtype='float32')
        c.norm = a
        num = len(a) * sum(k*a) - sum(k)*sum(a)
        den = (len(a) * sum(k**2) - sum(k)**2)
        slope = num/den/sum(a)
        assert_almost_equal (slope, o(c), decimal = 5)

        a = arange(0, c.length * 2, +2, dtype='float32')
        c.norm = a * 2
        assert_almost_equal (slope, o(c), decimal = 5)
Example #37
0
s = source(filename, samplerate, hop_s)
samplerate = s.samplerate

pv = pvoc(win_s, hop_s)

methods = ['default', 'energy', 'hfc', 'complex', 'phase', 'specdiff', 'kl',
        'mkl', 'specflux', 'centroid', 'slope', 'rolloff', 'spread', 'skewness',
        'kurtosis', 'decrease',]

all_descs = {}
o = {}

for method in methods:
    cands = []
    all_descs[method] = np.array([])
    o[method] = specdesc(method, win_s)

total_frames = 0
downsample = 2

while True:
    samples, read = s()
    fftgrain = pv(samples)
    #outstr = "%f" % ( total_frames / float(samplerate) )
    for method in methods:
        specdesc_val = o[method](fftgrain)[0]
        all_descs[method] = np.append(all_descs[method], specdesc_val)
        #outstr += " %f" % specdesc_val
    #print(outstr)
    total_frames += read
    if read < hop_s: break
Example #38
0
 def test_unknown(self):
     with self.assertRaises(RuntimeError):
         specdesc("unknown", 512)
 def test_phase(self):
     o = specdesc("phase")
     c = cvec()
     assert_equal( 0., o(c))
 def test_members(self):
     o = specdesc()
     assert_equal ([o.buf_size, o.method],
         [1024, "default"])
Example #41
0
 def test_negative(self):
     with self.assertRaises(ValueError):
         specdesc("default", -10)
Example #42
0
 def test_unknown(self):
     # FIXME should fail?
     with self.assertRaises(ValueError):
         specdesc("unknown", 512)
         self.skipTest('todo: new_specdesc should fail on wrong method')
Example #43
0
 def test_unknown(self):
     with self.assertRaises(RuntimeError):
         specdesc("unknown", 512)