Make the separation between target and interferer scenario depend on microphone spacing in Nonlinea…

webrtc/modules/audio_processing/beamformer/nonlinear_beamformer.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 18 matching lines @@
 
 const float kSpeedOfSoundMeterSeconds = 343;
 
 // For both target and interference angles, PI / 2 is perpendicular to the
 // microphone array, facing forwards. The positive direction goes
 // counterclockwise.
 // The angle at which we amplify sound.
 // TODO(aluebs): Make the target angle dynamically settable.
 const float kTargetAngleRadians = static_cast<float>(M_PI) / 2.f;
 
+// The minimum separation in radians between the target direction and a

[Andrew MacDonald, 2015/10/14 23:38:53]

and an interferer

[aluebs-webrtc, 2015/10/17 00:54:49]

Done.

+// interferer scenario.
+const float kMinAwayRadians = 0.2f;
+
+// The separation between the target direction and the closest interferer
+// scenario is proportional to this constant.
+const float kAwaySlope = 0.008f;
+
 // When calculating the interference covariance matrix, this is the weight for
 // the weighted average between the uniform covariance matrix and the angled
 // covariance matrix.
 // Rpsi = Rpsi_angled * kBalance + Rpsi_uniform * (1 - kBalance)
 const float kBalance = 0.95f;
 
 const float kHalfBeamWidthRadians = static_cast<float>(M_PI) * 20.f / 180.f;
 
 // Alpha coefficients for mask smoothing.
 const float kMaskTimeSmoothAlpha = 0.2f;
@@ skipping 127 matching lines @@
       center += array_geometry[i].c[dim];
     }
     center /= array_geometry.size();
     for (size_t i = 0; i < array_geometry.size(); ++i) {
       array_geometry[i].c[dim] -= center;
     }
   }
   return array_geometry;
 }
 
+float GetMinimumSpacing(std::vector<Point> array_geometry) {

[Andrew MacDonald, 2015/10/14 23:38:53]

const reference

[aluebs-webrtc, 2015/10/17 00:54:50]

Done.

+  float mic_spacing = Distance(array_geometry[0], array_geometry[1]);
+  for (size_t i = 0; i < (array_geometry.size() - 1); ++i) {
+    for (size_t j = i + 1; j < array_geometry.size(); ++j) {
+      float distance = Distance(array_geometry[i], array_geometry[j]);

[Andrew MacDonald, 2015/10/14 23:38:53]

Not a big deal, but you're computing the first distance twice. Perhaps:
float mic_spacing = std::numeric_limits<float>::max();

OTOH, the very common two mic case will then have to enter the loop. Up to you.

[aluebs-webrtc, 2015/10/17 00:54:49]

Good suggestion. Done.

+      if (distance < mic_spacing) {
+        mic_spacing = distance;
+      }
+    }
+  }
+  return mic_spacing;
+}
+
 }  // namespace
 
 // static
 const size_t NonlinearBeamformer::kNumFreqBins;
 
 NonlinearBeamformer::NonlinearBeamformer(
     const std::vector<Point>& array_geometry)
-  : num_input_channels_(array_geometry.size()),
-      array_geometry_(GetCenteredArray(array_geometry)) {
+    : num_input_channels_(array_geometry.size()),
+      array_geometry_(GetCenteredArray(array_geometry)),
+      mic_spacing_(GetMinimumSpacing(array_geometry)) {
   WindowGenerator::KaiserBesselDerived(kKbdAlpha, kFftSize, window_);
 }
 
 void NonlinearBeamformer::Initialize(int chunk_size_ms, int sample_rate_hz) {
   chunk_length_ =
       static_cast<size_t>(sample_rate_hz / (1000.f / chunk_size_ms));
   sample_rate_hz_ = sample_rate_hz;
   low_mean_start_bin_ = Round(kLowMeanStartHz * kFftSize / sample_rate_hz_);
   low_mean_end_bin_ = Round(kLowMeanEndHz * kFftSize / sample_rate_hz_);
   high_mean_start_bin_ = Round(kHighMeanStartHz * kFftSize / sample_rate_hz_);
@@ skipping 42 matching lines @@
   for (size_t i = 0; i < kNumFreqBins; ++i) {
     rxiws_[i] = Norm(target_cov_mats_[i], delay_sum_masks_[i]);
     rpsiws_[i].clear();
     for (size_t j = 0; j < interf_angles_radians_.size(); ++j) {
       rpsiws_[i].push_back(Norm(*interf_cov_mats_[i][j], delay_sum_masks_[i]));
     }
   }
 }
 
 void NonlinearBeamformer::InitInterfAngles() {
-  // TODO(aluebs): Make kAway dependent on the mic spacing.
-  const float kAway = 0.5;
+  const float kAway =
+      std::min(static_cast<float>(M_PI),
+               std::max(kMinAwayRadians,
+                        kAwaySlope * static_cast<float>(M_PI) / mic_spacing_));
 
   interf_angles_radians_.clear();
   // TODO(aluebs): When the target angle is settable, make sure the interferer
   // scenarios aren't reflected over the target one for linear geometries.
   interf_angles_radians_.push_back(kTargetAngleRadians - kAway);
   interf_angles_radians_.push_back(kTargetAngleRadians + kAway);
 }
 
 void NonlinearBeamformer::InitDelaySumMasks() {
   for (size_t f_ix = 0; f_ix < kNumFreqBins; ++f_ix) {
@@ skipping 246 matching lines @@
                    new_mask_ + high_mean_end_bin_ + 1);
   if (new_mask_[quantile] > kMaskTargetThreshold) {
     is_target_present_ = true;
     interference_blocks_count_ = 0;
   } else {
     is_target_present_ = interference_blocks_count_++ < hold_target_blocks_;
   }
 }
 
 }  // namespace webrtc