let user choose scaling & fmt

Author: ecrax

build.rs

@@ -3,4 +3,4 @@ fn main() {
     if target.contains("windows") {
         embed_resource::compile("assets/icon.rc", embed_resource::NONE);
     }
-}
+}

src/components/microphone.rs

@@ -4,8 +4,8 @@ use egui::{Color32, Pos2, Rect};
 use serde::{Deserialize, Serialize};
 
 use super::gizmo::GizmoComponent;
-use crate::simulation::plugin::ComponentIDs;
 use crate::math::transformations::grid_to_image;
+use crate::simulation::plugin::ComponentIDs;
 use crate::ui::state::ToolType;
 
 /// A microphone on the grid that records the pressure at its position

src/components/source.rs

@@ -8,9 +8,9 @@ use rand::{thread_rng, Rng};
 use serde::{Deserialize, Serialize};
 
 use super::gizmo::GizmoComponent;
-use crate::simulation::plugin::ComponentIDs;
 use crate::math::constants::*;
 use crate::math::transformations::grid_to_image;
+use crate::simulation::plugin::ComponentIDs;
 use crate::ui::state::ToolType;
 
 /// A sound source on the grid

src/events.rs

@@ -4,8 +4,8 @@ use bevy_file_dialog::FileDialogExt;
 use crate::components::microphone::Microphone;
 use crate::components::source::Source;
 use crate::components::wall::{CircWall, RectWall};
-use crate::simulation::grid::Grid;
 use crate::render::gradient::Gradient;
+use crate::simulation::grid::Grid;
 use crate::ui::loading::SaveFileContents;
 use crate::ui::state::{SimTime, UiState};
 

src/input/mod.rs

@@ -1,2 +1,2 @@
-pub mod systems;
 pub mod plugin;
+pub mod systems;

src/lib.rs

@@ -2,9 +2,9 @@
 
 pub mod components;
 pub mod events;
-pub mod simulation;
 pub mod input;
 pub mod math;
 pub mod render;
+pub mod simulation;
 pub mod ui;
 pub mod undo;

src/math/fft.rs

@@ -1,16 +1,18 @@
-use spectrum_analyzer::scaling::scale_to_zero_to_one;
+use spectrum_analyzer::scaling::{scale_20_times_log10, scale_to_zero_to_one};
 use spectrum_analyzer::windows::hann_window;
 use spectrum_analyzer::{samples_fft_to_spectrum, FrequencyLimit};
 
 use crate::components::microphone::Microphone;
 use crate::math::constants::*;
+use crate::ui::state::FftScaling;
 
 /// Calculate the spectrum of a [`Microphone`] based on the record field.
 /// The spectrum is calculated using the FFT algorithm and a Hann window. The corresponding window size is specified in [`FFT_WINDOW_SIZE`].
-/// The spectrum is then mapped to a logarithmic scale and returned.
+/// The spectrum is then mapped to a logarithmic scale on the frequency axis and returned.
 /// * `microphone` - The microphone to calculate the spectrum for.
 /// * `ui_state` - The current state of the UI.
-pub fn calc_mic_spectrum(microphone: &Microphone) -> Vec<[f64; 2]> {
+/// * `scaling` - The scaling to apply to the spectrum on the amplitude axis.
+pub fn calc_mic_spectrum(microphone: &Microphone, scaling: FftScaling) -> Vec<[f64; 2]> {
     let samples = if microphone.record.len() < FFT_WINDOW_SIZE {
         let mut s = microphone.record.clone();
         s.resize(FFT_WINDOW_SIZE, [0.0, 0.0]);
@@ -28,7 +30,10 @@ pub fn calc_mic_spectrum(microphone: &Microphone) -> Vec<[f64; 2]> {
         // we can just use the constant value. Calculated as 1/(0.001 / 343) = 343200
         343200,
         FrequencyLimit::All,
-        Some(&scale_to_zero_to_one),
+        match scaling {
+            FftScaling::ZeroToOne => Some(&scale_to_zero_to_one),
+            FftScaling::Decibels => Some(&scale_20_times_log10),
+        },
     )
     .unwrap();
 

src/render/draw.rs

@@ -9,10 +9,10 @@ use super::gradient::Gradient;
 use crate::components::microphone::Microphone;
 use crate::components::states::Drag;
 use crate::components::wall::{CircWall, RectWall, WResize, Wall};
-use crate::simulation::grid::Grid;
 use crate::math::constants::{SIMULATION_HEIGHT, SIMULATION_WIDTH};
 use crate::math::transformations::{coords_to_index, map_range};
-use crate::ui::state::{FftMicrophone, UiState};
+use crate::simulation::grid::Grid;
+use crate::ui::state::{FftMicrophone, FftScaling, UiState};
 
 pub fn draw_pixels(
     pixel_buffers: QueryPixelBuffer,
@@ -85,7 +85,7 @@ pub fn draw_pixels(
 
             // TODO: maybe reset the frame each time the mic changes
 
-            let new_spectrum = crate::math::fft::calc_mic_spectrum(mic);
+            let new_spectrum = crate::math::fft::calc_mic_spectrum(mic, FftScaling::ZeroToOne);
             let frame_size = frame.size();
 
             // shift the old values to the left

src/ui/draw.rs

@@ -1173,6 +1173,7 @@ pub fn draw_egui(
                             fft_microphone: &mut fft_mic,
                             commands: &mut commands.reborrow(),
                             enabled_spectrogram: ui_state.enable_spectrogram,
+                            scaling: &mut ui_state.fft_scaling,
                         },
                     );
             });

src/ui/loading.rs

@@ -7,9 +7,9 @@ use crate::components::microphone::Microphone;
 use crate::components::source::Source;
 use crate::components::wall::{CircWall, RectWall};
 use crate::events::UpdateWalls;
+use crate::render::gradient::Gradient;
 use crate::simulation::grid::Grid;
 use crate::simulation::plugin::ComponentIDs;
-use crate::render::gradient::Gradient;
 
 /// Marker component for the file dialog and the corresponding event.
 pub struct SaveFileContents;

src/ui/state.rs

@@ -43,6 +43,21 @@ pub struct FftMicrophone {
     pub mic_id: Option<usize>,
 }
 
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum FftScaling {
+    ZeroToOne,
+    Decibels,
+}
+
+impl fmt::Display for FftScaling {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FftScaling::ZeroToOne => write!(f, "0-1"),
+            FftScaling::Decibels => write!(f, "dB"),
+        }
+    }
+}
+
 #[derive(Resource, PartialEq, Clone, Copy)]
 pub struct UiState {
     pub is_running: bool,
@@ -63,6 +78,7 @@ pub struct UiState {
     pub show_about: bool,
     pub show_help: bool,
     pub enable_spectrogram: bool,
+    pub fft_scaling: FftScaling,
 }
 
 impl Default for UiState {
@@ -89,6 +105,7 @@ impl Default for UiState {
             show_about: false,
             show_help: false,
             enable_spectrogram: false,
+            fft_scaling: FftScaling::ZeroToOne,
         }
     }
 }

src/ui/tabs.rs

@@ -7,7 +7,7 @@ use egui_plot::{GridMark, Line, Plot, PlotPoints};
 use plotters::prelude::*;
 
 use super::loading::SaveFileContents;
-use super::state::FftMicrophone;
+use super::state::{FftMicrophone, FftScaling};
 use crate::components::microphone::Microphone;
 use crate::math::fft::calc_mic_spectrum;
 
@@ -33,6 +33,7 @@ pub struct PlotTabs<'a> {
     pub mics: &'a [&'a Microphone],
     pub pixel_buffer: &'a mut PixelBuffersItem<'a>,
     pub fft_microphone: &'a mut FftMicrophone,
+    pub scaling: &'a mut FftScaling,
     pub commands: &'a mut Commands<'a, 'a>,
     pub enabled_spectrogram: bool,
 }
@@ -190,30 +191,54 @@ impl<'a> egui_dock::TabViewer for PlotTabs<'a> {
                     });
             }
             Tab::Frequency => {
-                egui::ComboBox::from_label("FFT Microphone")
-                    .selected_text(if let Some(index) = self.fft_microphone.mic_id {
-                        format!("Microphone {index}")
-                    } else {
-                        "No Microphone Selected".to_string()
-                    })
-                    .show_ui(ui, |ui| {
-                        for mic in self.mics {
+                ui.horizontal(|ui| {
+                    egui::ComboBox::from_label("FFT Microphone")
+                        .selected_text(if let Some(index) = self.fft_microphone.mic_id {
+                            format!("Microphone {index}")
+                        } else {
+                            "No Microphone Selected".to_string()
+                        })
+                        .show_ui(ui, |ui| {
+                            for mic in self.mics {
+                                ui.selectable_value(
+                                    &mut self.fft_microphone.mic_id,
+                                    Some(mic.id),
+                                    format!("Microphone {}", mic.id),
+                                );
+                            }
+                        });
+
+                    ui.add(egui::Separator::default().vertical());
+
+                    egui::ComboBox::from_label("Scaling")
+                        .selected_text(self.scaling.to_string())
+                        .show_ui(ui, |ui| {
                             ui.selectable_value(
-                                &mut self.fft_microphone.mic_id,
-                                Some(mic.id),
-                                format!("Microphone {}", mic.id),
+                                self.scaling,
+                                FftScaling::ZeroToOne,
+                                format!("{}", FftScaling::ZeroToOne),
                             );
-                        }
-                    });
+                            ui.selectable_value(
+                                self.scaling,
+                                FftScaling::Decibels,
+                                format!("{}", FftScaling::Decibels),
+                            );
+                        });
+                });
 
                 ui.separator();
+
+                let unit = match self.scaling {
+                    FftScaling::ZeroToOne => "(0-1)",
+                    FftScaling::Decibels => "(dB)",
+                };
                 Plot::new("fft_plot")
                     .allow_zoom([false, false])
                     .allow_scroll(false)
                     .allow_drag(false)
                     .allow_boxed_zoom(false)
                     .x_axis_label("Frequency (Hz)")
-                    .y_axis_label("Intensity (dB)")
+                    .y_axis_label(format!("Intensity {}", unit))
                     .x_grid_spacer(|input| {
                         let mut marks = Vec::with_capacity(
                             input.bounds.1 as usize - input.bounds.0 as usize + 1,
@@ -228,10 +253,11 @@ impl<'a> egui_dock::TabViewer for PlotTabs<'a> {
                         marks
                     })
                     .x_axis_formatter(|mark, _, _| format!("{:.0}", 10_f64.powf(mark.value)))
-                    .label_formatter(|_, value| {
+                    .label_formatter(move |_, value| {
                         format!(
-                            "Intensity: {:.2} dB\nFrequency: {:.2} Hz",
+                            "Intensity: {:.2} {}\nFrequency: {:.2} (Hz)",
                             value.y,
+                            unit,
                             10_f64.powf(value.x)
                         )
                     })
@@ -245,7 +271,7 @@ impl<'a> egui_dock::TabViewer for PlotTabs<'a> {
                             .iter()
                             .find(|m| m.id == self.fft_microphone.mic_id.expect("no mic selected"))
                         {
-                            let mapped_spectrum = calc_mic_spectrum(mic);
+                            let mapped_spectrum = calc_mic_spectrum(mic, *self.scaling);
                             // remove the first element, because of log it is at x=-inf
                             let mapped_spectrum = &mapped_spectrum[1..];