use super::super::flat::flat_loss;
use super::compute::compute_drivers_combined_response;
use super::crossover_type::CrossoverType;
use super::driver_measurement::DriverMeasurement;
use ndarray::Array1;
#[derive(Debug, Clone)]
pub struct DriversLossData {
pub drivers: Vec<DriverMeasurement>,
pub crossover_type: CrossoverType,
pub freq_grid: Array1<f64>,
}
impl DriversLossData {
pub fn new(mut drivers: Vec<DriverMeasurement>, crossover_type: CrossoverType) -> Self {
let max_drivers = if crossover_type == CrossoverType::None {
usize::MAX
} else {
4
};
assert!(
drivers.len() >= 2 && drivers.len() <= max_drivers,
"Must have at least 2 drivers and at most 4 when using crossovers, got {}",
drivers.len()
);
drivers.sort_by(|a, b| {
a.mean_freq()
.partial_cmp(&b.mean_freq())
.unwrap_or(std::cmp::Ordering::Equal)
});
Self::from_ordered(drivers, crossover_type)
}
pub fn new_ordered(drivers: Vec<DriverMeasurement>, crossover_type: CrossoverType) -> Self {
let max_drivers = if crossover_type == CrossoverType::None {
usize::MAX
} else {
4
};
assert!(
drivers.len() >= 2 && drivers.len() <= max_drivers,
"Must have at least 2 drivers and at most 4 when using crossovers, got {}",
drivers.len()
);
Self::from_ordered(drivers, crossover_type)
}
fn from_ordered(drivers: Vec<DriverMeasurement>, crossover_type: CrossoverType) -> Self {
let min_freq = drivers
.iter()
.map(|d| d.freq_range().0)
.fold(f64::INFINITY, f64::min);
let max_freq = drivers
.iter()
.map(|d| d.freq_range().1)
.fold(f64::NEG_INFINITY, f64::max);
let freq_grid = crate::read::create_log_frequency_grid(
10 * 10, min_freq.max(20.0),
max_freq.min(20000.0),
);
Self {
drivers,
crossover_type,
freq_grid,
}
}
}
pub fn drivers_flat_loss(
data: &DriversLossData,
gains: &[f64],
crossover_freqs: &[f64],
delays: Option<&[f64]>,
sample_rate: f64,
min_freq: f64,
max_freq: f64,
) -> f64 {
let combined_response =
compute_drivers_combined_response(data, gains, crossover_freqs, delays, sample_rate);
let mut sum = 0.0;
let mut count = 0;
for i in 0..data.freq_grid.len() {
let freq = data.freq_grid[i];
if freq >= min_freq && freq <= max_freq {
sum += combined_response[i];
count += 1;
}
}
let mean = if count > 0 { sum / count as f64 } else { 0.0 };
let normalized = &combined_response - mean;
flat_loss(&data.freq_grid, &normalized, min_freq, max_freq)
}
#[cfg(test)]
mod tests {
use super::*;
fn measurement(offset: f64) -> DriverMeasurement {
DriverMeasurement {
freq: ndarray::Array1::from_vec(vec![20.0, 80.0, 200.0]),
spl: ndarray::Array1::from_vec(vec![70.0 + offset; 3]),
phase: None,
}
}
#[test]
fn no_crossover_supports_eight_subwoofers() {
let drivers = (0..8).map(|index| measurement(index as f64)).collect();
let data = DriversLossData::new(drivers, CrossoverType::None);
assert_eq!(data.drivers.len(), 8);
}
#[test]
#[should_panic(expected = "at most 4 when using crossovers")]
fn crossover_still_rejects_more_than_four_drivers() {
let drivers = (0..5).map(|index| measurement(index as f64)).collect();
let _ = DriversLossData::new(drivers, CrossoverType::LinkwitzRiley4);
}
}