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]))