source: python/tests/test_phasevoc.py @ a159628

feature/autosinkfeature/constantqfeature/pitchshiftfeature/pydocstringsfeature/timestretchsampleryinfft+
Last change on this file since a159628 was d98f3c0, checked in by Paul Brossier <piem@piem.org>, 3 years ago

python/tests/test_fft.py: skip test fft(zeros).phas == 0 if needed, expected powerpc

  • Property mode set to 100755
File size: 5.8 KB
Line 
1#! /usr/bin/env python
2
3from numpy.testing import TestCase, assert_equal, assert_array_less
4from aubio import fvec, cvec, pvoc, float_type
5from nose2 import main
6from nose2.tools import params
7import numpy as np
8
9if float_type == 'float32':
10    max_sq_error = 1.e-12
11else:
12    max_sq_error = 1.e-29
13
14def create_sine(hop_s, freq, samplerate):
15    t = np.arange(hop_s).astype(float_type)
16    return np.sin( 2. * np.pi * freq * t / float(samplerate))
17
18def create_noise(hop_s):
19    return np.random.rand(hop_s).astype(float_type) * 2. - 1.
20
21class aubio_pvoc_test_case(TestCase):
22    """ pvoc object test case """
23
24    def test_members_automatic_sizes_default(self):
25        """ check object creation with default parameters """
26        f = pvoc()
27        assert_equal ([f.win_s, f.hop_s], [1024, 512])
28
29    def test_members_unnamed_params(self):
30        """ check object creation with unnamed parameters """
31        f = pvoc(2048, 128)
32        assert_equal ([f.win_s, f.hop_s], [2048, 128])
33
34    def test_members_named_params(self):
35        """ check object creation with named parameters """
36        f = pvoc(hop_s = 128, win_s = 2048)
37        assert_equal ([f.win_s, f.hop_s], [2048, 128])
38
39    def test_zeros(self):
40        """ check the resynthesis of zeros gives zeros """
41        win_s, hop_s = 1024, 256
42        f = pvoc (win_s, hop_s)
43        t = fvec (hop_s)
44        for _ in range( int ( 4 * win_s / hop_s ) ):
45            s = f(t)
46            r = f.rdo(s)
47            assert_equal ( t, 0.)
48            assert_equal ( s.norm, 0.)
49            try:
50                assert_equal ( s.phas, 0 )
51            except AssertionError:
52                assert_equal (s.phas[s.phas > 0], +np.pi)
53                assert_equal (s.phas[s.phas < 0], -np.pi)
54                assert_equal (np.abs(s.phas[np.abs(s.phas) != np.pi]), 0)
55                self.skipTest('pvoc(fvec(%d)).phas != +0, ' % win_s \
56                        + 'This is expected when using fftw3 on powerpc.')
57            assert_equal ( r, 0.)
58
59    @params(
60            ( 256, 8),
61            ( 256, 4),
62            ( 256, 2),
63            ( 512, 8),
64            ( 512, 4),
65            ( 512, 2),
66            #( 129, 2),
67            #( 320, 4),
68            #(  13, 8),
69            (1024, 8),
70            (1024, 4),
71            (1024, 2),
72            (2048, 8),
73            (2048, 4),
74            (2048, 2),
75            (4096, 8),
76            (4096, 4),
77            (4096, 2),
78            (8192, 8),
79            (8192, 4),
80            (8192, 2),
81            )
82    def test_resynth_steps_noise(self, hop_s, ratio):
83        """ check the resynthesis of a random signal is correct """
84        sigin = create_noise(hop_s)
85        self.reconstruction(sigin, hop_s, ratio)
86
87    @params(
88            (44100,  256, 8,   441),
89            (44100,  256, 4,  1203),
90            (44100,  256, 2,  3045),
91            (44100,  512, 8,   445),
92            (44100,  512, 4,   445),
93            (44100,  512, 2,   445),
94            (44100, 1024, 8,   445),
95            (44100, 1024, 4,   445),
96            (44100, 1024, 2,   445),
97            ( 8000, 1024, 2,   445),
98            (22050, 1024, 2,   445),
99            (22050,  256, 8,   445),
100            (96000, 1024, 8, 47000),
101            (96000, 1024, 8,    20),
102            )
103    def test_resynth_steps_sine(self, samplerate, hop_s, ratio, freq):
104        """ check the resynthesis of a sine is correct """
105        sigin = create_sine(hop_s, freq, samplerate)
106        self.reconstruction(sigin, hop_s, ratio)
107
108    def reconstruction(self, sigin, hop_s, ratio):
109        buf_s = hop_s * ratio
110        f = pvoc(buf_s, hop_s)
111        zeros = fvec(hop_s)
112        r2 = f.rdo( f(sigin) )
113        for _ in range(1, ratio):
114            r2 = f.rdo( f(zeros) )
115        # compute square errors
116        sq_error = (r2 - sigin)**2
117        # make sure all square errors are less than desired precision
118        assert_array_less(sq_error, max_sq_error)
119
120class aubio_pvoc_strange_params(TestCase):
121
122    def test_win_size_short(self):
123        with self.assertRaises(RuntimeError):
124            pvoc(1, 1)
125
126    def test_hop_size_long(self):
127        with self.assertRaises(RuntimeError):
128            pvoc(1024, 1025)
129
130    def test_large_input_timegrain(self):
131        win_s = 1024
132        f = pvoc(win_s)
133        t = fvec(win_s + 1)
134        with self.assertRaises(ValueError):
135            f(t)
136
137    def test_small_input_timegrain(self):
138        win_s = 1024
139        f = pvoc(win_s)
140        t = fvec(1)
141        with self.assertRaises(ValueError):
142            f(t)
143
144    def test_large_input_fftgrain(self):
145        win_s = 1024
146        f = pvoc(win_s)
147        s = cvec(win_s + 5)
148        with self.assertRaises(ValueError):
149            f.rdo(s)
150
151    def test_small_input_fftgrain(self):
152        win_s = 1024
153        f = pvoc(win_s)
154        s = cvec(16)
155        with self.assertRaises(ValueError):
156            f.rdo(s)
157
158class aubio_pvoc_wrong_params(TestCase):
159
160    def test_wrong_buf_size(self):
161        win_s = -1
162        with self.assertRaises(ValueError):
163            pvoc(win_s)
164
165    def test_buf_size_too_small(self):
166        win_s = 1
167        with self.assertRaises(RuntimeError):
168            pvoc(win_s)
169
170    def test_hop_size_negative(self):
171        win_s = 512
172        hop_s = -2
173        with self.assertRaises(ValueError):
174            pvoc(win_s, hop_s)
175
176    def test_hop_size_too_small(self):
177        win_s = 1
178        hop_s = 1
179        with self.assertRaises(RuntimeError):
180            pvoc(win_s, hop_s)
181
182    def test_buf_size_not_power_of_two(self):
183        win_s = 320
184        hop_s = win_s // 2
185        try:
186            with self.assertRaises(RuntimeError):
187                pvoc(win_s, hop_s)
188        except AssertionError:
189            # when compiled with fftw3, aubio supports non power of two fft sizes
190            self.skipTest('creating aubio.pvoc with size %d did not fail' % win_s)
191
192if __name__ == '__main__':
193    main()
194
Note: See TracBrowser for help on using the repository browser.