Skip to main content

autoeq_plot/
plot_drivers.rs

1use plotly::common::Mode;
2use plotly::layout::{Axis, AxisType};
3use plotly::{Layout, Plot, Scatter};
4
5use crate::loss::{DriversLossData, compute_drivers_combined_response};
6
7/// Create a plot showing individual driver responses and the combined response
8///
9/// # Arguments
10/// * `drivers_data` - Multi-driver measurement data
11/// * `gains` - Optimized gain values for each driver (in dB)
12/// * `crossover_freqs` - Optimized crossover frequencies (in Hz)
13/// * `sample_rate` - Sample rate for filter design
14///
15/// # Returns
16/// * Plot object showing all drivers and their combined response
17pub fn plot_drivers(
18    drivers_data: &DriversLossData,
19    gains: &[f64],
20    crossover_freqs: &[f64],
21    delays: Option<&[f64]>,
22    sample_rate: f64,
23) -> Plot {
24    let mut plot = Plot::new();
25
26    let freq_grid = &drivers_data.freq_grid;
27
28    // First, compute the combined response to get a reference normalization
29    let combined_response = compute_drivers_combined_response(
30        drivers_data,
31        gains,
32        crossover_freqs,
33        delays,
34        sample_rate,
35    );
36    let combined_mean = combined_response.mean().unwrap_or(0.0);
37
38    // Plot individual drivers (raw responses)
39    for (i, driver) in drivers_data.drivers.iter().enumerate() {
40        // Interpolate driver response to common frequency grid
41        let interpolated = crate::read::normalize_and_interpolate_response(
42            freq_grid,
43            &crate::Curve {
44                freq: driver.freq.clone(),
45                spl: driver.spl.clone(),
46                phase: driver.phase.clone(),
47                ..Default::default()
48            },
49        );
50
51        let color = match i {
52            0 => "rgb(31, 119, 180)",  // Blue (woofer)
53            1 => "rgb(255, 127, 14)",  // Orange (tweeter)
54            2 => "rgb(44, 160, 44)",   // Green (midrange)
55            3 => "rgb(214, 39, 40)",   // Red (super tweeter)
56            _ => "rgb(128, 128, 128)", // Gray (fallback)
57        };
58
59        let trace = Scatter::new(freq_grid.to_vec(), interpolated.spl.to_vec())
60            .mode(Mode::Lines)
61            .name(format!("Driver {} (raw)", i + 1))
62            .line(
63                plotly::common::Line::new()
64                    .color(color)
65                    .width(1.5)
66                    .dash(plotly::common::DashType::Dash),
67            );
68
69        plot.add_trace(trace);
70    }
71
72    // Plot individual drivers with gains and crossovers applied
73    // Drivers are shown at their actual levels - if raw measurements have passbands at 0 dB,
74    // and gains are small, the processed passbands should also be near 0 dB
75    for (i, driver) in drivers_data.drivers.iter().enumerate() {
76        // Use the driver's own frequency range
77        let driver_freq_grid = &driver.freq;
78
79        // Use raw SPL values + gain (assumes raw measurements are already properly normalized)
80        // This avoids the 1000-2000 Hz normalization which doesn't work well for woofers
81        let mut response = &driver.spl + gains[i];
82
83        // Apply crossover filters on the driver's frequency grid
84        if let crate::loss::CrossoverType::None = drivers_data.crossover_type {
85            // No filters
86        } else {
87            if i > 0 {
88                // Apply highpass from crossover with previous driver
89                let xover_freq = crossover_freqs[i - 1];
90                let hp_filter = match drivers_data.crossover_type {
91                    crate::loss::CrossoverType::Butterworth2 => {
92                        crate::iir::peq_butterworth_highpass(2, xover_freq, sample_rate)
93                    }
94                    crate::loss::CrossoverType::Butterworth4 => {
95                        crate::iir::peq_butterworth_highpass(4, xover_freq, sample_rate)
96                    }
97                    crate::loss::CrossoverType::LinkwitzRiley2 => {
98                        crate::iir::peq_linkwitzriley_highpass(2, xover_freq, sample_rate)
99                    }
100                    crate::loss::CrossoverType::LinkwitzRiley4 => {
101                        crate::iir::peq_linkwitzriley_highpass(4, xover_freq, sample_rate)
102                    }
103                    crate::loss::CrossoverType::LinkwitzRiley8 => {
104                        crate::iir::peq_linkwitzriley_highpass(8, xover_freq, sample_rate)
105                    }
106                    crate::loss::CrossoverType::LinearPhase => vec![],
107                    crate::loss::CrossoverType::None => vec![],
108                };
109                let hp_response = if matches!(
110                    drivers_data.crossover_type,
111                    crate::loss::CrossoverType::LinearPhase
112                ) {
113                    let crossover = math_audio_iir_fir::FirCrossover::new(
114                        xover_freq,
115                        sample_rate,
116                        1,
117                        math_audio_iir_fir::DEFAULT_FIR_CROSSOVER_TAPS,
118                    );
119                    ndarray::Array1::from_iter(
120                        crate::response::compute_fir_complex_response(
121                            &crossover.highpass_coefficients(),
122                            driver_freq_grid,
123                            sample_rate,
124                        )
125                        .into_iter()
126                        .map(|z| 20.0 * z.norm().max(1e-12).log10()),
127                    )
128                } else {
129                    crate::iir::compute_peq_response(driver_freq_grid, &hp_filter, sample_rate)
130                };
131                response = response + hp_response;
132            }
133
134            if i < drivers_data.drivers.len() - 1 {
135                // Apply lowpass from crossover with next driver
136                let xover_freq = crossover_freqs[i];
137                let lp_filter = match drivers_data.crossover_type {
138                    crate::loss::CrossoverType::Butterworth2 => {
139                        crate::iir::peq_butterworth_lowpass(2, xover_freq, sample_rate)
140                    }
141                    crate::loss::CrossoverType::Butterworth4 => {
142                        crate::iir::peq_butterworth_lowpass(4, xover_freq, sample_rate)
143                    }
144                    crate::loss::CrossoverType::LinkwitzRiley2 => {
145                        crate::iir::peq_linkwitzriley_lowpass(2, xover_freq, sample_rate)
146                    }
147                    crate::loss::CrossoverType::LinkwitzRiley4 => {
148                        crate::iir::peq_linkwitzriley_lowpass(4, xover_freq, sample_rate)
149                    }
150                    crate::loss::CrossoverType::LinkwitzRiley8 => {
151                        crate::iir::peq_linkwitzriley_lowpass(8, xover_freq, sample_rate)
152                    }
153                    crate::loss::CrossoverType::LinearPhase => vec![],
154                    crate::loss::CrossoverType::None => vec![],
155                };
156                let lp_response = if matches!(
157                    drivers_data.crossover_type,
158                    crate::loss::CrossoverType::LinearPhase
159                ) {
160                    let crossover = math_audio_iir_fir::FirCrossover::new(
161                        xover_freq,
162                        sample_rate,
163                        1,
164                        math_audio_iir_fir::DEFAULT_FIR_CROSSOVER_TAPS,
165                    );
166                    ndarray::Array1::from_iter(
167                        crate::response::compute_fir_complex_response(
168                            crossover.lowpass_coefficients(),
169                            driver_freq_grid,
170                            sample_rate,
171                        )
172                        .into_iter()
173                        .map(|z| 20.0 * z.norm().max(1e-12).log10()),
174                    )
175                } else {
176                    crate::iir::compute_peq_response(driver_freq_grid, &lp_filter, sample_rate)
177                };
178                response = response + lp_response;
179            }
180        }
181
182        // Don't subtract combined_mean - each driver shows its contribution
183        // The raw measurements are already normalized to 0 dB in their passband
184        // After applying gain and crossover, the passband should stay near 0 dB
185
186        let color = match i {
187            0 => "rgb(31, 119, 180)",  // Blue (woofer)
188            1 => "rgb(255, 127, 14)",  // Orange (tweeter)
189            2 => "rgb(44, 160, 44)",   // Green (midrange)
190            3 => "rgb(214, 39, 40)",   // Red (super tweeter)
191            _ => "rgb(128, 128, 128)", // Gray (fallback)
192        };
193
194        let trace = Scatter::new(driver_freq_grid.to_vec(), response.to_vec())
195            .mode(Mode::Lines)
196            .name(format!("Driver {} ({:+.1} dB)", i + 1, gains[i]))
197            .line(plotly::common::Line::new().color(color).width(2.0));
198
199        plot.add_trace(trace);
200    }
201
202    // Plot combined response (already computed above, now normalize it)
203    let combined_response_normalized = &combined_response - combined_mean;
204
205    let trace_combined = Scatter::new(freq_grid.to_vec(), combined_response_normalized.to_vec())
206        .mode(Mode::Lines)
207        .name("Combined Response")
208        .line(plotly::common::Line::new().color("rgb(0, 0, 0)").width(3.0));
209
210    plot.add_trace(trace_combined);
211
212    // Add vertical lines for crossover frequencies
213    let mut shapes = Vec::new();
214    let mut annotations = Vec::new();
215    for (i, &xover_freq) in crossover_freqs.iter().enumerate() {
216        let shape = plotly::layout::Shape::new()
217            .shape_type(plotly::layout::ShapeType::Line)
218            .x_ref("x")
219            .y_ref("paper")
220            .x0(xover_freq)
221            .x1(xover_freq)
222            .y0(0.0)
223            .y1(1.0)
224            .line(
225                plotly::layout::ShapeLine::new()
226                    .color("rgba(150, 150, 150, 0.6)")
227                    .width(2.0)
228                    .dash(plotly::common::DashType::Dot),
229            );
230        shapes.push(shape);
231
232        // Add annotation for crossover frequency
233        let annotation = plotly::layout::Annotation::new()
234            .x(xover_freq)
235            .y(1.02)
236            .x_ref("x")
237            .y_ref("paper")
238            .text(format!("Crossover {}: {:.0} Hz", i + 1, xover_freq))
239            .show_arrow(false)
240            .font(
241                plotly::common::Font::new()
242                    .size(10)
243                    .color("rgb(100, 100, 100)"),
244            )
245            .x_anchor(plotly::common::Anchor::Center)
246            .y_anchor(plotly::common::Anchor::Bottom);
247        annotations.push(annotation);
248    }
249
250    // Create layout
251    let crossover_type_str = drivers_data.crossover_type.display_name();
252
253    let layout = Layout::new()
254        .title(format!(
255            "Multi-Driver Crossover Optimization ({})",
256            crossover_type_str
257        ))
258        .x_axis(
259            Axis::new()
260                .title("Frequency (Hz)".to_string())
261                .type_(AxisType::Log)
262                .range(vec![1.301, 4.301])
263                .grid_color("rgba(128, 128, 128, 0.2)"),
264        )
265        .y_axis(
266            Axis::new()
267                .title("SPL (dB)".to_string())
268                .range(vec![-30.0, 30.0])
269                .grid_color("rgba(128, 128, 128, 0.2)"),
270        )
271        .shapes(shapes)
272        .annotations(annotations)
273        .height(600)
274        .hover_mode(plotly::layout::HoverMode::X);
275
276    plot.set_layout(layout);
277
278    plot
279}
280
281/// Generate and save an HTML plot for multi-driver optimization results
282///
283/// # Arguments
284/// * `drivers_data` - Multi-driver measurement data
285/// * `gains` - Optimized gain values for each driver (in dB)
286/// * `crossover_freqs` - Optimized crossover frequencies (in Hz)
287/// * `sample_rate` - Sample rate for filter design
288/// * `output_path` - Path to save the HTML file
289///
290/// # Returns
291/// * Result indicating success or failure
292pub fn plot_drivers_results(
293    drivers_data: &DriversLossData,
294    gains: &[f64],
295    crossover_freqs: &[f64],
296    delays: Option<&[f64]>,
297    sample_rate: f64,
298    output_path: &std::path::Path,
299) -> Result<(), Box<dyn std::error::Error>> {
300    use build_html::*;
301    use std::fs::File;
302    use std::io::Write;
303
304    let plot = plot_drivers(drivers_data, gains, crossover_freqs, delays, sample_rate);
305
306    let title_text = format!(
307        "{}-Way Speaker Crossover Optimization",
308        drivers_data.drivers.len()
309    );
310
311    let html = HtmlPage::new()
312        .with_title(&title_text)
313        .with_script_link("https://cdn.plot.ly/plotly-3.2.0.min.js")
314        .with_raw(plot.to_inline_html(Some("drivers")))
315        .to_html_string();
316
317    // Ensure parent directory exists before writing files
318    let html_output_path = output_path.with_extension("html");
319    if let Some(parent) = html_output_path.parent() {
320        std::fs::create_dir_all(parent)?;
321    }
322
323    let mut file = File::create(&html_output_path)?;
324    file.write_all(html.as_bytes())?;
325    file.flush()?;
326
327    Ok(())
328}