3 from numpy.testing import TestCase, assert_equal, assert_array_less
4 from _tools import parametrize
5 from aubio import fvec, cvec, pvoc, float_type
8 if float_type == 'float32':
13 def create_sine(hop_s, freq, samplerate):
14 t = np.arange(hop_s).astype(float_type)
15 return np.sin( 2. * np.pi * freq * t / float(samplerate))
17 def create_noise(hop_s):
18 return np.random.rand(hop_s).astype(float_type) * 2. - 1.
20 class Test_aubio_pvoc_test_case(object):
21 """ pvoc object test case """
23 def test_members_automatic_sizes_default(self):
24 """ check object creation with default parameters """
26 assert_equal ([f.win_s, f.hop_s], [1024, 512])
28 def test_members_unnamed_params(self):
29 """ check object creation with unnamed parameters """
31 assert_equal ([f.win_s, f.hop_s], [2048, 128])
33 def test_members_named_params(self):
34 """ check object creation with named parameters """
35 f = pvoc(hop_s = 128, win_s = 2048)
36 assert_equal ([f.win_s, f.hop_s], [2048, 128])
39 """ check the resynthesis of zeros gives zeros """
40 win_s, hop_s = 1024, 256
41 f = pvoc (win_s, hop_s)
43 for _ in range( int ( 4 * win_s / hop_s ) ):
47 assert_equal ( s.norm, 0.)
49 assert_equal ( s.phas, 0 )
50 except AssertionError:
51 assert_equal (s.phas[s.phas > 0], +np.pi)
52 assert_equal (s.phas[s.phas < 0], -np.pi)
53 assert_equal (np.abs(s.phas[np.abs(s.phas) != np.pi]), 0)
54 self.skipTest('pvoc(fvec(%d)).phas != +0, ' % win_s \
55 + 'This is expected when using fftw3 on powerpc.')
58 resynth_noise_args = "hop_s, ratio"
59 resynth_noise_values = [
83 @parametrize(resynth_noise_args, resynth_noise_values)
84 def test_resynth_steps_noise(self, hop_s, ratio):
85 """ check the resynthesis of a random signal is correct """
86 sigin = create_noise(hop_s)
87 self.reconstruction(sigin, hop_s, ratio)
89 resynth_sine_args = "samplerate, hop_s, ratio, freq"
90 resynth_sine_values = [
92 (44100, 256, 4, 1203),
93 (44100, 256, 2, 3045),
97 (44100, 1024, 8, 445),
98 (44100, 1024, 4, 445),
99 (44100, 1024, 2, 445),
100 ( 8000, 1024, 2, 445),
101 (22050, 1024, 2, 445),
102 (22050, 256, 8, 445),
103 (96000, 1024, 8, 47000),
104 (96000, 1024, 8, 20),
107 @parametrize(resynth_sine_args, resynth_sine_values)
108 def test_resynth_steps_sine(self, samplerate, hop_s, ratio, freq):
109 """ check the resynthesis of a sine is correct """
110 sigin = create_sine(hop_s, freq, samplerate)
111 self.reconstruction(sigin, hop_s, ratio)
113 def reconstruction(self, sigin, hop_s, ratio):
114 buf_s = hop_s * ratio
115 f = pvoc(buf_s, hop_s)
117 r2 = f.rdo( f(sigin) )
118 for _ in range(1, ratio):
119 r2 = f.rdo( f(zeros) )
120 # compute square errors
121 sq_error = (r2 - sigin)**2
122 # make sure all square errors are less than desired precision
123 assert_array_less(sq_error, max_sq_error)
125 class aubio_pvoc_strange_params(TestCase):
127 def test_win_size_short(self):
128 with self.assertRaises(RuntimeError):
131 def test_hop_size_long(self):
132 with self.assertRaises(RuntimeError):
135 def test_large_input_timegrain(self):
139 with self.assertRaises(ValueError):
142 def test_small_input_timegrain(self):
146 with self.assertRaises(ValueError):
149 def test_large_input_fftgrain(self):
153 with self.assertRaises(ValueError):
156 def test_small_input_fftgrain(self):
160 with self.assertRaises(ValueError):
163 class aubio_pvoc_wrong_params(TestCase):
165 def test_wrong_buf_size(self):
167 with self.assertRaises(ValueError):
170 def test_buf_size_too_small(self):
172 with self.assertRaises(RuntimeError):
175 def test_hop_size_negative(self):
178 with self.assertRaises(ValueError):
181 def test_hop_size_too_small(self):
184 with self.assertRaises(RuntimeError):
187 def test_buf_size_not_power_of_two(self):
191 with self.assertRaises(RuntimeError):
193 except AssertionError:
194 # when compiled with fftw3, aubio supports non power of two fft sizes
195 self.skipTest('creating aubio.pvoc with size %d did not fail' % win_s)
197 if __name__ == '__main__':
198 from unittest import main