3 from numpy.testing import TestCase, assert_equal, assert_array_less
4 from aubio import fvec, cvec, pvoc, float_type
5 from numpy import array, shape
6 from numpy.random import random
7 from nose2.tools import params
10 if float_type == 'float32':
15 def create_sine(hop_s, freq, samplerate):
16 t = np.arange(hop_s).astype(float_type)
17 return np.sin( 2. * np.pi * freq * t / float(samplerate))
19 def create_noise(hop_s):
20 return np.random.rand(hop_s).astype(float_type) * 2. - 1.
22 class aubio_pvoc_test_case(TestCase):
23 """ pvoc object test case """
25 def test_members_automatic_sizes_default(self):
26 """ check object creation with default parameters """
28 assert_equal ([f.win_s, f.hop_s], [1024, 512])
30 def test_members_unnamed_params(self):
31 """ check object creation with unnamed parameters """
33 assert_equal ([f.win_s, f.hop_s], [2048, 128])
35 def test_members_named_params(self):
36 """ check object creation with named parameters """
37 f = pvoc(hop_s = 128, win_s = 2048)
38 assert_equal ([f.win_s, f.hop_s], [2048, 128])
41 """ check the resynthesis of zeros gives zeros """
42 win_s, hop_s = 1024, 256
43 f = pvoc (win_s, hop_s)
45 for time in range( int ( 4 * win_s / hop_s ) ):
49 assert_equal ( s.norm, 0.)
50 assert_equal ( s.phas, 0.)
53 def test_resynth_8_steps_sine(self):
54 """ check the resynthesis of is correct with 87.5% overlap """
57 freq = 445; samplerate = 22050
58 sigin = create_sine(hop_s, freq, samplerate)
59 self.reconstruction( sigin, hop_s, ratio)
61 def test_resynth_8_steps(self):
62 """ check the resynthesis of is correct with 87.5% overlap """
65 sigin = create_noise(hop_s)
66 self.reconstruction(sigin, hop_s, ratio)
68 def test_resynth_4_steps_sine(self):
69 """ check the resynthesis of is correct with 87.5% overlap """
72 freq = 445; samplerate = 22050
73 sigin = create_sine(hop_s, freq, samplerate)
74 self.reconstruction(sigin, hop_s, ratio)
76 def test_resynth_4_steps(self):
77 """ check the resynthesis of is correct with 75% overlap """
80 sigin = create_noise(hop_s)
81 self.reconstruction(sigin, hop_s, ratio)
83 def test_resynth_2_steps_sine(self):
84 """ check the resynthesis of is correct with 50% overlap """
87 freq = 445; samplerate = 22050
88 sigin = create_sine(hop_s, freq, samplerate)
89 self.reconstruction(sigin, hop_s, ratio)
91 def test_resynth_2_steps(self):
92 """ check the resynthesis of is correct with 50% overlap """
95 sigin = create_noise(hop_s)
96 self.reconstruction(sigin, hop_s, ratio)
118 def test_resynth_steps_noise(self, hop_s, ratio):
119 """ check the resynthesis of a random signal is correct """
120 sigin = create_noise(hop_s)
121 self.reconstruction(sigin, hop_s, ratio)
124 (44100, 256, 8, 441),
125 (44100, 256, 4, 1203),
126 (44100, 256, 2, 3045),
127 (44100, 512, 8, 445),
128 (44100, 512, 4, 445),
129 (44100, 512, 2, 445),
130 (44100, 1024, 8, 445),
131 (44100, 1024, 4, 445),
132 (44100, 1024, 2, 445),
133 ( 8000, 1024, 2, 445),
134 (22050, 1024, 2, 445),
135 (22050, 256, 8, 445),
136 (96000, 1024, 8, 47000),
137 (96000, 1024, 8, 20),
139 def test_resynth_steps_sine(self, samplerate, hop_s, ratio, freq):
140 """ check the resynthesis of a sine is correct """
141 sigin = create_sine(hop_s, freq, samplerate)
142 self.reconstruction(sigin, hop_s, ratio)
144 def reconstruction(self, sigin, hop_s, ratio):
145 buf_s = hop_s * ratio
146 f = pvoc(buf_s, hop_s)
148 r2 = f.rdo( f(sigin) )
149 for i in range(1, ratio):
150 r2 = f.rdo( f(zeros) )
151 # compute square errors
152 sq_error = (r2 - sigin)**2
153 # make sure all square errors are less than desired precision
154 assert_array_less(sq_error, max_sq_error)
156 if __name__ == '__main__':
157 from nose2 import main