Changeset 1a6ef2c

Timestamp:

Dec 25, 2009, 4:57:49 AM (14 years ago)

Author:

Paul Brossier <piem@piem.org>

Branches:

feature/autosink, feature/cnn, feature/cnn_org, feature/constantq, feature/crepe, feature/crepe_org, feature/pitchshift, feature/pydocstrings, feature/timestretch, fix/ffmpeg5, master, pitchshift, sampler, timestretch, yinfft+

Children:

9c9cd54

Parents:

84e0606

Message:

test_*.py: switch to mono, add tests for cvec

Location:

interfaces/python

Files:

• test_cvec.py (added)
• test_fft.py (modified) (5 diffs)
• test_filter.py (modified) (4 diffs)
• test_filterbank.py (modified) (4 diffs)
• test_fvec.py (modified) (2 diffs)
• test_onsetdetection.py (modified) (4 diffs)
• test_phasevoc.py (modified) (3 diffs)

interfaces/python/test_fft.py

@@ -2 +2 @@
 from numpy.testing import assert_equal, assert_almost_equal
 # WARNING: numpy also has an fft object
-from _aubio import fft, fvec, cvec
+from _aubio import fft, cvec
+from aubio import fvec
 from numpy import array, shape
 from math import pi
@@ -10 +11 @@
   def test_members(self):
     f = fft()
-    assert_equal ([f.win_s, f.channels], [1024, 1])
-    f = fft(2048, 4)
-    assert_equal ([f.win_s, f.channels], [2048, 4])
+    assert_equal (f.win_s, 1024)
 
   def test_output_dimensions(self):
     """ check the dimensions of output """
-    win_s, chan = 1024, 3
-    timegrain = fvec(win_s, chan)
-    f = fft(win_s, chan)
+    win_s = 1024
+    timegrain = fvec(win_s)
+    f = fft(win_s)
     fftgrain = f (timegrain)
-    assert_equal (array(fftgrain), 0)
-    assert_equal (shape(fftgrain), (chan * 2, win_s/2+1))
     assert_equal (fftgrain.norm, 0)
-    assert_equal (shape(fftgrain.norm), (chan, win_s/2+1))
+    assert_equal (shape(fftgrain.norm), (win_s/2+1,))
     assert_equal (fftgrain.phas, 0)
-    assert_equal (shape(fftgrain.phas), (chan, win_s/2+1))
+    assert_equal (shape(fftgrain.phas), (win_s/2+1,))
 
   def test_zeros(self):
     """ check the transform of zeros """
-    win_s, chan = 512, 3
-    timegrain = fvec(win_s, chan)
-    f = fft(win_s, chan)
+    win_s = 512
+    timegrain = fvec(win_s)
+    f = fft(win_s)
     fftgrain = f(timegrain)
     assert_equal ( fftgrain.norm == 0, True )
@@ -40 +37 @@
     from random import random
     from math import floor
-    win_s, chan = 256, 1
+    win_s = 256
     i = floor(random()*win_s)
     impulse = pi * random() 
-    f = fft(win_s, chan)
-    timegrain = fvec(win_s, chan)
-    timegrain[0][i] = impulse 
+    f = fft(win_s)
+    timegrain = fvec(win_s)
+    timegrain[i] = impulse 
     fftgrain = f ( timegrain )
-    #self.plot_this ( fftgrain.phas[0] )
+    #self.plot_this ( fftgrain.phas )
     assert_almost_equal ( fftgrain.norm, impulse, decimal = 6 )
     assert_equal ( fftgrain.phas <= pi, True)
@@ -56 +53 @@
     from random import random
     from math import floor
-    win_s, chan = 256, 1
+    win_s = 256
     i = 0 
     impulse = -10. 
-    f = fft(win_s, chan)
-    timegrain = fvec(win_s, chan)
-    timegrain[0][i] = impulse 
+    f = fft(win_s)
+    timegrain = fvec(win_s)
+    timegrain[i] = impulse 
     fftgrain = f ( timegrain )
-    #self.plot_this ( fftgrain.phas[0] )
+    #self.plot_this ( fftgrain.phas )
     assert_almost_equal ( fftgrain.norm, abs(impulse), decimal = 6 )
     if impulse < 0:
       # phase can be pi or -pi, as it is not unwrapped
-      assert_almost_equal ( abs(fftgrain.phas[0][1:-1]) , pi, decimal = 6 )
-      assert_almost_equal ( fftgrain.phas[0][0], pi, decimal = 6)
-      assert_almost_equal ( fftgrain.phas[0][-1], pi, decimal = 6)
+      assert_almost_equal ( abs(fftgrain.phas[1:-1]) , pi, decimal = 6 )
+      assert_almost_equal ( fftgrain.phas[0], pi, decimal = 6)
+      assert_almost_equal ( fftgrain.phas[-1], pi, decimal = 6)
     else:
-      assert_equal ( fftgrain.phas[0][1:-1] == 0, True)
-      assert_equal ( fftgrain.phas[0][0] == 0, True)
-      assert_equal ( fftgrain.phas[0][-1] == 0, True)
+      assert_equal ( fftgrain.phas[1:-1] == 0, True)
+      assert_equal ( fftgrain.phas[0] == 0, True)
+      assert_equal ( fftgrain.phas[-1] == 0, True)
     # now check the resynthesis
     synthgrain = f.rdo ( fftgrain )
@@ -83 +80 @@
 
   def test_impulse_at_zero(self):
-    """ check the transform of one impulse at a index 0 in one channel """
-    win_s, chan = 1024, 2
+    """ check the transform of one impulse at a index 0 """
+    win_s = 1024
     impulse = pi
-    f = fft(win_s, chan)
-    timegrain = fvec(win_s, chan)
-    timegrain[0][0] = impulse 
+    f = fft(win_s)
+    timegrain = fvec(win_s)
+    timegrain[0] = impulse 
     fftgrain = f ( timegrain )
     #self.plot_this ( fftgrain.phas )
     assert_equal ( fftgrain.phas[0], 0)
     assert_equal ( fftgrain.phas[1], 0)
-    assert_almost_equal ( fftgrain.norm[0], impulse, decimal = 6 )
-    assert_equal ( fftgrain.norm[0], impulse)
+    assert_almost_equal (fftgrain.norm[0], impulse, decimal = 6 )
 
   def test_rdo_before_do(self):
     """ check running fft.rdo before fft.do works """
-    win_s, chan = 1024, 2
+    win_s = 1024
     impulse = pi
-    f = fft(win_s, chan)
-    fftgrain = cvec(win_s, chan)
+    f = fft(win_s)
+    fftgrain = cvec(win_s)
     t = f.rdo( fftgrain )
     assert_equal ( t, 0 )

interfaces/python/test_filter.py

@@ -2 +2 @@
 from numpy.testing import assert_equal, assert_almost_equal
 from _aubio import *
+from aubio import fvec
 from numpy import array
 
@@ -12 +13 @@
   def test_members(self):
     f = digital_filter()
-    assert_equal ([f.channels, f.order], [1, 7])
-    f = digital_filter(5, 2)
-    assert_equal ([f.channels, f.order], [2, 5])
+    assert_equal (f.order, 7)
+    f = digital_filter(5)
+    assert_equal (f.order, 5)
     f(fvec())
   
   def test_cweighting_error(self):
-    f = digital_filter (2, 1)
+    f = digital_filter (2)
     self.assertRaises ( ValueError, f.set_c_weighting, 44100 )
-    f = digital_filter (8, 1)
+    f = digital_filter (8)
     self.assertRaises ( ValueError, f.set_c_weighting, 44100 )
-    f = digital_filter (5, 1)
+    f = digital_filter (5)
     self.assertRaises ( ValueError, f.set_c_weighting, 4000 )
-    f = digital_filter (5, 1)
+    f = digital_filter (5)
     self.assertRaises ( ValueError, f.set_c_weighting, 193000 )
-    f = digital_filter (7, 1)
+    f = digital_filter (7)
     self.assertRaises ( ValueError, f.set_a_weighting, 193000 )
-    f = digital_filter (5, 1)
+    f = digital_filter (5)
     self.assertRaises ( ValueError, f.set_a_weighting, 192000 )
 
   def test_c_weighting(self):
     expected = array_from_text_file('c_weighting_test_simple.expected')
-    f = digital_filter(5, 1)
+    f = digital_filter(5)
     f.set_c_weighting(44100)
     v = fvec(32)
-    v[0][12] = .5
+    v[12] = .5
     u = f(v)
     assert_almost_equal (expected[1], u)
@@ -42 +43 @@
   def test_a_weighting(self):
     expected = array_from_text_file('a_weighting_test_simple.expected')
-    f = digital_filter(7, 1)
+    f = digital_filter(7)
     f.set_a_weighting(44100)
     v = fvec(32)
-    v[0][12] = .5
+    v[12] = .5
     u = f(v)
     assert_almost_equal (expected[1], u)
@@ -51 +52 @@
   def test_a_weighting_parted(self):
     expected = array_from_text_file('a_weighting_test_simple.expected')
-    f = digital_filter(7, 1)
+    f = digital_filter(7)
     f.set_a_weighting(44100)
     v = fvec(16)
-    v[0][12] = .5
+    v[12] = .5
     u = f(v)
     assert_almost_equal (expected[1][:16], u)

interfaces/python/test_filterbank.py

@@ -3 +3 @@
 from numpy import array, shape
 from _aubio import *
+#from aubio import cvec
 
 class aubio_filter_test_case(TestCase):
@@ -11 +12 @@
     a = f.get_coeffs()
     a.T
+    assert_equal(shape (a), (40, 512/2 + 1) )
 
   def test_other_slaney(self):
@@ -23 +25 @@
       #print "sum is", sum(sum(a))
 
-  def test_triangle_freqs(self):
+  def test_triangle_freqs_zeros(self):
     f = filterbank(9, 1024)
     freq_list = [40, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 15000, 24000]
@@ -29 +31 @@
     f.set_triangle_bands(freqs, 48000)
     f.get_coeffs().T
-    assert_equal ( f(cvec(1024)), [0] * 9)
+    assert_equal ( f(cvec(1024)), 0)
+
+  def test_triangle_freqs_ones(self):
+    f = filterbank(9, 1024)
+    freq_list = [40, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 15000, 24000]
+    freqs = array(freq_list, dtype = 'float32')
+    f.set_triangle_bands(freqs, 48000)
+    f.get_coeffs().T
     spec = cvec(1024)
-    spec[0][40:100] = 100
-    #print f(spec)
+    spec.norm[:] = 1
+    assert_almost_equal ( f(spec),
+            [ 0.02070313,  0.02138672,  0.02127604,  0.02135417, 
+        0.02133301, 0.02133301,  0.02133311,  0.02133334,  0.02133345])
 
 if __name__ == '__main__':

interfaces/python/test_fvec.py

@@ -2 +2 @@
 from numpy.testing import assert_equal, assert_almost_equal
 from _aubio import *
-from numpy import array
+from aubio import fvec
+from numpy import array, shape
 
 class aubio_fvec_test_case(TestCase):
 
-
     def test_vector_created_with_zeroes(self):
-        a = fvec()
+        a = fvec(10)
+        a
+        shape(a)
+        a[0]
+        #del a
         assert_equal(array(a), 0.)
 
@@ -20 +24 @@
         a[-1] = 1
         assert_equal(a[-1], 1)
-        assert_equal(a[a.length-1], 1)
+        assert_equal(a[len(a)-1], 1)
 
     def test_vector(self):
         a = fvec()
-        a, a.length
+        a, len(a) #a.length
         a[0]
         array(a)
         a = fvec(10)
         a = fvec(1)
+        a.T
         array(a).T
-        a[0] = range(a.length)
+        a = range(len(a))
 
     def test_wrong_values(self):

interfaces/python/test_onsetdetection.py

@@ -2 +2 @@
 from numpy.testing import assert_equal, assert_almost_equal
 # WARNING: numpy also has an fft object
-from _aubio import cvec, specdesc
+from _aubio import specdesc, cvec
 from numpy import array, shape, arange, zeros, log
 from math import pi
@@ -10 +10 @@
     def test_members(self):
         o = specdesc()
-        assert_equal ([o.buf_size, o.channels, o.method],
-            [1024, 1, "default"])
-        o = specdesc("complex", 512, 2)
-        assert_equal ([o.buf_size, o.channels, o.method],
-            [512, 2, "complex"])
+        assert_equal ([o.buf_size, o.method],
+            [1024, "default"])
 
     def test_hfc(self):
@@ -22 +19 @@
         a = arange(c.length, dtype='float32')
         c.norm = a
-        assert_equal (a, c.norm[0])
+        assert_equal (a, c.norm)
         assert_equal ( sum(a*(a+1)), o(c))
 
@@ -31 +28 @@
         a = arange(c.length, dtype='float32')
         c.norm = a
-        assert_equal (a, c.norm[0])
+        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

interfaces/python/test_phasevoc.py

@@ -1 +1 @@
 from numpy.testing import TestCase, run_module_suite
 from numpy.testing import assert_equal, assert_almost_equal
+from aubio import fvec
 from _aubio import *
 from numpy import array, shape
@@ -26 +27 @@
   def test_steps_two_channels(self):
     """ check the resynthesis of steps is correct """
-    f = pvoc(1024, 512, 2)
-    t1 = fvec(512, 2)
-    t2 = fvec(512, 2)
+    f = pvoc(1024, 512)
+    t1 = fvec(512)
+    t2 = fvec(512)
     # positive step in first channel
-    t1[0][100:200] = .1
+    t1[100:200] = .1
     # positive step in second channel
-    t1[1][20:50] = -.1
+    t1[20:50] = -.1
     s1 = f(t1)
     r1 = f.rdo(s1)
@@ -42 +43 @@
   def test_steps_three_random_channels(self):
     from random import random
-    f = pvoc(64, 16, 3)
-    t0 = fvec(16, 3)
-    t1 = fvec(16, 3)
-    for i in xrange(3):
-      for j in xrange(16):
-        t1[i][j] = random() * 2. - 1.
+    f = pvoc(64, 16)
+    t0 = fvec(16)
+    t1 = fvec(16)
+    for i in xrange(16):
+        t1[i] = random() * 2. - 1.
     t2 = f.rdo(f(t1))
     t2 = f.rdo(f(t0))