Aligning and linking an axis with different scale

[savagegreed]

Hello, I am trying to visualize the relation of velocity, acceleration, time and position of my parameters.
But i got stuck trying to achieve the intedend behavior.

my intended behavior,
Moving/panning/zooming X axis or Y axis in one of the plot would also perform the same changes in the other plot

the current behavior
Moving/panning/zooming X axis in the position plot, can update the X axis of timing plot.
Y axis is sort of stuck, unable to pan/zoom.

What other things i've tried
I tried using subplots to align x axis, but as the scale for position and timing are different which makes the allignment not correct.

Other thing to achieve: Ideally, the 2 plots graph should be identical , the only difference is the unit scale of X axis, so i would like them to be drawn in the same plot and have use axisx1 and axisx2 with the pan/zoom features for all the axis, and all the allignment should be correct.

Hopefully the idea is understandable, i just need some pointers / would appreciate a code that can do the intended behavior.

VelocityProfile_Axis_Alignment.mp4

Edit: ( forgot to attach the code)

        // Motion parameters
      // Motion parameters (all in mm and ms units)

              // assume units for distance is mm, and time is ms, acceleration would be mm/ms^2, velocity is mm/ms

        static float xMin = 0.0f;               // mm
        static float xMax = 100.0f;             // mm
        static float roiStart = 20.0f;          // mm
        static float roiEnd = 80.0f;            // mm
        static float maxVelocity = 0.050f;       // mm/ms
        static float acceleration = 0.100f;      // mm/ms²
        static float deceleration = 0.100f;      // mm/ms²

        ImGui::Begin("Velocity Profile");

        // Input controls
        ImGui::SliderFloat("X Min (mm)", &xMin, 0.0f, 100.0f);
        ImGui::SliderFloat("X Max (mm)", &xMax, xMin + 1.0f, 200.0f);

        // Clamp ROI to X range
        roiStart = std::clamp(roiStart, xMin, xMax - 1.0f);
        roiEnd = std::clamp(roiEnd, roiStart + 1.0f, xMax);

        ImGui::SliderFloat("ROI Start (mm)", &roiStart, xMin, xMax - 1.0f);
        ImGui::SliderFloat("ROI End (mm)", &roiEnd, roiStart + 1.0f, xMax);
        ImGui::SliderFloat("Max Velocity (mm/ms)", &maxVelocity, 0.010f, 0.100f, "%.4f");
        ImGui::SliderFloat("Acceleration (mm/ms²)", &acceleration, 0.010f, 0.500f, "%.4f");
        ImGui::SliderFloat("Deceleration (mm/ms²)", &deceleration, 0.010f, 0.500f, "%.4f");

        float roiLength = roiEnd - roiStart;

        // Compute max reachable velocity
        float maxReachableVelocity = sqrtf((2.0f * roiLength * acceleration * deceleration) / (acceleration + deceleration));

        float effectiveVelocity = maxVelocity;
        float accelDistance = (effectiveVelocity * effectiveVelocity) / (2.0f * acceleration);  // acceptable
        float decelDistance = (effectiveVelocity * effectiveVelocity) / (2.0f * deceleration);  // acceptable

        if (accelDistance + decelDistance > roiLength) { // acceptable
            effectiveVelocity = maxReachableVelocity;    // acceptable
            accelDistance = (effectiveVelocity * effectiveVelocity) / (2.0f * acceleration);    // acceptable
            decelDistance = (effectiveVelocity * effectiveVelocity) / (2.0f * deceleration);     // acceptable
        }

        float cruiseStart = roiStart + accelDistance;  // acceptable
        float cruiseEnd = roiEnd - decelDistance;  // acceptable

        // maybe not needed, since the checking is done at the start when clamping?
        //if (cruiseStart > cruiseEnd) {
        //    cruiseStart = (roiStart + roiEnd) / 2.0f;
        //    cruiseEnd = cruiseStart;
        //}

        // Time calculations (ms)
        //float t_accel = effectiveVelocity / acceleration; // acceptable
        //float t_accel = effectiveVelocity * effectiveVelocity / (2.0 * acceleration);
        float t_accel = effectiveVelocity / acceleration;
        float t_cruise = (cruiseEnd - cruiseStart) / effectiveVelocity; // acceptable
        float t_decel = effectiveVelocity / deceleration; // acceptable
        float t_total = t_accel + t_cruise + t_decel;   // accptable

        // Trapezoid points acceptable
        static float xPos[4], yVel[4], xTime[4];
        xPos[0] = roiStart;      yVel[0] = 0.0f;
        xPos[1] = cruiseStart;   yVel[1] = effectiveVelocity;
        xPos[2] = cruiseEnd;     yVel[2] = effectiveVelocity;
        xPos[3] = roiEnd;        yVel[3] = 0.0f;

        xTime[0] = 0.0f;
        xTime[1] = t_accel;
        xTime[2] = t_accel + t_cruise;
        xTime[3] = t_total;

        // Padding /// ok
        float velocityPadding = effectiveVelocity * 0.1f;
        float plotYMin = 0.0f;
        float plotYMax = effectiveVelocity + velocityPadding;

        double dou_plotYMin = plotYMin;
        double dou_plotYMax = plotYMax;

        //ok
        float positionPadding = roiLength * 0.1f;
        float plotXMin = roiStart - positionPadding;
        float plotXMax = roiEnd + positionPadding;

        double dou_plotXMin = plotXMin;
        double dou_plotXMax = plotXMax;


        // ok
        float timePadding = t_total * 0.1f;
        float plotTimeMin = xTime[0] - timePadding;
        float plotTimeMax = xTime[3] + timePadding;

        double dou_plotTimeMin = plotTimeMin;
        double dou_plotTimeMax = plotTimeMax;

   

        // need to link X axis. calculate the factor
        // for getting position given time
        float link_factor_slope1 = (plotTimeMax - plotTimeMin) / (plotXMax - plotXMin);
        float link_factor_constant1 = plotTimeMax - link_factor_slope1 * plotXMax;
        double offsetX2Factor_min = link_factor_slope1 * plotXMin + link_factor_constant1;
        double offsetX2Factor_max = link_factor_slope1 * plotXMax + link_factor_constant1;
        //
        //
        //
        float link_factor_slope2 = (plotXMax - plotXMin) / (plotTimeMax - plotTimeMin);
        float link_factor_constant2 = plotXMax - link_factor_slope2 * plotTimeMax;
        double offsetX1Factor_min = link_factor_slope2 * plotTimeMin + link_factor_constant2;
        double offsetX1Factor_max = link_factor_slope2 * plotTimeMax + link_factor_constant2;


//        static ImPlotSubplotFlags flags = ImPlotSubplotFlags_LinkRows | ImPlotSubplotFlags_LinkCols;
        //ImGui::CheckboxFlags("ImPlotSubplotFlags_LinkRows", (unsigned int*)&flags, ImPlotSubplotFlags_LinkRows);
        //ImGui::CheckboxFlags("ImPlotSubplotFlags_LinkCols", (unsigned int*)&flags, ImPlotSubplotFlags_LinkCols);
        //ImGui::CheckboxFlags("ImPlotSubplotFlags_LinkAllX", (unsigned int*)&flags, ImPlotSubplotFlags_LinkAllX);
        //ImGui::CheckboxFlags("ImPlotSubplotFlags_LinkAllY", (unsigned int*)&flags, ImPlotSubplotFlags_LinkAllY);

        static int rows = 2;
        static int cols = 1;

        static double limx1_min;
        static double limx1_max;
        static double limx2_min;
        static double limx2_max;

        static double offsetX1Factor_minA;
        static double offsetX1Factor_maxA;


        if (ImPlot::BeginPlot("Position")) {
            ImPlot::SetupAxisLimits(ImAxis_X1, plotXMin, plotXMax);
            ImPlot::SetupAxisLinks(ImAxis_Y1, &dou_plotYMin, &dou_plotYMax);

            ImPlot::PlotLine("Velocity vs Position", xPos, yVel, 4);

            limx1_min = ImPlot::GetPlotLimits().X.Min;
            limx1_max = ImPlot::GetPlotLimits().X.Max;

            ImPlot::EndPlot();
        }





        if (ImPlot::BeginPlot("Time")) {
            offsetX1Factor_minA = link_factor_slope1 * limx1_min + link_factor_constant1;
            offsetX1Factor_maxA = link_factor_slope1 * limx1_max + link_factor_constant1;

            ImPlot::SetupAxisLinks(ImAxis_X1, &offsetX1Factor_minA, &offsetX1Factor_maxA);
            ImPlot::SetupAxisLinks(ImAxis_Y1, &dou_plotYMin, &dou_plotYMax);

            ImPlot::PlotLine("Velocity vs Time", xTime, yVel, 4);

            limx2_min = ImPlot::GetPlotLimits().X.Min;
            limx2_max = ImPlot::GetPlotLimits().X.Max;

            ImPlot::EndPlot();
        }


        ImGui::Text("Axis1Min %.3f, Axis1Max % .3f", limx1_min, limx1_max);
        ImGui::Text("Axis2Min %.3f, Axis2Max % .3f", limx2_min, limx2_max);

        ImGui::Text("AxisNFactorMin %.3f, AxisFactorMax % .3f", offsetX1Factor_minA, offsetX1Factor_maxA);


       // Feedback
        ImGui::Text("Effective Velocity: %.4f mm/ms", effectiveVelocity);
        if (effectiveVelocity < maxVelocity) {
            ImGui::TextColored(ImVec4(1, 0.5f, 0, 1), "ROI too short for full velocity — clamped to fit.");
        }

        ImGui::Separator();
        ImGui::Text("Timing Estimates:");
        ImGui::Text("Ramp-Up Time: %.3f ms", t_accel);
        ImGui::Text("Cruise Time: %.3f ms", t_cruise);
        ImGui::Text("Ramp-Down Time: %.3f ms", t_decel);
        ImGui::Text("Total Motion Time: %.3f ms", t_total);

        ImGui::End();

[brenocq]

Hello hello! Thank you for providing the reproducible example! I think the problem is that you needed to update the plotXMin/plotXMax with the offsetX1Factor_minA/offsetX1Factor_maxA. You did the forward transform, but not the backward transform.

I wrote the working example below. Note that in my implementation, the X-axis center will always be the same on both plots. Depending on the x_factor, the second plot will have the X-axis range scaled up or down.

// Data
const float x[4] = {10.0f, 10.0f, 90.0f, 90.0f};
const float y[4] = {0.0f, 0.05f, 0.05f, 0.0f};

// Linked axes values
static double x_min = 0.0;
static double x_max = 100.0;
static double y_min = 0.0;
static double y_max = 0.1;

if (ImPlot::BeginPlot("Original axis")) {
    ImPlot::SetupAxisLinks(ImAxis_X1, &x_min, &x_max);
    ImPlot::SetupAxisLinks(ImAxis_Y1, &y_min, &y_max);

    ImPlot::PlotLine("Line", x, y, 4);

    ImPlot::EndPlot();
}

// Convert limits to new scale (x_min_scaled/x_max_scaled)
const double x_factor = 2; // Range will be twice the original range
const double x_range = x_max - x_min;
const double x_center = (x_min + x_max) / 2.0;
double x_range_scaled = x_range * x_factor;
double x_min_scaled = x_center - x_range_scaled / 2.0;
double x_max_scaled = x_center + x_range_scaled / 2.0;

if (ImPlot::BeginPlot("Scaled axis")) {
    ImPlot::SetupAxisLinks(ImAxis_X1, &x_min_scaled, &x_max_scaled);
    ImPlot::SetupAxisLinks(ImAxis_Y1, &y_min, &y_max);

    ImPlot::PlotLine("Line", x, y, 4);

    ImPlot::EndPlot();
}

// --- Undo Scaling to compute x_min/x_max ---
// 1. Find the new scaled range and its center
double x_range_scaled_after = x_max_scaled - x_min_scaled;   // Get updated range after user interaction
double x_center_after = (x_min_scaled + x_max_scaled) / 2.0; // Get updated center after user interaction
// 2. Calculate the original range
double x_range_after = x_range_scaled_after / x_factor;
// 3. Re-calculate the original min/max based on the center and original range
x_min = x_center_after - x_range_after / 2.0;
x_max = x_center_after + x_range_after / 2.0;

// --- Print values ---
ImGui::Text("Min %.3f, Max %.3f, Center %.3f, Range %.3f", x_min, x_max, x_center, x_range);
ImGui::Text("MinScaled %.3f, MaxScaled %.3f, CenterScaled %.3f, RangeScaled %.3f", x_min_scaled, x_max_scaled, x_center_after,
            x_range_scaled);

Video:

Peek.2025-09-29.17-31.mp4

Obs: I think this question would be a better fit in the Q&Adiscussion instead of issues.

[savagegreed]

Hello thank you for the reply, you're right i posted in the wrong location. Sorry about that, Im not too sure how to move it back to Q&A.

I see that your example provided further insight on using the SetupAxisLinks, I think i'll be able to further modify it to meet my intended behavior! thank you very much for your time!

Hello hello! Thank you for providing the reproducible example! I think the problem is that you needed to update the plotXMin/plotXMax with the offsetX1Factor_minA/offsetX1Factor_maxA. You did the forward transform, but not the backward transform.

I wrote the working example below. Note that in my implementation, the X-axis center will always be the same on both plots. Depending on the x_factor, the second plot will have the X-axis range scaled up or down.

// Data
const float x[4] = {10.0f, 10.0f, 90.0f, 90.0f};
const float y[4] = {0.0f, 0.05f, 0.05f, 0.0f};

// Linked axes values
static double x_min = 0.0;
static double x_max = 100.0;
static double y_min = 0.0;
static double y_max = 0.1;

if (ImPlot::BeginPlot("Original axis")) {
ImPlot::SetupAxisLinks(ImAxis_X1, &x_min, &x_max);
ImPlot::SetupAxisLinks(ImAxis_Y1, &y_min, &y_max);

ImPlot::PlotLine("Line", x, y, 4);

ImPlot::EndPlot();

}

// Convert limits to new scale (x_min_scaled/x_max_scaled)
const double x_factor = 2; // Range will be twice the original range
const double x_range = x_max - x_min;
const double x_center = (x_min + x_max) / 2.0;
double x_range_scaled = x_range * x_factor;
double x_min_scaled = x_center - x_range_scaled / 2.0;
double x_max_scaled = x_center + x_range_scaled / 2.0;

if (ImPlot::BeginPlot("Scaled axis")) {
ImPlot::SetupAxisLinks(ImAxis_X1, &x_min_scaled, &x_max_scaled);
ImPlot::SetupAxisLinks(ImAxis_Y1, &y_min, &y_max);

ImPlot::PlotLine("Line", x, y, 4);

ImPlot::EndPlot();

}

// --- Undo Scaling to compute x_min/x_max ---
// 1. Find the new scaled range and its center
double x_range_scaled_after = x_max_scaled - x_min_scaled; // Get updated range after user interaction
double x_center_after = (x_min_scaled + x_max_scaled) / 2.0; // Get updated center after user interaction
// 2. Calculate the original range
double x_range_after = x_range_scaled_after / x_factor;
// 3. Re-calculate the original min/max based on the center and original range
x_min = x_center_after - x_range_after / 2.0;
x_max = x_center_after + x_range_after / 2.0;

// --- Print values ---
ImGui::Text("Min %.3f, Max %.3f, Center %.3f, Range %.3f", x_min, x_max, x_center, x_range);
ImGui::Text("MinScaled %.3f, MaxScaled %.3f, CenterScaled %.3f, RangeScaled %.3f", x_min_scaled, x_max_scaled, x_center_after,
x_range_scaled);
Video:

Peek.2025-09-29.17-31.mp4
Obs: I think this question would be a better fit in the Q&Adiscussion instead of issues.