Refactor plots

Author: Tehforsch

Cargo.lock

@@ -16,6 +16,7 @@ futures = "0.3.30"
 hound = "3.5.1"
 iced = { version = "0.13.1", features = ["canvas"] }
 log = "0.4.22"
+ordered-float = "4.6.0"
 regex = "1"
 rodio = "0.19"
 serde = { version = "1.0", features = ["derive"] }

Cargo.toml

@@ -12,4 +12,4 @@ pub use cutting_strategy::*;
 pub use sample_reader::get_volume_at;
 pub use sample_reader::SampleReader;
 pub use sample_reader::WavFileReader;
-pub use time::{interpolate, interpolation_factor, AudioTime};
+pub use time::AudioTime;

src/audio/mod.rs

@@ -51,14 +51,6 @@ impl AudioTime {
     }
 }
 
-pub fn interpolate(start: AudioTime, end: AudioTime, factor: f64) -> AudioTime {
-    start + (end - start) * factor
-}
-
-pub fn interpolation_factor(start: AudioTime, end: AudioTime, x: AudioTime) -> f64 {
-    (x.time - start.time) / (end.time - start.time)
-}
-
 impl ops::Sub<AudioTime> for AudioTime {
     type Output = AudioTime;
 

src/audio/time.rs

@@ -3,24 +3,62 @@ use iced::{
     mouse::{self, Button},
     theme::Palette,
     widget::canvas::{path::Builder, Event, Frame, Geometry, Path, Program, Stroke},
-    Color, Point, Rectangle, Renderer, Theme, Vector,
+    Color, Point, Rectangle, Renderer, Theme,
 };
+use ordered_float::OrderedFloat;
 
 use crate::{
-    audio::{get_volume_at, interpolate, interpolation_factor, AudioTime, CutInfo, WavFileReader},
+    audio::{get_volume_at, AudioTime, CutInfo, WavFileReader},
     song::Song,
 };
 
-const WIDTH: f32 = 800.0;
-const HEIGHT: f32 = 50.0;
 const NUM_PLOT_POINTS: usize = 100;
 const PLOT_STROKE_WIDTH: f32 = 1.5;
-const PLOT_COLOR: Color = Palette::GRUVBOX_DARK.text;
+const PLOT_COLOR: Color = Palette::GRUVBOX_DARK.primary;
 const MARKER_STROKE_WIDTH: f32 = 2.5;
-const MARKER_COLOR: Color = Palette::GRUVBOX_DARK.primary;
+const MARKER_COLOR: Color = Palette::GRUVBOX_DARK.danger;
+
+type Volume = f32;
+
+struct Data {
+    time: AudioTime,
+    /// The volume of this data point normalized
+    /// by the maximum volume of all points in this
+    /// plot.
+    volume: Volume,
+}
+
+struct Bounds {
+    min_time: AudioTime,
+    max_time: AudioTime,
+    height: f32,
+    width: f32,
+}
+
+pub fn interpolate(start: AudioTime, end: AudioTime, factor: f32) -> AudioTime {
+    start + (end - start) * factor as f64
+}
+
+pub fn interpolation_factor(start: AudioTime, end: AudioTime, x: AudioTime) -> f64 {
+    (x.time - start.time) / (end.time - start.time)
+}
+
+impl Bounds {
+    fn x_pos_to_time(&self, pos: Point) -> AudioTime {
+        let f = pos.x / self.width;
+        interpolate(self.min_time, self.max_time, f)
+    }
+
+    fn data_to_point(&self, data: &Data) -> Point {
+        let f = interpolation_factor(self.min_time, self.max_time, data.time);
+        Point::new(f as f32 * self.width, data.volume * self.height)
+    }
+}
+
+impl Data {}
 
 pub struct Plot {
-    data: Vec<Point>,
+    volume_data: Vec<Data>,
     song_before: Option<Song>,
     song_after: Option<Song>,
     start: AudioTime,
@@ -40,16 +78,29 @@ impl Plot {
         let delta = AudioTime::from_time_same_spec(3.0, cut_time);
         let start = cut_time - delta;
         let end = cut_time + delta;
-        let data = (0..NUM_PLOT_POINTS)
+        let volume_data: Vec<_> = (0..NUM_PLOT_POINTS)
             .map(|i| {
                 let f = i as f32 / NUM_PLOT_POINTS as f32;
-                let time = interpolate(start, end, f as f64);
-                let vol = get_volume_at(reader, time).unwrap_or(0.0) as f32;
-                Point::new(f * WIDTH, HEIGHT / 2.0 + vol * HEIGHT)
+                let time = interpolate(start, end, f);
+                let volume = get_volume_at(reader, time).unwrap_or(0.0) as f32;
+                Data { time, volume }
+            })
+            .collect();
+        // Normalize
+        let max_volume = volume_data
+            .iter()
+            .map(|data| OrderedFloat(data.volume))
+            .max()
+            .unwrap();
+        let volume_data = volume_data
+            .into_iter()
+            .map(|data| Data {
+                time: data.time,
+                volume: data.volume / *max_volume,
             })
             .collect();
         Self {
-            data,
+            volume_data,
             song_before,
             song_after,
             start,
@@ -60,47 +111,44 @@ impl Plot {
         }
     }
 
-    fn pos_to_time(&self, pos: Point) -> AudioTime {
-        interpolate(self.start, self.end, (pos.x / WIDTH) as f64)
-    }
-
-    fn time_to_pos(&self, time: AudioTime) -> f32 {
-        WIDTH * interpolation_factor(self.start, self.end, time) as f32
-    }
-
-    pub fn get_plot_path(&self, data: &[Point]) -> Path {
+    pub fn get_plot_path(&self, data: &[Data], bounds: &Bounds) -> Path {
         let mut path = Builder::new();
 
         if data.len() > 0 {
-            path.move_to(data[0]);
-            for point in data.iter() {
-                path.line_to(*point);
+            path.move_to(bounds.data_to_point(&data[0]));
+            for data in data.iter() {
+                path.line_to(bounds.data_to_point(data));
             }
         }
         path.build()
     }
 
     /// Return the path left of the marker and the path right
     /// of the marker, so they can be colored individually.
-    pub fn get_plot_paths(&self) -> (Path, Path) {
+    pub fn get_plot_paths(&self, bounds: &Bounds) -> (Path, Path) {
         let cutoff = self
-            .data
+            .volume_data
             .iter()
             .enumerate()
-            .find(|(_, p)| self.pos_to_time(**p) > self.cut_time)
+            .find(|(_, data)| data.time > self.cut_time)
             .map(|(i, _)| i)
-            .unwrap_or(self.data.len() - 1);
+            .unwrap_or(self.volume_data.len() - 1);
         (
-            self.get_plot_path(&self.data[..=cutoff]),
-            self.get_plot_path(&self.data[cutoff..]),
+            self.get_plot_path(&self.volume_data[..=cutoff], bounds),
+            self.get_plot_path(&self.volume_data[cutoff..], bounds),
         )
     }
 
-    pub fn get_marker_path(&self) -> Path {
+    pub fn get_marker_path(&self, bounds: &Bounds) -> Path {
         let mut path = Builder::new();
-        let x = self.time_to_pos(self.cut_time);
-        path.move_to(Point::new(x, 0.0));
-        path.line_to(Point::new(x, HEIGHT));
+        path.move_to(bounds.data_to_point(&Data {
+            time: self.cut_time,
+            volume: -1.0,
+        }));
+        path.line_to(bounds.data_to_point(&Data {
+            time: self.cut_time,
+            volume: 1.0,
+        }));
         path.build()
     }
 
@@ -126,6 +174,15 @@ impl Plot {
     pub fn song_before(&self) -> Option<&Song> {
         self.song_before.as_ref()
     }
+
+    fn get_bounds(&self, bounds: Rectangle) -> Bounds {
+        Bounds {
+            width: bounds.width,
+            height: bounds.height,
+            min_time: self.volume_data.first().unwrap().time,
+            max_time: self.volume_data.last().unwrap().time,
+        }
+    }
 }
 
 pub struct PlotMarkerMoved {
@@ -139,16 +196,17 @@ impl Program<PlotMarkerMoved> for Plot {
         &self,
         _state: &mut Self::State,
         event: Event,
-        bounds: Rectangle,
+        rect: Rectangle,
         cursor: mouse::Cursor,
     ) -> (Status, Option<PlotMarkerMoved>) {
+        let bounds = self.get_bounds(rect);
         if let Event::Mouse(mouse::Event::ButtonPressed(ev)) = event {
             if ev == Button::Left {
-                if let Some(pos) = cursor.position_in(bounds) {
+                if let Some(pos) = cursor.position_in(rect) {
                     return (
                         Status::Ignored,
                         Some(PlotMarkerMoved {
-                            time: self.pos_to_time(pos),
+                            time: bounds.x_pos_to_time(pos),
                         }),
                     );
                 }
@@ -162,12 +220,13 @@ impl Program<PlotMarkerMoved> for Plot {
         _state: &(),
         renderer: &Renderer,
         _theme: &Theme,
-        bounds: Rectangle,
+        rect: Rectangle,
         _cursor: mouse::Cursor,
     ) -> Vec<Geometry> {
-        let mut frame = Frame::new(renderer, bounds.size());
+        let mut frame = Frame::new(renderer, rect.size());
 
-        let (plot_before, plot_after) = self.get_plot_paths();
+        let bounds = self.get_bounds(rect);
+        let (plot_before, plot_after) = self.get_plot_paths(&bounds);
         let color = |finished_cutting| {
             if finished_cutting {
                 Color::from_rgb(0.0, 0.8, 0.0)
@@ -187,7 +246,7 @@ impl Program<PlotMarkerMoved> for Plot {
                 .with_width(PLOT_STROKE_WIDTH)
                 .with_color(color(self.finished_cut_after)),
         );
-        let marker = self.get_marker_path();
+        let marker = self.get_marker_path(&bounds);
         frame.stroke(
             &marker,
             Stroke::default()

src/gui/plot.rs

@@ -9,12 +9,12 @@ use iced::alignment::Horizontal;
 use iced::stream::channel;
 use iced::widget::{column, horizontal_space, text, Canvas, Column, Row};
 use iced::Length::Fill;
-use iced::{Element, Subscription, Task};
+use iced::{Element, Subscription};
 use log::debug;
 
 use super::plot::{Plot, PlotMarkerMoved};
 
-const CANVAS_HEIGHT: f32 = 80.0;
+pub const CANVAS_HEIGHT: f32 = 80.0;
 
 #[derive(Clone, Debug)]
 pub enum SessionMessage {