Updated: I want to display the value of the data point closest to the cursor. I see the problem.

[Lelick-PMR]

Hi all! Firstly, I want to thank the author for the great work done!
Secondly I want to apologize for my English. I write with translator!
Thirdly, I'm not a programmer! But, I urgently needed a program to display graphs from a log file.

I started studying BC Winforms C# + ScottPlot, since ScottPlot is faster than its competitors.

I didn’t know what to choose SP 4 or SP 5?

I decided to try both versions!
ScottPlot 4
I used the code from here #1762
modifying it a little
Here's a video, it works great!

ScottPlot.v4.1.mp4

ScottPlot 5
I used the code from here SignalXYDrag.cs
modifying it a little
here's a video, it's slow

ScottPlot.v5.0.34.mp4

        private void formsPlot1_MouseMove(object? sender, MouseEventArgs e)
        {

            (var signalUnderMouse, DataPoint dp) = GetSignalXYUnderMouse(formsPlot1.Plot, e.X, e.Y); 
                //Cursor = signalUnderMouse is null ? Cursors.Arrow : Cursors.SizeWE;
                HighlightedPoint.IsVisible = signalUnderMouse is not null;

                if (signalUnderMouse is not null)
                {
                    HighlightedPoint.Axes = signalUnderMouse.Axes ;
                    HighlightedPoint.Location = dp.Coordinates;
                    HighlightedPoint.Color = signalUnderMouse.Color;
                    formsPlot1.Plot.Title($"Index {dp.Index} at {dp.Coordinates} ");
                    formsPlot1.Refresh();
                }

                return;

        }

        private (SignalXY? signalXY, DataPoint point) GetSignalXYUnderMouse(Plot plot, double x, double y)
        {
            Pixel mousePixel = new(x, y);

            // --Coordinates mouseLocation = signal.Axes.GetCoordinates(mousePixel);

            foreach (SignalXY signal in plot.GetPlottables<SignalXY>().Reverse())
            {
                Coordinates mouseLocation = signal.Axes.GetCoordinates(mousePixel);

                DataPoint nearest = signal.GetNearest(mouseLocation, formsPlot1.Plot.LastRender);
                if (nearest.IsReal)
                {
                    return (signal, nearest);
                }
            }

            return (null, DataPoint.None);
        }

how can I speed up SP 5 like SP 4? Thanks!

[Lelick-PMR]

UPDATE

Windows 10
ScottPlot 5.0.34
WindowsForms
.NET 8.0

Maybe no one is interested? Maybe no one has time for this?

I tried to reproduce this problem in a special application for you. You can download this application and play with it.
Download AppSlowDemoSP5.zip

I also uploaded the VS project
Download ProjectSlowDemoSP5.zip

Try repeating the same steps with the application that I did in the video to reproduce the same problems that I get with the GetNearest() function.

1. First click the "Add Low Data" button
2. Then click the "Add High Data" button
3. Adjust the position of the graphs for convenience and watch how the search for the nearest values ​​occurs under the mouse cursor. Here you will see that searching for values ​​with High Data is slow.

then press the "Clear" button.
And generate the data again, but:

1. First click the "Add High Data" button
2. Then click the "Add Low Data" button
3. Adjust the position of the graphs for convenience.

Here you will see that 1 of the 2 signals is not visible to the mouse cursor! I think that it is located in a different place and not where it is drawn.

Demo video:

bandicam.2024-05-23.14-41-01-797.mp4

I think this is a problem!

Here's all the code:
(I apologize for the code if it's terrible, I'm not a programmer.)

using ScottPlot;
using ScottPlot.Plottables;

namespace SlowDemoSP5
{
    public partial class Form1 : Form
    {
        List<SignalXY> plotList = []; // for count only SignalXY plots
        bool right = false; // for additional axes: Add Left or Right
        private Marker? HighlightedPoint; // Marker point
        private SignalXY? sig; // signal

        public Form1()
        {
            InitializeComponent();
        }

        private void AddDataToPlot(int lenData, double minData, double maxData, string label)
        {

            double[] xs = Generate.Consecutive(lenData, 1, 0);
            double[] ys = Generate.RandomSample(lenData, minData, maxData);

            sig = formsPlot1.Plot.Add.SignalXY(xs, ys);
            //plotList.AddRange(formsPlot1.Plot.GetPlottables<SignalXY>()); 
            plotList.Add(sig);

            if (plotList.Count > 2)
            {
                if (right)
                {
                    sig.Axes.YAxis = formsPlot1.Plot.Axes.AddRightAxis();
                    right = false;
                }
                else
                {
                    sig.Axes.YAxis = formsPlot1.Plot.Axes.AddLeftAxis();
                    right = true;
                }
            }
            else
            {
                if (plotList.Count == 1)
                    sig.Axes.YAxis = formsPlot1.Plot.Axes.Left;

                if (plotList.Count == 2)
                    sig.Axes.YAxis = formsPlot1.Plot.Axes.Right;

            }

            sig.Axes.YAxis.Label.Text = $"{label} - {plotList.Count}";
            sig.Axes.YAxis.Label.ForeColor = sig.Color;
            sig.Axes.YAxis.FrameLineStyle.Color = sig.Color;
            sig.Axes.YAxis.MajorTickStyle.Color = sig.Color;
            sig.Axes.YAxis.MinorTickStyle.Color = sig.Color;
            sig.Axes.YAxis.TickLabelStyle.ForeColor = sig.Color;


            HighlightedPoint.IsVisible = false;
            HighlightedPoint.Size = 8;
            HighlightedPoint.Shape = MarkerShape.FilledCircle;

            formsPlot1.Plot.Axes.AutoScale();
            formsPlot1.Refresh();

        }

        private void formsPlot1_MouseMove(object? sender, MouseEventArgs e)
        {
            if (formsPlot1.Plot.PlottableList.Count > 0)
            {
                (var signalUnderMouse, DataPoint dp) = GetSignalXYUnderMouse(formsPlot1.Plot, e.X, e.Y);
                HighlightedPoint.IsVisible = signalUnderMouse is not null;

                if (signalUnderMouse is not null)
                {
                    HighlightedPoint.Axes = signalUnderMouse.Axes;
                    HighlightedPoint.Location = dp.Coordinates;
                    HighlightedPoint.Color = signalUnderMouse.Color;
                    formsPlot1.Plot.Axes.Title.Label.IsVisible = true;
                    formsPlot1.Plot.Axes.Title.Label.Text = $"Index {dp.Index} at {dp.Coordinates}";
                    formsPlot1.Plot.Axes.Title.Label.ForeColor = signalUnderMouse.Color;
                    formsPlot1.Refresh();
                }

                return;
            }
        }

        private (SignalXY? signalXY, DataPoint point) GetSignalXYUnderMouse(Plot plot, double x, double y)
        {
            Pixel mousePixel = new(x, y);

            foreach (SignalXY signal in plot.GetPlottables<SignalXY>().Reverse())
            {

                Coordinates mouseLocation = signal.Axes.GetCoordinates(mousePixel);
                RenderDetails RndDet = formsPlot1.Plot.LastRender;

                //where does the program stumble? GetNearest?
                DataPoint nearest = signal.Data.GetNearest(mouseLocation, RndDet);

                if (nearest.IsReal)
                {
                    return (signal, nearest);
                }
            }

            return (null, DataPoint.None);
        }

        private void NumValChanged()
        {
            trbDataLowMin.Value = (int)numDataLowMin.Value;
            trbDataLowMax.Value = (int)numDataLowMax.Value;
            trbDataHighMin.Value = (int)numDataHighMin.Value;
            trbDataHighMax.Value = (int)numDataHighMax.Value;
        }

        private void TrBarValChanged()
        {
            numDataLowMin.Value = trbDataLowMin.Value;
            numDataLowMax.Value = trbDataLowMax.Value;
            numDataHighMin.Value = trbDataHighMin.Value;
            numDataHighMax.Value = trbDataHighMax.Value;
        }

        private void numDataValueChanged(object sender, EventArgs e)
        {
            NumValChanged();
        }

        private void trbDataValueChanged(object sender, EventArgs e)
        {
            TrBarValChanged();
        }

        private void btnClear_Click(object sender, EventArgs e)
        {
            plotList.Clear();
            formsPlot1.Reset();
            formsPlot1.Refresh();
            right = false;

            HighlightedPoint = formsPlot1.Plot.Add.Marker(0, 0);
            HighlightedPoint.IsVisible = false;
        }

        private void btnAddDataLow_Click(object sender, EventArgs e)
        {
            AddDataToPlot((int)numLenData.Value, (double)numDataLowMin.Value, (double)numDataLowMax.Value, tbDataLowLabel.Text);
        }

        private void btnAddDataHigh_Click(object sender, EventArgs e)
        {
            AddDataToPlot((int)numLenData.Value, (double)numDataHighMin.Value, (double)numDataHighMax.Value, tbDataHighLabel.Text);
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            // Only after Reset() formsPlot1.Plot.Axes.Title.Label.Text = "string" is Worked
            formsPlot1.Reset();

            HighlightedPoint = formsPlot1.Plot.Add.Marker(0, 0);
            HighlightedPoint.IsVisible = false;
        }

        private void btnRefresh_Click(object sender, EventArgs e)
        {
            formsPlot1.Refresh();
        }
    }
}

@swharden please let me know if you read this! Thank you.

[swharden]

Hi @Lelick-PMR, I modified the following function and I think it is working better. Let me know what you think

private void formsPlot1_MouseMove(object? sender, MouseEventArgs e)
{
    if (formsPlot1.Plot.PlottableList.Count == 0)
        return;

    (var signalUnderMouse, DataPoint dp) = GetSignalXYUnderMouse(formsPlot1.Plot, e.X, e.Y);

    if (signalUnderMouse is null)
    {
        if (HighlightedPoint.IsVisible)
        {
            HighlightedPoint.IsVisible = false;
            formsPlot1.Refresh();
        }

        return;
    }

    if (HighlightedPoint.IsVisible && HighlightedPoint.Location == dp.Coordinates)
        return;

    HighlightedPoint.IsVisible = true;
    HighlightedPoint.Axes = signalUnderMouse.Axes;
    HighlightedPoint.Location = dp.Coordinates;
    HighlightedPoint.Color = signalUnderMouse.Color;
    formsPlot1.Plot.Axes.Title.Label.IsVisible = true;
    formsPlot1.Plot.Axes.Title.Label.Text = $"Index {dp.Index} at {dp.Coordinates}";
    formsPlot1.Plot.Axes.Title.Label.ForeColor = signalUnderMouse.Color;
    formsPlot1.Plot.XLabel($"Render count: {formsPlot1.Plot.RenderManager.RenderCount}");
    formsPlot1.Refresh();
}

[Lelick-PMR]

@swharden, I am very grateful to you for writing an answer to me.

I applied your code and this is how it works:

bandicam.2024-05-23.22-32-57-094.mp4

Nothing changed.

That's what I just noticed:

So that's it. If the limits of all signals are approximately the same, then searching for the nearest values ​​​​from the mouse cursor seems to work perfectly!

I don't know if I explained it clearly. But I also recorded a demo video of how it works!

bandicam.2024-05-23.23-09-29-447.mp4

[swharden]

Thanks for the videos clarifying things! I think we are narrowing in on the issue:

This line in GetSignalXYUnderMouse() is the problem...

Coordinates mouseLocation = signal.Axes.GetCoordinates(mousePixel);

It's determining where the mouse is in coordinate space only using the left vertical axis. It's confused because the second signal plot uses the right axis. I'm short on time at the moment so I can't look into it further, but I think the GetCoordinates() method has an overload that lets you specify which axis to use. Exploring that may be a start toward finding a solution!

[StendProg]

Here is extension method GetNearestX for ISignalXYSource. Call it istead of GetNearest and you get ScottPlot4 performance, but some different behaviour too.

   public static class SignalXYSourceDoubleArrayExtensions
   {
       public static DataPoint GetNearestX(this ISignalXYSource source, Coordinates mouseLocation, RenderDetails renderInfo, float maxDistance = 15)
       {
           double[] Xs = (double[])(typeof(SignalXYSourceDoubleArray).GetField("Xs", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(source));
           double[] Ys = (double[])(typeof(SignalXYSourceDoubleArray).GetField("Ys", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(source));

           var dataPoint = GetNearestXNoDistanceCheck(source, Xs, Ys, mouseLocation, renderInfo);

           var distanceX = (dataPoint.X + source.XOffset - mouseLocation.X) * renderInfo.PxPerUnitX;
           var distanceY = (dataPoint.Y * source.YScale + source.YOffset - mouseLocation.Y) * renderInfo.PxPerUnitY;
           var distanceSquare = distanceX * distanceX + distanceY * distanceY;

           if (distanceSquare < (maxDistance * maxDistance))
               return dataPoint;
           else
               return DataPoint.None;

       }

       private static DataPoint GetNearestXNoDistanceCheck(ISignalXYSource source, double[] Xs, double[] Ys, Coordinates mouseLocation, RenderDetails renderInfo)
       {
           var x = mouseLocation.X - source.XOffset;

           int index = Array.BinarySearch(Xs, source.MinimumIndex, source.MaximumIndex - source.MinimumIndex, x);
           if (index < 0)
           {
               index = ~index;
           }
           else // x equal to XS element 
           {
               return new DataPoint(Xs[index], Ys[index], index);
           }
           if (index <= source.MinimumIndex) // x lower then any MinRenderIndex 
               return new DataPoint(Xs[source.MinimumIndex], Ys[source.MinimumIndex], source.MinimumIndex);
           if (index > source.MaximumIndex) // x higher then MaxRenderIndex 
               return new DataPoint(Xs[source.MaximumIndex], Ys[source.MaximumIndex], source.MaximumIndex);

           double distLeftX = (x - Xs[index - 1])*renderInfo.PxPerUnitX;
           double distLeftY = (mouseLocation.Y * source.YScale + source.YOffset - Ys[index - 1])*renderInfo.PxPerUnitY;
           double distLeftSquare = distLeftX * distLeftX + distLeftY * distLeftY;

           double distRightX = (x - Xs[index])*renderInfo.PxPerUnitX;
           double distRightY = (mouseLocation.Y * source.YScale + source.YOffset - Ys[index])*renderInfo.PxPerUnitY;
           double distRightSquare = distRightX * distRightX + distRightY * distRightY;


           if (distLeftSquare <= distRightSquare) // x closer to XS[index -1] 
               return new DataPoint(Xs[index - 1], Ys[index - 1], index - 1);
           else // x closer to XS[index] 
               return new DataPoint(Xs[index], Ys[index], index);
       }
   }

If you implement it in the SignalXYSourceDoubleArray class, you won't need to get to the Xs and Ys arrays via reflection.

FastGetNearest.mp4

[StendProg]

The strange behavior on the different plottables you show in the discussion below is due to the fact that you are using additional Y axes. The GetNearest() interface is not adapted to this. In internal calculations, it uses PxPerUnitX and PxPerUnitY from RenderDetails to convert coordinates to pixels.
It takes these values most likely from the values of the main axes. Obviously, the additional axis has other PxPerUnitY values, and that's why calculations of distances in pixels are performed incorrectly.

At the moment, refusing to use additional axes is the easiest and the only way to solve this problem.