Add class for efficiently building B-Splines

This adds the IncrementalBSplineBuilder class which can be used to
build up a B-Spline from a series of linear points efficiently.
The class takes special care to keep the number of control points

osu.Framework.Benchmarks/BenchmarkPathApproximator.cs

@@ -0,0 +1,55 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#if NET6_0
+using System.Collections.Generic;
+using System;
+using BenchmarkDotNet.Attributes;
+using osu.Framework.Utils;
+using osuTK;
+using osu.Framework.Graphics.Primitives;
+
+namespace osu.Framework.Benchmarks
+{
+    public class BenchmarkPathApproximator : BenchmarkTest
+    {
+        private Vector2[] inputArr = Array.Empty<Vector2>();
+
+        public override void SetUp()
+        {
+            var input = new List<Vector2>();
+            var bounds = new RectangleF(0, 0, 512, 384);
+
+            var current = new Vector2(
+                Random.Shared.Next((int)bounds.Left, (int)bounds.Right + 1),
+                Random.Shared.Next((int)bounds.Top, (int)bounds.Bottom + 1)
+            );
+            while (input.Count < 25_000)
+            {
+                input.Add(current);
+
+                Vector2 next = current + new Vector2(
+                    (Random.Shared.NextSingle() - 0.5f) * 20f,
+                    (Random.Shared.NextSingle() - 0.5f) * 20f
+                );
+                while (!bounds.Contains(next))
+                {
+                    next = current + new Vector2(
+                        (Random.Shared.NextSingle() - 0.5f) * 20f,
+                        (Random.Shared.NextSingle() - 0.5f) * 20f
+                    );
+                }
+                current = next;
+            }
+
+            inputArr = input.ToArray();
+        }
+
+        [Benchmark]
+        public List<Vector2> GetBSpline()
+        {
+            return PathApproximator.PiecewiseLinearToBSpline(inputArr, 3);
+        }
+    }
+}
+#endif

osu.Framework.Tests/MathUtils/TestPathApproximator.cs

@@ -17,7 +17,7 @@ public void TestLagrange()
             // lagrange of (0,0) (0.5,0.35) (1,1) is equal to 0.6x*x + 0.4x
             Vector2[] points = { new Vector2(0, 0), new Vector2(0.5f, 0.35f), new Vector2(1, 1) };
 
-            List<Vector2> approximated = PathApproximator.ApproximateLagrangePolynomial(points);
+            List<Vector2> approximated = PathApproximator.LagrangePolynomialToPiecewiseLinear(points);
             Assert.Greater(approximated.Count, 10, "Approximated polynomial should have at least 10 points to test");
 
             for (int i = 0; i < approximated.Count; i++)
@@ -34,7 +34,7 @@ public void TestBSpline()
         {
             Vector2[] points = { new Vector2(0, 0), new Vector2(1, 0), new Vector2(1, -1), new Vector2(-1, -1), new Vector2(-1, 1), new Vector2(3, 2), new Vector2(3, 0) };
 
-            List<Vector2> approximated = PathApproximator.ApproximateBSpline(points, 4);
+            List<Vector2> approximated = PathApproximator.BSplineToPiecewiseLinear(points, 4);
             Assert.AreEqual(approximated.Count, 29, "Approximated path should have 29 points to test");
             Assert.True(Precision.AlmostEquals(approximated[0], points[0], 1e-4f));
             Assert.True(Precision.AlmostEquals(approximated[28], points[6], 1e-4f));

osu.Framework.Tests/Visual/Drawables/TestSceneCircularArcBoundingBox.cs

@@ -74,7 +74,7 @@ protected override void LoadComplete()
                 if (copy.Length != 3)
                     return;
 
-                path.Vertices = PathApproximator.ApproximateCircularArc(copy);
+                path.Vertices = PathApproximator.CircularArcToPiecewiseLinear(copy);
 
                 var bounds = PathApproximator.CircularArcBoundingBox(copy);
                 boundingBox.Size = bounds.Size;

osu.Framework.Tests/Visual/Drawables/TestSceneCustomEasingCurve.cs

@@ -165,7 +165,7 @@ protected override void Update()
                 vectorPath.AddRange(ordered.Select(p => p.PointPosition.Value));
                 vectorPath.Add(new Vector2(DrawWidth, 0));
 
-                var bezierPath = PathApproximator.ApproximateBezier(vectorPath.ToArray());
+                var bezierPath = PathApproximator.BezierToPiecewiseLinear(vectorPath.ToArray());
                 path.Vertices = bezierPath;
                 path.Position = -path.PositionInBoundingBox(Vector2.Zero);
 

osu.Framework.Tests/Visual/Drawables/TestSceneInteractivePathDrawing.cs

@@ -0,0 +1,108 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osuTK.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Lines;
+using osu.Framework.Input.Events;
+using osuTK.Input;
+using osu.Framework.Utils;
+using osuTK;
+
+namespace osu.Framework.Tests.Visual.Drawables
+{
+    [System.ComponentModel.Description("Approximate a hand-drawn path with minimal B-spline control points")]
+    public partial class TestSceneInteractivePathDrawing : FrameworkTestScene
+    {
+        private readonly Path rawDrawnPath;
+        private readonly Path approximatedDrawnPath;
+        private readonly Container controlPointViz;
+
+        private IncrementalBSplineBuilder bSplineBuilder = new IncrementalBSplineBuilder();
+
+        public TestSceneInteractivePathDrawing()
+        {
+            Child = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    rawDrawnPath = new Path
+                    {
+                        Colour = Color4.DeepPink,
+                        PathRadius = 5,
+                    },
+                    approximatedDrawnPath = new Path
+                    {
+                        Colour = Color4.Blue,
+                        PathRadius = 3,
+                    },
+                    controlPointViz = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0.5f,
+                    },
+                }
+            };
+
+            updateViz();
+            OnUpdate += _ => updateControlPointsViz();
+
+            AddStep("Reset path", () =>
+            {
+                bSplineBuilder.Clear();
+            });
+
+            AddSliderStep($"{nameof(bSplineBuilder.Degree)}", 1, 5, 3, v =>
+            {
+                bSplineBuilder.Degree = v;
+            });
+            AddSliderStep($"{nameof(bSplineBuilder.Tolerance)}", 0f, 1f, 0.1f, v =>
+            {
+                bSplineBuilder.Tolerance = v;
+            });
+        }
+
+        private void updateControlPointsViz()
+        {
+            controlPointViz.Clear();
+            foreach (var cp in bSplineBuilder.ControlPoints)
+            {
+                controlPointViz.Add(new Box
+                {
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(10),
+                    Position = cp,
+                    Colour = Color4.LightGreen,
+                });
+            }
+        }
+
+        protected override bool OnDragStart(DragStartEvent e)
+        {
+            if (e.Button == MouseButton.Left)
+            {
+                bSplineBuilder.Clear();
+                bSplineBuilder.AddLinearPoint(rawDrawnPath.ToLocalSpace(ToScreenSpace(e.MousePosition)));
+                return true;
+            }
+
+            return false;
+        }
+
+        private void updateViz()
+        {
+            rawDrawnPath.Vertices = bSplineBuilder.InputPath;
+            approximatedDrawnPath.Vertices = bSplineBuilder.OutputPath;
+
+            updateControlPointsViz();
+        }
+
+        protected override void OnDrag(DragEvent e)
+        {
+            bSplineBuilder.AddLinearPoint(rawDrawnPath.ToLocalSpace(ToScreenSpace(e.MousePosition)));
+        }
+    }
+}

osu.Framework.Tests/Visual/Drawables/TestScenePathApproximator.cs

@@ -10,36 +10,48 @@
 using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
+using osu.Framework.Graphics.Containers;
+using System.Linq;
+using osu.Framework.Graphics.Shapes;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
     public partial class TestScenePathApproximator : GridTestScene
     {
         public TestScenePathApproximator()
-            : base(2, 2)
+            : base(2, 3)
         {
             Cell(0).AddRange(new[]
             {
-                createLabel("ApproximateBezier"),
-                new ApproximatedPathTest(PathApproximator.ApproximateBezier),
+                createLabel("BezierToPiecewiseLinear"),
+                new ApproximatedPathTest(PathApproximator.BezierToPiecewiseLinear),
             });
 
             Cell(1).AddRange(new[]
             {
-                createLabel("ApproximateCatmull"),
-                new ApproximatedPathTest(PathApproximator.ApproximateCatmull),
+                createLabel("PiecewiseLinearToBSpline"),
+                new ApproximatedCurveTest(
+                    p => PathApproximator.PiecewiseLinearToBSpline(p, 3),
+                    p => PathApproximator.BSplineToPiecewiseLinear(p, 3)
+                ),
             });
 
             Cell(2).AddRange(new[]
             {
-                createLabel("ApproximateCircularArc"),
-                new ApproximatedPathTest(PathApproximator.ApproximateCircularArc),
+                createLabel("CatmullToPiecewiseLinear"),
+                new ApproximatedPathTest(PathApproximator.CatmullToPiecewiseLinear),
             });
 
             Cell(3).AddRange(new[]
             {
-                createLabel("ApproximateLagrangePolynomial"),
-                new ApproximatedPathTest(PathApproximator.ApproximateLagrangePolynomial),
+                createLabel("CircularArcToPiecewiseLinear"),
+                new ApproximatedPathTest(PathApproximator.CircularArcToPiecewiseLinear),
+            });
+
+            Cell(4).AddRange(new[]
+            {
+                createLabel("LagrangePolynomialToPiecewiseLinear"),
+                new ApproximatedPathTest(PathApproximator.LagrangePolynomialToPiecewiseLinear),
             });
         }
 
@@ -50,10 +62,10 @@ public TestScenePathApproximator()
             Colour = Color4.White,
         };
 
+        public delegate List<Vector2> ApproximatorFunc(ReadOnlySpan<Vector2> controlPoints);
+
         private partial class ApproximatedPathTest : SmoothPath
         {
-            public delegate List<Vector2> ApproximatorFunc(ReadOnlySpan<Vector2> controlPoints);
-
             public ApproximatedPathTest(ApproximatorFunc approximator)
             {
                 Vector2[] points = new Vector2[5];
@@ -70,5 +82,45 @@ public ApproximatedPathTest(ApproximatorFunc approximator)
                 Colour = Color4.White;
             }
         }
+
+        private partial class ApproximatedCurveTest : CompositeDrawable
+        {
+            public ApproximatedCurveTest(ApproximatorFunc piecewiseLinearToControlPoints, ApproximatorFunc controlPointsToPiecewiseLinear)
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                var linearCurve = new ApproximatedPathTest(v => v.ToArray().ToList())
+                {
+                    Colour = Color4.Blue
+                };
+                Vector2[]? controlPoints = null;
+                var approximatedCurve = new ApproximatedPathTest(v =>
+                {
+                    controlPoints = piecewiseLinearToControlPoints(v).ToArray();
+                    return controlPointsToPiecewiseLinear(controlPoints.AsSpan());
+                });
+
+                AddRangeInternal(new Drawable[]
+                {
+                    linearCurve,
+                    approximatedCurve,
+                });
+                if (controlPoints != null)
+                {
+                    foreach (var cp in controlPoints)
+                    {
+                        AddInternal(new Box
+                        {
+                            Size = new Vector2(5f),
+                            Colour = Color4.LightGreen,
+                            Alpha = 1f,
+                            Position = cp,
+                            Depth = -1f,
+                            Origin = Anchor.Centre,
+                        });
+                    }
+                }
+            }
+        }
     }
 }

osu.Framework.Tests/Visual/Graphics/TestSceneShaderStorageBufferObject.cs

@@ -123,7 +123,7 @@ public override void Draw(IRenderer renderer)
                 shader.Bind();
                 shader.BindUniformBlock("g_ColourBuffer", colourBuffer);
 
-                // Submit vertices, making sure that we don't submit an index which would overflow the SSBO.
+                // Submit rawDrawnPath, making sure that we don't submit an index which would overflow the SSBO.
                 for (int i = 0; i < areas.Count; i++)
                 {
                     vertices.Add(new ColourIndexedVertex

osu.Framework/Graphics/Lines/Path.cs

@@ -237,6 +237,16 @@ public void AddVertex(Vector2 pos)
             Invalidate(Invalidation.DrawSize);
         }
 
+        public void ReplaceVertex(int index, Vector2 pos)
+        {
+            vertices[index] = pos;
+
+            vertexBoundsCache.Invalidate();
+            segmentsCache.Invalidate();
+
+            Invalidate(Invalidation.DrawSize);
+        }
+
         private readonly List<Line> segmentsBacking = new List<Line>();
         private readonly Cached segmentsCache = new Cached();
         private List<Line> segments => segmentsCache.IsValid ? segmentsBacking : generateSegments();