[aimc] r303 committed - Rename variables to be consistent with the rest of the library.

[ai...@googlecode.com]

Revision: 303
Author: ro...@google.com
Date: Thu Jun 27 08:30:46 2013
Log: Rename variables to be consistent with the rest of the library.

http://code.google.com/p/aimc/source/detail?r=303

Modified:
/trunk/carfac/carfac_test.cc
/trunk/carfac/sai.cc
/trunk/carfac/sai.h
/trunk/carfac/sai_test.cc

=======================================
--- /trunk/carfac/carfac_test.cc Mon Jun 24 09:35:21 2013
+++ /trunk/carfac/carfac_test.cc Thu Jun 27 08:30:46 2013
@@ -68,8 +68,8 @@
// Reads a size rows vector of size columns Container objects from a
// multi-column text file generated by the Matlab version of CARFAC.
template <typename Container = ArrayX, bool ColMajor = true>
-vector<Container> Load2dTestData(const string& filename, const int rows,
- const int columns) {
+vector<Container> Load2dTestData(const string& filename, int rows,
+ int columns) {
string fullfile = kTestSourceDir + filename;
ifstream file(fullfile.c_str());
vector<Container> output;
@@ -96,19 +96,22 @@
// Reads a two dimensional vector of audio data from a text file
// containing the output of the Matlab wavread() function.
vector<vector<float>> Load2dAudioVector(string filename, int timepoints,
- int channels) {
- return Load2dTestData<vector<float>, false>(filename, timepoints,
channels);
+ int num_channels) {
+ return Load2dTestData<vector<float>, false>(filename, timepoints,
+ num_channels);
}

class CARFACTest : public testing::Test {
protected:
- deque<vector<ArrayX>> LoadTestData(
- const string& basename, int n_timepoints, int n_ears, int n_ch)
const {
- deque<vector<ArrayX>> test_data(n_timepoints, vector<ArrayX>(n_ears));
- for (int ear = 0; ear < n_ears; ++ear) {
+ deque<vector<ArrayX>> LoadTestData(const string& basename,
+ int num_samples,
+ int num_ears,
+ int num_channels) const {
+ deque<vector<ArrayX>> test_data(num_samples, vector<ArrayX>(num_ears));
+ for (int ear = 0; ear < num_ears; ++ear) {
string filename = basename + std::to_string(ear + 1) + ".txt";
- vector<ArrayX> data = Load2dTestData(filename, n_timepoints, n_ch);
- for (int i = 0; i < n_timepoints; ++i) {
+ vector<ArrayX> data = Load2dTestData(filename, num_samples,
num_channels);
+ for (int i = 0; i < num_samples; ++i) {
test_data[i][ear] = data[i];
}
}
@@ -117,10 +120,12 @@

void AssertCARFACOutputNear(const deque<vector<ArrayX>>& expected,
const deque<vector<ArrayX>>& actual,
- int n_timepoints, int n_ears, int n_ch)
const {
- for (int timepoint = 0; timepoint < n_timepoints; ++timepoint) {
- for (int ear = 0; ear < n_ears; ++ear) {
- for (int channel = 0; channel < n_ch; ++channel) {
+ int num_samples,
+ int num_ears,
+ int num_channels) const {
+ for (int timepoint = 0; timepoint < num_samples; ++timepoint) {
+ for (int ear = 0; ear < num_ears; ++ear) {
+ for (int channel = 0; channel < num_channels; ++channel) {
const float kPrecisionLevel = 1.0e-7;
ASSERT_NEAR(expected[timepoint][ear](channel),
actual[timepoint][ear](channel),
@@ -136,12 +141,12 @@
};

TEST_F(CARFACTest, BinauralData) {
- const int n_timepoints = 882;
- const int n_ears = 2;
- const int n_ch = 71;
+ const int kNumSamples = 882;
+ const int kNumEars = 2;
+ const int kNumChannels = 71;
vector<vector<float>> sound_data =
- Load2dAudioVector("file_signal_binaural_test.txt", n_timepoints,
n_ears);
- CARFAC carfac(n_ears, 22050, car_params_, ihc_params_, agc_params_);
+ Load2dAudioVector("file_signal_binaural_test.txt", kNumSamples,
kNumEars);
+ CARFAC carfac(kNumEars, 22050, car_params_, ihc_params_, agc_params_);
CARFACOutput output(true, true, false, false);
const bool kOpenLoop = false;
const int length = sound_data[0].size();
@@ -153,22 +158,22 @@
WriteNAPOutput(output, "cpp_nap_output_2_binaural_test.txt", 1);

deque<vector<ArrayX>> expected_nap =
- LoadTestData("binaural_test_nap", n_timepoints, n_ears, n_ch);
+ LoadTestData("binaural_test_nap", kNumSamples, kNumEars,
kNumChannels);
AssertCARFACOutputNear(expected_nap, output.nap(),
- n_timepoints, n_ears, n_ch);
+ kNumSamples, kNumEars, kNumChannels);
deque<vector<ArrayX>> expected_bm =
- LoadTestData("binaural_test_bm", n_timepoints, n_ears, n_ch);
+ LoadTestData("binaural_test_bm", kNumSamples, kNumEars,
kNumChannels);
AssertCARFACOutputNear(expected_bm, output.bm(),
- n_timepoints, n_ears, n_ch);
+ kNumSamples, kNumEars, kNumChannels);
}

TEST_F(CARFACTest, LongBinauralData) {
- const int n_timepoints = 2000;
- const int n_ears = 2;
- const int n_ch = 83;
+ const int kNumSamples = 2000;
+ const int kNumEars = 2;
+ const int kNumChannels = 83;
vector<vector<float>> sound_data =
- Load2dAudioVector("file_signal_long_test.txt", n_timepoints, n_ears);
- CARFAC carfac(n_ears, 44100, car_params_, ihc_params_, agc_params_);
+ Load2dAudioVector("file_signal_long_test.txt", kNumSamples,
kNumEars);
+ CARFAC carfac(kNumEars, 44100, car_params_, ihc_params_, agc_params_);
CARFACOutput output(true, true, false, false);
const bool kOpenLoop = false;
const int length = sound_data[0].size();
@@ -180,11 +185,11 @@
WriteNAPOutput(output, "cpp_nap_output_2_long_test.txt", 1);

deque<vector<ArrayX>> expected_nap =
- LoadTestData("long_test_nap", n_timepoints, n_ears, n_ch);
+ LoadTestData("long_test_nap", kNumSamples, kNumEars, kNumChannels);
AssertCARFACOutputNear(expected_nap, output.nap(),
- n_timepoints, n_ears, n_ch);
+ kNumSamples, kNumEars, kNumChannels);
deque<vector<ArrayX>> expected_bm =
- LoadTestData("long_test_bm", n_timepoints, n_ears, n_ch);
+ LoadTestData("long_test_bm", kNumSamples, kNumEars, kNumChannels);
AssertCARFACOutputNear(expected_bm, output.bm(),
- n_timepoints, n_ears, n_ch);
+ kNumSamples, kNumEars, kNumChannels);
}
=======================================
--- /trunk/carfac/sai.cc Wed Jun 12 12:24:29 2013
+++ /trunk/carfac/sai.cc Thu Jun 27 08:30:46 2013
@@ -30,10 +30,10 @@
"SAI window_width must be larger than width.");

int buffer_width = params_.width +
- static_cast<int>((1 + static_cast<float>(params_.n_window_pos -
1)/2) *
+ static_cast<int>((1 + static_cast<float>(params_.num_window_pos -
1)/2) *
params_.window_width);
- input_buffer_.setZero(params_.n_ch, buffer_width);
- output_buffer_.setZero(params_.n_ch, params_.width);
+ input_buffer_.setZero(params_.num_channels, buffer_width);
+ output_buffer_.setZero(params_.num_channels, params_.width);

window_.setLinSpaced(params_.window_width, kPi / params_.window_width,
kPi)
.sin();
@@ -48,21 +48,21 @@
ArrayXX* output_frame) {
assert(!input.empty() || input.size() <= params_.window_width &&
"Unexpected input size.");
- assert(input[0].size() == params_.n_ch &&
+ assert(input[0].size() == params_.num_channels &&
"Unexpected input frame size.");

// Append new data to the input buffer.
- int n_shift = input.size();
- int shift_width = input_buffer_.cols() - n_shift;
- input_buffer_.topLeftCorner(params_.n_ch, shift_width).swap(
- input_buffer_.block(0, n_shift, params_.n_ch, shift_width));
+ int num_shift = input.size();
+ int shift_width = input_buffer_.cols() - num_shift;
+ input_buffer_.topLeftCorner(params_.num_channels, shift_width).swap(
+ input_buffer_.block(0, num_shift, params_.num_channels,
shift_width));
for (int i = 0; i < input.size(); ++i) {
input_buffer_.block(0, shift_width + i, input[i].size(), 1) = input[i];
}
// Zero-pad the buffer if necessary.
if (input.size() < params_.window_width) {
int pad_width = params_.window_width - input.size();
- input_buffer_.topRightCorner(params_.n_ch, pad_width).setZero();
+ input_buffer_.topRightCorner(params_.num_channels,
pad_width).setZero();
}

StabilizeSegment(input_buffer_, &output_buffer_);
@@ -74,17 +74,17 @@
// Windows are always approximately 50% overlapped.
float window_hop = params_.window_width / 2;
int window_start = (input_buffer.cols() - params_.window_width) -
- (params_.n_window_pos - 1) * window_hop;
+ (params_.num_window_pos - 1) * window_hop;
int window_range_start = window_start - params_.future_lags - 1;
int offset_range_start = window_start - params_.width;
assert(offset_range_start >= 0);
- for (int i = 0; i < params_.n_ch; ++i) {
+ for (int i = 0; i < params_.num_channels; ++i) {
// TODO(ronw): Rename this here and in the Matlab code since the
// input doesn't have to contain naps.
const ArrayX& nap_wave = input_buffer.row(i);
// TODO(ronw): Smooth row.

- for (int w = 0; w < params_.n_window_pos; ++w) {
+ for (int w = 0; w < params_.num_window_pos; ++w) {
int current_window_offset = w * window_hop;
// Choose a trigger point.
int trigger_time;
=======================================
--- /trunk/carfac/sai.h Wed Jun 12 12:24:29 2013
+++ /trunk/carfac/sai.h Thu Jun 27 08:30:46 2013
@@ -27,7 +27,7 @@
// Design parameters for a single SAI.
struct SAIParams {
// Number of channels (height) of the SAI.
- int n_ch;
+ int num_channels;

// TODO(ronw): Consider parameterizing this as past_lags and
// future_lags, with width == past_lags + 1 + future_lags.
@@ -37,7 +37,7 @@
// Number of lag samples that should come from the future.
int future_lags;
// Number of windows (triggers) to consider during each SAI frame.
- int n_window_pos;
+ int num_window_pos;

// TODO(ronw): more carefully define terms "window" and "frame"

@@ -57,11 +57,11 @@
// Reset the internal state.
void Reset();

- // Fills output_frame with a params_.n_ch by params_.width SAI frame
+ // Fills output_frame with a params_.num_channels by params_.width SAI
frame
// computed from the given input frames.
//
// The input should have dimensionality of params_.window_width by
- // params_.n_ch. Inputs containing too few frames are zero-padded.
+ // params_.num_channels. Inputs containing too few frames are
zero-padded.
// FIXME: ArrayXX input type would be less awkward.
void RunSegment(const std::vector<ArrayX>& input,
ArrayXX* output_output_frame);
@@ -77,9 +77,9 @@
// Size: params_.window_width.
ArrayX window_;
// Buffer to store a large enough window of input frames to compute
- // a full SAI frame. Size: params_.n_ch by params_.buffer_width.
+ // a full SAI frame. Size: params_.num_channels by params_.buffer_width.
ArrayXX input_buffer_;
- // Output frame buffer. Size: params_.n_ch by params_.width.
+ // Output frame buffer. Size: params_.num_channels by params_.width.
ArrayXX output_buffer_;
};

=======================================
--- /trunk/carfac/sai_test.cc Wed Jun 26 16:35:47 2013
+++ /trunk/carfac/sai_test.cc Thu Jun 27 08:30:46 2013
@@ -36,10 +36,10 @@
using testing::Values;
using std::vector;

-vector<ArrayX> CreateZeroSegment(int n_ch, int length) {
+vector<ArrayX> CreateZeroSegment(int num_channels, int length) {
vector<ArrayX> segment;
for (int i = 0; i < length; ++i) {
- segment.push_back(ArrayX::Zero(n_ch));
+ segment.push_back(ArrayX::Zero(num_channels));
}
return segment;
}
@@ -77,16 +77,16 @@
protected:
void SetUp() {
period_ = std::tr1::get<0>(GetParam());
- n_ch_ = std::tr1::get<1>(GetParam());
+ num_channels_ = std::tr1::get<1>(GetParam());
}

int period_;
- int n_ch_;
+ int num_channels_;
};

TEST_P(SAIPeriodicInputTest, MultiChannelPulseTrain) {
- vector<ArrayX> segment = CreateZeroSegment(n_ch_, 38);
- for (int i = 0; i < n_ch_; ++i) {
+ vector<ArrayX> segment = CreateZeroSegment(num_channels_, 38);
+ for (int i = 0; i < num_channels_; ++i) {
// Begin each channel at a different phase.
const int phase = i;
for (int j = phase; j < segment.size(); j += period_) {
@@ -96,12 +96,12 @@

SAIParams sai_params;
sai_params.window_width = segment.size();
- sai_params.n_ch = n_ch_;
+ sai_params.num_channels = num_channels_;
sai_params.width = 15;
// Half of the SAI should come from the future.
// sai_params.future_lags = sai_params.width / 2;
sai_params.future_lags = 0;
- sai_params.n_window_pos = 2;
+ sai_params.num_window_pos = 2;

SAI sai(sai_params);
ArrayXX sai_frame;
@@ -109,7 +109,7 @@

// The output should have peaks at the same positions, regardless of
// input phase.
- for (int i = 0; i < n_ch_; ++i) {
+ for (int i = 0; i < num_channels_; ++i) {
const ArrayX& sai_channel = sai_frame.row(i);
for (int j = sai_channel.size() - 1; j >= 0; j -= period_) {
EXPECT_TRUE(HasPeakAt(sai_channel, j));
@@ -123,26 +123,26 @@
}
INSTANTIATE_TEST_CASE_P(PeriodicInputVariations, SAIPeriodicInputTest,
testing::Combine(Values(25, 10, 5, 2), // periods.
- Values(1, 2, 15))); // n_ch.
+ Values(1, 2, 15))); //
num_channels.

TEST(SAITest, CARFACIntegration) {
- const int n_ears = 1;
- const int length = 300;
- vector<vector<float>> segment(n_ears, vector<float>(length, 0.0));
+ const int kNumEars = 1;
+ const int kNumSamples = 300;
+ vector<vector<float>> segment(kNumEars, vector<float>(kNumSamples, 0.0));

// Sinusoid input.
const float kFrequency = 10;
Eigen::Map<Eigen::ArrayXf> segment_array(&segment[0][0],
segment[0].size());
- segment_array.setLinSpaced(length, 0.0, 2 * kFrequency * kPi);
+ segment_array.setLinSpaced(kNumSamples, 0.0, 2 * kFrequency * kPi);
segment_array.sin();

CARParams car_params;
IHCParams ihc_params;
AGCParams agc_params;
- CARFAC carfac(n_ears, 800, car_params, ihc_params, agc_params);
+ CARFAC carfac(kNumEars, 800, car_params, ihc_params, agc_params);
CARFACOutput output(true, false, false, false);
const bool kOpenLoop = false;
- carfac.RunSegment(segment, 0, length, kOpenLoop, &output);
+ carfac.RunSegment(segment, 0, kNumSamples, kOpenLoop, &output);

vector<ArrayX> nap_segment;
nap_segment.reserve(output.nap().size());
@@ -151,12 +151,12 @@
}

SAIParams sai_params;
- sai_params.window_width = length;
- sai_params.n_ch = carfac.num_channels();
+ sai_params.window_width = kNumSamples;
+ sai_params.num_channels = carfac.num_channels();
sai_params.width = 20;
// Half of the SAI should come from the future.
sai_params.future_lags = sai_params.width / 2;
- sai_params.n_window_pos = 2;
+ sai_params.num_window_pos = 2;
SAI sai(sai_params);
ArrayXX sai_frame;
sai.RunSegment(nap_segment, &sai_frame);