1use plotly::common::Mode;
2use plotly::layout::{Axis, AxisType};
3use plotly::{Layout, Plot, Scatter};
4
5use crate::loss::{DriversLossData, compute_drivers_combined_response};
6
7pub 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 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 for (i, driver) in drivers_data.drivers.iter().enumerate() {
40 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)", 1 => "rgb(255, 127, 14)", 2 => "rgb(44, 160, 44)", 3 => "rgb(214, 39, 40)", _ => "rgb(128, 128, 128)", };
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 for (i, driver) in drivers_data.drivers.iter().enumerate() {
76 let driver_freq_grid = &driver.freq;
78
79 let mut response = &driver.spl + gains[i];
82
83 if let crate::loss::CrossoverType::None = drivers_data.crossover_type {
85 } else {
87 if i > 0 {
88 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 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 let color = match i {
187 0 => "rgb(31, 119, 180)", 1 => "rgb(255, 127, 14)", 2 => "rgb(44, 160, 44)", 3 => "rgb(214, 39, 40)", _ => "rgb(128, 128, 128)", };
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 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 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 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 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
281pub 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 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}