def test_get_best_cost(self, mock_delta):
mock_delta.return_value = 25
candidate = (172, 0.542)
params = raptparams.Raptparams()
params.original_audio = (44100, [2.0] * 73000)
cost = pyrapt._get_best_cost(candidate, 25, [], 100, params)
self.assertEqual(50, cost)
def test_get_delta_cost(self):
cand1 = (172, 0.542)
cand2 = (0, 0.0)
prev_cand1 = (10, (215, 0.211))
prev_cand2 = (10, (0, 0.0))
params = raptparams.Raptparams()
with patch('pyrapt.pyrapt._get_unvoiced_to_unvoiced_cost') as mok_cost1:
mok_cost1.return_value = 5
cost = pyrapt._get_delta_cost(cand2, prev_cand2, 25, params)
self.assertEquals(5, cost)
mok_cost1.assert_called_once_with(prev_cand2)
with patch('pyrapt.pyrapt._get_voiced_to_unvoiced_cost') as mok_cost2:
mok_cost2.return_value = 10
cost = pyrapt._get_delta_cost(cand2, prev_cand1, 25, params)
self.assertEquals(10, cost)
mok_cost2.assert_called_once_with(cand2, prev_cand1, 25, params)
with patch('pyrapt.pyrapt._get_unvoiced_to_voiced_cost') as mok_cost3:
mok_cost3.return_value = 15
cost = pyrapt._get_delta_cost(cand1, prev_cand2, 25, params)
self.assertEquals(15, cost)
mok_cost3.assert_called_once_with(cand1, prev_cand2, 25, params)
with patch('pyrapt.pyrapt._get_voiced_to_voiced_cost') as mok_cost4:
mok_cost4.return_value = 25
cost = pyrapt._get_delta_cost(cand1, prev_cand1, 25, params)
self.assertEquals(25, cost)
mok_cost4.assert_called_once_with(cand1, prev_cand1, params)
def test_rms_ratio(self):
# TODO: mock hanning window vals
# start with basic test - if samples are all the same the frames will
# match exactly and rms ratio will just be 1
params = raptparams.Raptparams()
params.original_audio = (2000, [2.0] * 73000)
params.samples_per_frame = 5
params.hanning_window_length = 60
params.hanning_window_vals = numpy.hanning(60)
params.rms_offset = 40
result = pyrapt._get_rms_ratio(100, params)
self.assertEqual(1.0, result)
# now test one where amp is increasing (rms ratio should be > 1)
increasing_audio = [2.0] * 73000
increasing_audio[540:600] = [4.0] * 60
params.original_audio = (2000, increasing_audio)
result = pyrapt._get_rms_ratio(100, params)
self.assertGreater(result, 1.0)
# now test where amp is decreasing (rms ratio should be btwn 0 and 1)
decreasing_audio = [2.0] * 73000
decreasing_audio[540:600] = [1.0] * 60
params.original_audio = (2000, decreasing_audio)
result = pyrapt._get_rms_ratio(100, params)
self.assertGreater(result, 0.0)
self.assertLess(result, 1.0)
def test_get_marked_results(self):
candidates = ([0.7, 0.2, 0.6, 0.8], 1.0)
params = (raptparams.Raptparams(), nccfparams.Nccfparams())
params[1].shortest_lag_per_frame = 7
params[0].min_acceptable_peak_val = 0.5
params[0].max_hypotheses_per_frame = 19
marked_values = pyrapt._get_marked_results(candidates, params, False)
self.assertEqual(3, len(marked_values))
self.assertEqual((9, 0.6), marked_values[1])
def test_determine_state_per_frame(self, mock_process):
mock_process.return_value = [[(25, (172, 0.5423))]] * 166
raptparam = raptparams.Raptparams()
nccf_results = [[(172, 0.5423), (770, 0.6772)]] * 166
candidates = pyrapt._determine_state_per_frame(nccf_results, raptparam,
44100)
self.assertEqual(166, len(candidates))
mock_process.assert_called_once_with(165, [], nccf_results, raptparam,
44100)
def test_process_candidates(self, mock_calc_frame):
mock_calc_frame.return_value = [(25, (172, 0.542)), (55, (770, 0.672))]
raptparam = raptparams.Raptparams()
nccf_results = [[(172, 0.5423), (770, 0.6772)]] * 166
candidates = pyrapt._process_candidates(165, [], nccf_results,
raptparam, 44100)
mock_calc_frame.assert_called_with(ANY, ANY, nccf_results, raptparam,
44100)
self.assertEqual(166, len(candidates))
def test_nccf_firstpass(self, mock_frame_results):
mock_frame_results.return_value = [(8, 0.7), (12, 0.8), (21, 0.6)]
# TODO: This is with default params. Do it with passed in ones as well
sample_rate = 2004
audio_data = numpy.full(3346, 5.0)
params = raptparams.Raptparams()
candidates = pyrapt._first_pass_nccf((sample_rate, audio_data), params)
self.assertEqual(166, len(candidates))
self.assertEqual(3, len(candidates[0]))
self.assertEqual(0.8, candidates[34][1][1])
def test_get_marked_results_above_max(self):
candidates = ([0.7, 0.2, 0.6, 0.8, 0.9, 0.5], 1.0)
params = (raptparams.Raptparams(), nccfparams.Nccfparams())
params[1].shortest_lag_per_frame = 7
params[0].min_acceptable_peak_val = 0.5
params[0].max_hypotheses_per_frame = 5
marked_values = pyrapt._get_marked_results(candidates, params, False)
self.assertEqual(4, len(marked_values))
self.assertEqual((7, 0.7), marked_values[0])
self.assertEqual((11, 0.9), marked_values[3])
self.assertEqual((10, 0.8), marked_values[2])
def test_get_marked_results_firstpass(self, mock_get_peak):
candidates = ([0.7, 0.2, 0.6, 0.8], 1.0)
params = (raptparams.Raptparams(), nccfparams.Nccfparams())
params[1].shortest_lag_per_frame = 7
params[0].min_acceptable_peak_val = 0.5
params[0].max_hypotheses_per_frame = 19
mock_get_peak.return_value = (9, 0.6)
marked_values = pyrapt._get_marked_results(candidates, params, True)
self.assertEqual(3, len(marked_values))
self.assertEqual((9, 0.6), marked_values[1])
mock_get_peak.assert_called_with(ANY, ANY, ANY)
def test_unvoiced_to_voiced(self, mock_rms):
mock_rms.return_value = 2.0
candidate = (709, 0.733)
prev_entry = (0.373, (650, 0.841))
params = raptparams.Raptparams()
params.transition_cost = 10.0
params.amp_mod_transition_cost = 4.0
cost = pyrapt._get_unvoiced_to_voiced_cost(candidate, prev_entry,
100, params)
mock_rms.assert_called_once_with(100, params)
self.assertEqual(12.373, cost)
def test_get_freq_estimate(self, mock_determine_state):
mock_determine_state.return_value = [75] * 166
raptparam = raptparams.Raptparams()
nccf_results = [[(172, 0.5423), (770, 0.6772)]] * 166
results = pyrapt._get_freq_estimate(nccf_results, raptparam, 44100)
mock_determine_state.assert_called_once_with(nccf_results, raptparam,
44100)
self.assertEqual(166, len(results))
# now try it when returned results contain unvoiced hypothesis
mock_determine_state.return_value = [50, 0, 75]
results = pyrapt._get_freq_estimate(nccf_results, raptparam, 44100)
self.assertEqual(0.0, results[1])
def test_get_results_for_frame(self, mock_get_for_all_lags):
mock_get_for_all_lags.return_value = ([0.2] * 35, 0.3)
audio = (2004, numpy.full(3346, 5.0))
params = (raptparams.Raptparams(), nccfparams.Nccfparams())
lag_range = 8
with patch('pyrapt.pyrapt._get_marked_results') as mock_mark:
mock_mark.return_value = [(9, 0.7), (15, 0.8), (17, 0.6)]
results = pyrapt._get_firstpass_frame_results(
audio, 5, lag_range, params)
mock_mark.assert_called_once_with(ANY, ANY, True)
self.assertEqual(3, len(results))
self.assertEqual(0.8, results[1][1])
def test_get_correlation(self):
audio = (10, numpy.array([0, 1, 2, 3, 4, 5, 6, 7]))
params = (raptparams.Raptparams(), nccfparams.Nccfparams())
params[1].samples_per_frame = 2
params[1].samples_correlated_per_lag = 5
correlation = pyrapt._get_correlation(audio, 0, 1, params)
self.assertEqual(0.816496580927726, correlation)
# Now try with additive constant added in denominator
# (only added for 2nd pass NCCF calc)
params[0].additive_constant = 12
correlation = pyrapt._get_correlation(audio, 0, 1, params, False)
self.assertEqual(0.7856742013183862, correlation)
def test_get_correlations_for_all_lags(self, mock_get_correlation):
mock_get_correlation.return_value = 0.4
audio = (2004, numpy.full(3346, 5.0))
params = (raptparams.Raptparams(), nccfparams.Nccfparams())
params[1].samples_correlated_per_lag = 20
params[1].samples_per_frame = 20
params[1].shortest_lag_per_frame = 10
lag_range = 8
results = pyrapt._get_correlations_for_all_lags(
audio, 5, lag_range, params)
self.assertEqual(0.4, results[1])
self.assertEqual(8, len(results[0]))
self.assertEqual(0.4, results[0][7])
mock_get_correlation.assert_called_with(ANY, ANY, ANY, ANY)
def test_calculate_params_all_params(self, mock_hanning):
params = raptparams.Raptparams()
self.assertEqual(None, params.original_audio)
self.assertEqual(None, params.samples_per_frame)
mock_hanning.return_value = [1, 2, 3, 4, 5]
audio = (44100, [5.0] * 7000)
down_audio = (2000, [5.0] * 700)
pyrapt._calculate_params(params, audio, down_audio)
mock_hanning.assert_called_once_with(1323)
self.assertEqual(22.05, params.sample_rate_ratio)
self.assertEqual(audio, params.original_audio)
self.assertEqual(441, params.samples_per_frame)
self.assertEqual(1323, params.hanning_window_length)
self.assertEqual([1, 2, 3, 4, 5], params.hanning_window_vals)
self.assertEqual(441, params.rms_offset)
def test_calculate_local_cost(self):
# standard voiced hypothesis calc:
raptparam = raptparams.Raptparams()
raptparam.lag_weight = 0.4
raptparam.minimum_allowed_freq = 50
max_corr_for_frame = 0.682
sample_rate = 44100
cost = pyrapt._calculate_local_cost((172, 0.5423), max_corr_for_frame,
raptparam, sample_rate)
self.assertEqual(0.5000018594104307, cost)
# now test unvoiced hypothesis calc:
raptparam.voicing_bias = 10.0
cost = pyrapt._calculate_local_cost((0, 0.0), max_corr_for_frame,
raptparam, sample_rate)
self.assertEqual(10.682, cost)
def test_run_nccf(self, mock_first_pass):
with patch('pyrapt.pyrapt._second_pass_nccf') as mock_second_pass:
mock_first_pass.return_value = [[(4, 0.6)] * 5] * 166
mock_second_pass.return_value = [[(4, 0.6)] * 3] * 166
downsampled_audio = (10, numpy.array([0, 1, 2, 3]))
original_audio = (100, numpy.array([0, 1, 2, 3, 4, 5, 6]))
params = raptparams.Raptparams()
results = pyrapt._run_nccf(original_audio, params,
downsampled_audio)
mock_first_pass.assert_called_once_with(downsampled_audio, params)
mock_second_pass.assert_called_once_with(original_audio, ANY,
params)
self.assertEqual(166, len(results))
self.assertEqual(4, results[0][0][0])
self.assertEqual(0.6, results[165][2][1])
def test_calculate_params_firstpass_only(self, mock_hanning):
params = raptparams.Raptparams()
params.is_two_pass_nccf = False
params.frame_step_size = .008
self.assertEqual(None, params.original_audio)
self.assertEqual(None, params.samples_per_frame)
mock_hanning.return_value = [1, 2, 3, 4, 5]
audio = (44199, [5.0] * 7000)
pyrapt._calculate_params(params, audio)
mock_hanning.assert_called_once_with(1326)
self.assertEqual(None, params.sample_rate_ratio)
self.assertEqual(audio, params.original_audio)
self.assertEqual(354, params.samples_per_frame)
self.assertEqual(1326, params.hanning_window_length)
self.assertEqual([1, 2, 3, 4, 5], params.hanning_window_vals)
self.assertEqual(530, params.rms_offset)
def test_get_second_pass_results_for_frame(self, mock_get_correlations):
with patch('pyrapt.pyrapt._get_marked_results') as mock_res:
mock_return_val = ([0.2] * 35, 0.5)
mock_get_correlations.return_value = mock_return_val
mock_res.return_value = [(4, 0.6), (4, 0.6), (4, 0.6)] * 165
audio = (44100, numpy.full(73612, 7.3))
i = 5
lag_range = 5
params = (raptparams.Raptparams(), nccfparams.Nccfparams())
params[0].sample_rate_ratio = 20
first_pass = [(4, 0.5), (5, 0.6), (22, 0.7)] * 165
frame_results = pyrapt._get_secondpass_frame_results(
audio, i, lag_range, params, first_pass)
mock_get_correlations.assert_called_once_with(
audio, 5, first_pass, 5, params)
mock_res.assert_called_once_with(mock_return_val, params, False)
self.assertEqual(4, frame_results[0][0])
def test_calculate_cost_per_frame(self, mock_max_for_frame):
mock_max_for_frame.return_value = 0.6772
raptparam = raptparams.Raptparams()
raptparam = (44100, [2.0] * 73000)
nccf_results = [[(172, 0.5423), (770, 0.6772)]] * 166
with patch('pyrapt.pyrapt._calculate_local_cost') as mock_local:
with patch('pyrapt.pyrapt._get_best_cost') as mock_best:
mock_local.return_value = 25
mock_best.return_value = 75
candidates = pyrapt._calculate_costs_per_frame(100, [],
nccf_results,
raptparam, 44100)
self.assertEqual(2, len(candidates))
mock_max_for_frame.assert_called_once_with([(172, 0.5423),
(770, 0.6772)])
mock_local.assert_called_with(ANY, 0.6772, raptparam, 44100)
mock_best.assert_called_with(ANY, ANY, [], 100, raptparam)
def test_get_nccfparams(self):
audio_input = (10, numpy.zeros(60))
params = raptparams.Raptparams()
params.correlation_window_size = 2.0
params.minimum_allowed_freq = 2.0
params.maximum_allowed_freq = 2.0
params.frame_step_size = 2.0
first_params = pyrapt._get_nccf_params(audio_input, params, True)
self.assertEqual(20, first_params.samples_correlated_per_lag)
self.assertEqual(5, first_params.shortest_lag_per_frame)
self.assertEqual(5, first_params.longest_lag_per_frame)
self.assertEqual(20, first_params.samples_per_frame)
self.assertEqual(2, first_params.max_frame_count)
second_params = pyrapt._get_nccf_params(audio_input, params, False)
self.assertEqual(0, second_params.shortest_lag_per_frame)
self.assertEqual(5, second_params.longest_lag_per_frame)
self.assertEqual(20, second_params.samples_correlated_per_lag)
self.assertEqual(2, second_params.max_frame_count)
def test_get_correlations_for_input_lags(self, mock_get_correlation):
mock_get_correlation.return_value = 0.6
audio = (44100, numpy.full(3500, 5.0))
params = (raptparams.Raptparams(), nccfparams.Nccfparams())
params[0].sample_rate_ratio = 4
params[1].samples_correlated_per_lag = 20
params[1].samples_per_frame = 100
params[1].shortest_lag_per_frame = 0
lag_range = 50
first_pass = [[(32, 0.7)]] * 35
results = pyrapt._get_correlations_for_input_lags(
audio, 5, first_pass, lag_range, params)
mock_get_correlation.assert_called_with(ANY, ANY, ANY, ANY, False)
self.assertEqual(50, len(results[0]))
self.assertEqual(0.6, results[0][32])
self.assertEqual(0.6, results[0][29])
self.assertEqual(0.6, results[0][35])
self.assertEqual(0.0, results[0][28])
self.assertEqual(0.0, results[0][36])
self.assertEqual(0.6, results[1])
def plot_example(audio_file, output_filename):
params = raptparams.Raptparams()
example_audio = pyrapt._get_audio_data(audio_file)
samples_per_frame = int(example_audio[0] * params.frame_step_size)
results = pyrapt.rapt_with_nccf(audio_file,
transition_cost=0.5,
doubling_cost=30.0)
nccf_results = results[0]
nccf_cands = []
z = []
iter = 1
for a in nccf_results:
for b in a:
if b[0] > 0.0:
nccf_cands.append(float(example_audio[0]) / float(b[0]))
z.append(iter * samples_per_frame)
iter += 1
y = results[1]
x = range(0, len(y))
y = numpy.array(y)
x = numpy.array(x)
x = x * samples_per_frame
# spec = mlab.specgram(example_audio[1])
output_file(output_filename, title=audio_file)
p = figure(title='example 0 w trans cost of 0.5 and doubling cost ' +
'of 30.0',
x_axis_label='x',
y_axis_label='y')
if show_amp:
p.line(range(0, len(example_audio[1])),
example_audio[1],
legend='amp of example.wav',
line_width=1,
line_color='orange')
if show_freq:
p.line(x, y, legend='example.wav f0', line_width=2, line_color='blue')
if show_nccf:
p.circle(z, nccf_cands, legend='nccf candidates', color='red', size=1)
save(p)
def test_nccf_secondpass(self, mock_frame_results):
mock_frame_results.return_value = [(5, 0.6), (30, 0.7), (55, 0.9)]
first_pass = [(4, 0.6)] * 165
audio_data = (44100, numpy.full(73612, 6.8))
raptparam = raptparams.Raptparams()
raptparam.sample_rate_ratio = 20
with patch('pyrapt.pyrapt._get_nccf_params') as mock_get_params:
nccfparam = nccfparams.Nccfparams()
# lag range is supposed to be 0-samplerate/50 for 2nd pass default:
nccfparam.shortest_lag_per_frame = 0
nccfparam.longest_lag_per_frame = 882
nccfparam.max_frame_count = 165
params = (raptparam, nccfparam)
mock_get_params.return_value = nccfparam
candidates = pyrapt._second_pass_nccf(audio_data, first_pass,
raptparam)
mock_get_params.assert_called_once_with(audio_data, raptparam,
False)
# at each frame we get results, with lag range being max - 1
mock_frame_results.assert_called_with(audio_data, ANY, 881, params,
first_pass)
self.assertEqual(165, len(candidates))
self.assertEqual(5, candidates[0][0][0])
from pyrapt import pyrapt, raptparams
from bokeh.plotting import figure, output_file, save
import numpy
# from matplotlib import mlab
params = raptparams.Raptparams()
example_audio = pyrapt._get_audio_data('example.wav')
samples_per_frame = int(example_audio[0] * params.frame_step_size)
y1 = pyrapt.rapt('example.wav')
y2 = pyrapt.rapt('example.wav', doubling_cost=15.0)
x = range(0, len(y1))
y1 = numpy.array(y1)
y2 = numpy.array(y2)
x = numpy.array(x)
x = x * samples_per_frame
# spec = mlab.specgram(example_audio[1])
output_file('visualization/output/example_plot.html', title='example.wav f0s')
p = figure(title='vocal frequency', x_axis_label='x',
y_axis_label='y')
p.line(range(0, len(example_audio[1])), example_audio[1],
legend='amp of example.wav', line_width=1, line_color='orange')
p.line(x, y1, legend='example.wav f0 (basic)', line_width=2, line_color='blue')
p.line(x, y2, legend='example.wav f0 (high doubling cost)', line_width=2,
line_color='red')
save(p)
def test_voiced_to_voiced(self):
candidate = (709, 0.733)
prev_entry = (0.373, (650, 0.841))
params = raptparams.Raptparams()
cost = pyrapt._get_voiced_to_voiced_cost(candidate, prev_entry, params)
self.assertEqual(0.39212528033835004, cost)
