def test_ensure_minimal_inersection_ratio_insufficient_overlap(self): scale = GeometricScale(start_center_hz=300, stop_center_hz=3030, bandwidth_ratio=0.01, n_bands=300) self.assertRaises(AssertionError, lambda: scale.ensure_overlap_ratio(0.5))
def test_ensure_minimal_intersection_ratio(self): scale = GeometricScale(start_center_hz=300, stop_center_hz=3030, bandwidth_ratio=0.017, n_bands=300) try: scale.ensure_overlap_ratio(0.5) except AssertionError: self.fail('AssertionError was raised')
def test_not_equal_due_to_scales(self): scale1 = GeometricScale(20, 5000, 0.02, 3) slices1 = [slice(0, 10), slice(10, 100), slice(100, 1000)] dim1 = ExplicitFrequencyDimension(scale1, slices1) scale2 = GeometricScale(20, 5000, 0.02, 3) slices2 = [slice(0, 10), slice(10, 100), slice(100, 1000)] dim2 = ExplicitFrequencyDimension(scale2, slices2) self.assertNotEqual(dim1, dim2)
def test_slicing_geometric_scale_returns_explicit_scale(self): scale = GeometricScale(start_center_hz=20, stop_center_hz=5000, bandwidth_ratio=0.05, n_bands=100) sliced = scale[FrequencyBand(100, 1000)] self.assertIsInstance(sliced, ExplicitScale)
def test_square_form_no_overlap_add(self): samplerate = SR11025() BaseModel = stft(resample_to=samplerate) windowing_func = OggVorbisWindowingFunc() scale = GeometricScale(20, 5000, 0.1, 25) @simple_in_memory_settings class Document(BaseModel): long_windowed = ArrayWithUnitsFeature( SlidingWindow, wscheme=SampleRate(frequency=Milliseconds(500), duration=Seconds(1)), wfunc=windowing_func, needs=BaseModel.resampled, store=True) dct = ArrayWithUnitsFeature(DCT, scale_always_even=True, needs=long_windowed, store=True) mdct = FrequencyAdaptiveFeature(FrequencyAdaptiveTransform, transform=scipy.fftpack.idct, scale=scale, needs=dct, store=True) synth = TickSynthesizer(SR22050()) samples = synth.synthesize(Seconds(5), Milliseconds(200)) _id = Document.process(meta=samples.encode()) doc = Document(_id) square = doc.mdct.square(30) self.assertEqual(3, square.ndim) self.assertEqual(30, square.shape[1]) self.assertEqual(25, square.shape[2])
def test_metaslice(self): scale1 = GeometricScale(20, 5000, 0.02, 3) bands = list(scale1) slices1 = [slice(0, 10), slice(10, 100), slice(100, 1000)] dim1 = ExplicitFrequencyDimension(scale1, slices1) dim2 = dim1.metaslice(FrequencyBand(15, 1000), 2) self.assertEqual(bands[:2], list(dim2.scale)[:2]) self.assertEqual(slices1[:2], dim2.slices[:2])
def test_not_equal_when_scale_differs(self): fb1 = FrequencyBand(20, 20000) scale1 = LinearScale(fb1, 100) fb2 = FrequencyBand(20, 20000) scale2 = GeometricScale(20, 20000, 0.01, 100) self.assertNotEqual(scale1, scale2)
def test_can_invert_frequency_weighting_for_adaptive_representation(self): td = TimeDimension(duration=Seconds(1), frequency=Milliseconds(500)) scale = GeometricScale(20, 5000, 0.05, 120) arrs = [np.random.random_sample((10, x)) for x in xrange(1, 121)] fa = FrequencyAdaptive(arrs, td, scale) weighting = AWeighting() result = fa * weighting inverted = result / AWeighting() np.testing.assert_allclose(fa, inverted)
def test_can_apply_a_weighting_to_frequency_adaptive_representation(self): td = TimeDimension(duration=Seconds(1), frequency=Milliseconds(500)) scale = GeometricScale(20, 5000, 0.05, 120) arrs = [np.ones((10, x)) for x in xrange(1, 121)] fa = FrequencyAdaptive(arrs, td, scale) weighting = AWeighting() result = fa * weighting self.assertGreater(result[:, scale[-1]].sum(), result[:, scale[0]].sum())
def test_can_invert_weighting_for_explicit_frequency_dimension(self): td = TimeDimension(duration=Seconds(1), frequency=Milliseconds(500)) scale = GeometricScale(20, 5000, 0.05, 120) arrs = [np.ones((10, x)) for x in xrange(1, 121)] fa = FrequencyAdaptive(arrs, td, scale) fa2 = ArrayWithUnits(fa, fa.dimensions) weighting = AWeighting() result = fa2 * weighting inverted = result / AWeighting() np.testing.assert_allclose(fa, inverted)
def test_can_apply_weighting_to_explicit_frequency_dimension(self): td = TimeDimension(duration=Seconds(1), frequency=Milliseconds(500)) scale = GeometricScale(20, 5000, 0.05, 120) arrs = [np.ones((10, x)) for x in xrange(1, 121)] fa = FrequencyAdaptive(arrs, td, scale) fa2 = ArrayWithUnits(fa, fa.dimensions) weighting = AWeighting() result = fa2 * weighting self.assertGreater(result[:, scale[-1]].sum(), result[:, scale[0]].sum())
def test_metaslice_exact_matching_band(self): scale = GeometricScale(20, 5000, 0.05, 120) # the values of the slices don't matter for this test slices = [slice(0, 10) for _ in xrange(len(scale))] dim = ExplicitFrequencyDimension(scale, slices) dim2 = dim.metaslice(scale[0], 1) self.assertEqual(1, len(dim2.scale)) self.assertEqual(1, len(dim2.slices)) self.assertEqual(dim.scale[0], dim2.scale[0]) self.assertEqual(dim.slices[0], dim2.slices[0])
def test_raises_useful_error_when_unexpected_dimensions_are_received(self): scale = GeometricScale(20, 5000, 0.1, 25) transform = FrequencyAdaptiveTransform(transform=scipy.fftpack.idct, scale=scale) inp = ArrayWithUnits(np.zeros((100, 10)), dimensions=[ TimeDimension(Seconds(1)), TimeDimension(Milliseconds(100)) ]) self.assertRaises(ValueError, lambda: list(transform._process(inp))[0])
def test_can_get_all_even_sized_bands(self): samplerate = SR44100() scale = LinearScale.from_sample_rate(samplerate, 44100, always_even=True) log_scale = GeometricScale(20, 20000, 0.01, 64) slices = [scale.get_slice(band) for band in log_scale] sizes = [s.stop - s.start for s in slices] self.assertTrue( not any([s % 2 for s in sizes]), 'All slice sizes should be even but were {sizes}'.format( **locals()))
def test_raises_when_scale_has_insufficient_overlap_and_check_is_requested( self): scale = GeometricScale(start_center_hz=50, stop_center_hz=5000, bandwidth_ratio=0.01, n_bands=128) self.assertRaises( ValueError, lambda: FrequencyAdaptiveTransform(transform=np.fft.irfft, scale=scale, check_scale_overlap_ratio=True))
def test_metaslice_fuzzy_matching_band(self): scale = GeometricScale(20, 5000, 0.05, 120) # the values of the slices don't matter for this test slices = [slice(0, 10) for _ in xrange(len(scale))] dim = ExplicitFrequencyDimension(scale, slices) first_band = scale[0] band = FrequencyBand(first_band.start_hz, first_band.stop_hz + 1) dim2 = dim.metaslice(band, 3) self.assertEqual(3, len(dim2.scale)) self.assertEqual(3, len(dim2.slices)) self.assertEqual(dim.scale[0], dim2.scale[0]) self.assertEqual(dim.scale[1], dim2.scale[1]) self.assertEqual(dim.scale[2], dim2.scale[2]) self.assertEqual(dim.slices[0], dim2.slices[0]) self.assertEqual(dim.slices[1], dim2.slices[1]) self.assertEqual(dim.slices[2], dim2.slices[2])
def test_can_get_slice_with_overlap(self): scale1 = GeometricScale(20, 5000, 0.02, 3) bands = list(scale1) slices1 = [slice(0, 10), slice(5, 100), slice(50, 1000)] dim1 = ExplicitFrequencyDimension(scale1, slices1) self.assertEqual(slices1[1], dim1.integer_based_slice(bands[1]))
def test_not_equal(self): fd1 = FrequencyDimension(LinearScale(FrequencyBand(20, 10000), 100)) fd2 = FrequencyDimension(GeometricScale(20, 10000, 0.01, 100)) self.assertNotEqual(fd1, fd2)
def test_is_not_valid_when_size_does_not_correspond_to_last_slice(self): scale1 = GeometricScale(20, 5000, 0.02, 3) slices1 = [slice(0, 10), slice(10, 100), slice(100, 1000)] dim1 = ExplicitFrequencyDimension(scale1, slices1) self.assertFalse(dim1.validate(2000))
def test_raises_when_scale_and_slices_are_different_sizes(self): scale1 = GeometricScale(20, 5000, 0.02, 3) slices1 = [slice(0, 10), slice(10, 100)] self.assertRaises(ValueError, lambda: ExplicitFrequencyDimension(scale1, slices1))
def test_can_get_slice_when_perfectly_corresponds_to_band(self): scale1 = GeometricScale(20, 5000, 0.02, 3) bands = list(scale1) slices1 = [slice(0, 10), slice(10, 100), slice(100, 1000)] dim1 = ExplicitFrequencyDimension(scale1, slices1) self.assertEqual(slices1[1], dim1.integer_based_slice(bands[1]))