Multiple independent Y-axis for several signals

[altar31]

Dear egui community,

I tried to plot multiple signals such as temperature, pressure and position over time.
Each signal is independent, and I would like to plot them on the same graph but with independent y-axis. However, my issue is that the signals doesn't scale to their respective y-axis but with the main y-axis...
How to fix it ?
Thanks in advance.

use eframe::egui::*;
use egui_plot::{AxisHints, GridMark, Legend, Line, Plot, PlotPoints};
use polars::prelude::*;
use std::ops::RangeInclusive;
#[derive(PartialEq, Default)]
pub struct PlotBackend {}

impl PlotBackend {
    fn temp_line(data: &DataFrame) -> Line {
        let t_vect = data.column("t").unwrap().f64().unwrap();
        let temp_vect = data.column("temp").unwrap().f64().unwrap();
        let temp_data: Vec<[f64; 2]> = t_vect
            .into_iter()
            .zip(temp_vect.into_iter())
            .map(|(t, temp)| [t.unwrap(), temp.unwrap()])
            .collect();

        Line::new(PlotPoints::new(temp_data)).color(Color32::from_rgb(200, 100, 100))
    }
    fn f_line(data: &DataFrame) -> Line {
        let t_vect = data.column("t").unwrap().f64().unwrap();
        let f_vect = data.column("force").unwrap().f64().unwrap();
        let f_data: Vec<[f64; 2]> = t_vect
            .into_iter()
            .zip(f_vect.into_iter())
            .map(|(t, force)| [t.unwrap(), force.unwrap()])
            .collect();

        Line::new(PlotPoints::new(f_data)).color(Color32::from_rgb(100, 200, 100))
    }
    fn z_line(data: &DataFrame) -> Line {
        let t_vect = data.column("t").unwrap().f64().unwrap();
        let z_vect = data.column("z").unwrap().f64().unwrap();
        let z_data: Vec<[f64; 2]> = t_vect
            .into_iter()
            .zip(z_vect.into_iter())
            .map(|(t, z)| [t.unwrap(), z.unwrap()])
            .collect();

        Line::new(PlotPoints::new(z_data)).color(Color32::from_rgb(60, 130, 246))
    }

    #[allow(clippy::unused_self)]
    pub fn ui(&mut self, ui: &mut Ui, data: &DataFrame) -> Response {
        let f_formatter = |mark: GridMark, _digits, _range: &RangeInclusive<f64>| {
            let value = 0.5 * mark.value;
            if is_approx_zero(value) {
                String::new()
            } else {
                format!("{:.2}", value)
            }
        };
        let z_formatter = |mark: GridMark, _digits, _range: &RangeInclusive<f64>| {
            let value = 0.01 * mark.value;
            if is_approx_zero(value) {
                String::new()
            } else {
                format!("{:.2}", value)
            }
        };

        // Define custom y-axis hints for each line
        let temp_y_axis = AxisHints::new_y().label("T (°C)").max_digits(4);
        let f_y_axis = AxisHints::new_y()
            .label("F (kN)")
            .max_digits(3)
            .formatter(f_formatter)
            .placement(egui_plot::HPlacement::Left);
        let z_y_axis = AxisHints::new_y()
            .label("Z (mm)")
            .formatter(z_formatter)
            .placement(egui_plot::HPlacement::Right);

        // Define x-axis hints
        let x_axes = vec![AxisHints::new_x().label("Time (s)")];

        // Construct custom y-axis hints vector
        let y_axes = vec![temp_y_axis, f_y_axis, z_y_axis];

        // Create the plot with custom axes
        let plot = Plot::new("custom_axes")
            .legend(Legend::default())
            .custom_x_axes(x_axes)
            .custom_y_axes(y_axes);

        // Show the plot with lines
        plot.show(ui, |plot_ui| {
            plot_ui.line(Self::temp_line(data).name("T (°C)"));
            plot_ui.line(Self::f_line(data).name("F (kN)"));
            plot_ui.line(Self::z_line(data).name("Z (mm)"));
        })
        .response
    }
}

fn is_approx_zero(value: f64) -> bool {
    value.abs() < 1e-6 // Adjust the epsilon value as needed
}```

[mrpathos]

Same question myself. Just reading through the code, it's not really clear what multiple custom y axes would be for. The code is very readable, and very clearly builds one set of bounds out of all the items you hand the plot, and makes a single transform for them, and then draws them all with that transform. So it appears the plot code just doesn't support this at all.

I'm in a similar boat, trying to plot related signals in different scales against each other. I'm considering just trying a super janky thing where I draw two entirely different Plots on top of each other and just disable all decoration on the second one. We'll see how it goes...

[mrpathos]

Actually, I found a halfway-decent solution, and suspect this might be what the custom_y_axes thing is for. It's janky, but when I generate each Line, I scale the y values in the points by some scalar to bring everything into roughly the same range, and then I add multiple custom_y_axes and give each a formatter that divides the tick mark value by the same scalar.

So for example, if I'm plotting voltage in the 0-100 range and amperage in the 0-3 range, I multiple all amperage values by 33.0, and then add a second custom axis that divides the tick value by 33.0.

Actually works fine.