Refactor WebGPU encoder and linearize path model

Author: JimBobSquarePants

src/ImageSharp.Drawing.WebGPU/WebGPUSceneEncoder.cs

@@ -44,6 +44,8 @@ public ArcLineSegment(PointF from, PointF to, SizeF radius, float rotation, bool
         {
             this.linePoints = EllipticArcFromEndParams(from, to, radius, rotation, largeArc, sweep);
         }
+
+        this.Bounds = CalculateBounds(this.linePoints);
     }
 
     /// <summary>
@@ -78,16 +80,39 @@ public ArcLineSegment(PointF center, SizeF radius, float rotation, float startAn
         {
             this.linePoints = EllipticArcFromEndParams(from, to, radius, rotation, largeArc, sweep);
         }
+
+        this.Bounds = CalculateBounds(this.linePoints);
+    }
+
+    private ArcLineSegment(PointF[] linePoints)
+    {
+        this.linePoints = linePoints;
+        this.Bounds = CalculateBounds(linePoints);
     }
 
-    private ArcLineSegment(PointF[] linePoints) => this.linePoints = linePoints;
+    /// <inheritdoc/>
+    public PointF StartPoint => this.linePoints[0];
 
     /// <inheritdoc/>
     public PointF EndPoint => this.linePoints[^1];
 
+    /// <inheritdoc />
+    public RectangleF Bounds { get; }
+
+    /// <inheritdoc />
+    public int LinearVertexCount => this.linePoints.Length;
+
     /// <inheritdoc/>
     public ReadOnlyMemory<PointF> Flatten() => this.linePoints;
 
+    /// <inheritdoc />
+    public void CopyTo(Span<PointF> destination, bool skipFirstPoint)
+    {
+        int startIndex = skipFirstPoint ? 1 : 0;
+
+        this.linePoints.AsSpan(startIndex).CopyTo(destination);
+    }
+
     /// <summary>
     /// Transforms the current <see cref="ArcLineSegment"/> using specified matrix.
     /// </summary>
@@ -112,6 +137,28 @@ public ILineSegment Transform(Matrix4x4 matrix)
     /// <inheritdoc/>
     ILineSegment ILineSegment.Transform(Matrix4x4 matrix) => this.Transform(matrix);
 
+    /// <summary>
+    /// Computes the bounds for the retained linearized arc points.
+    /// </summary>
+    private static RectangleF CalculateBounds(ReadOnlySpan<PointF> points)
+    {
+        float minX = float.MaxValue;
+        float minY = float.MaxValue;
+        float maxX = float.MinValue;
+        float maxY = float.MinValue;
+
+        for (int i = 0; i < points.Length; i++)
+        {
+            PointF point = points[i];
+            minX = MathF.Min(minX, point.X);
+            minY = MathF.Min(minY, point.Y);
+            maxX = MathF.Max(maxX, point.X);
+            maxY = MathF.Max(maxY, point.Y);
+        }
+
+        return RectangleF.FromLTRB(minX, minY, maxX, maxY);
+    }
+
     private static PointF[] EllipticArcFromEndParams(
         PointF from,
         PointF to,

src/ImageSharp.Drawing/ArcLineSegment.cs

@@ -17,6 +17,8 @@ public sealed class ComplexPolygon : IPath, IPathInternals, IInternalPathOwner
     private List<InternalPath>? internalPaths;
     private float length;
     private RectangleF? bounds;
+    private IPath? closedPath;
+    private LinearGeometry? linearGeometry;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ComplexPolygon"/> class.
@@ -97,6 +99,98 @@ public IEnumerable<ISimplePath> Flatten()
         return paths;
     }
 
+    /// <inheritdoc />
+    public LinearGeometry ToLinearGeometry()
+    {
+        if (this.linearGeometry is not null)
+        {
+            return this.linearGeometry;
+        }
+
+        int pointCount = 0;
+        int contourCount = 0;
+        int segmentCount = 0;
+
+        bool hasBounds = false;
+        float minX = float.MaxValue;
+        float minY = float.MaxValue;
+        float maxX = float.MinValue;
+        float maxY = float.MinValue;
+
+        foreach (IPath path in this.paths)
+        {
+            LinearGeometry geometry = path.ToLinearGeometry();
+
+            if (geometry.Info.PointCount == 0)
+            {
+                continue;
+            }
+
+            RectangleF childBounds = geometry.Info.Bounds;
+            minX = MathF.Min(minX, childBounds.Left);
+            minY = MathF.Min(minY, childBounds.Top);
+            maxX = MathF.Max(maxX, childBounds.Right);
+            maxY = MathF.Max(maxY, childBounds.Bottom);
+            hasBounds = true;
+
+            pointCount += geometry.Info.PointCount;
+            contourCount += geometry.Info.ContourCount;
+            segmentCount += geometry.Info.SegmentCount;
+        }
+
+        PointF[] points = new PointF[pointCount];
+        LinearContour[] contours = new LinearContour[contourCount];
+        int pointStart = 0;
+        int contourStart = 0;
+        int segmentStart = 0;
+
+        foreach (IPath path in this.paths)
+        {
+            LinearGeometry geometry = path.ToLinearGeometry();
+            if (geometry.Info.PointCount == 0)
+            {
+                continue;
+            }
+
+            for (int i = 0; i < geometry.Points.Count; i++)
+            {
+                points[pointStart + i] = geometry.Points[i];
+            }
+
+            for (int i = 0; i < geometry.Contours.Count; i++)
+            {
+                LinearContour contour = geometry.Contours[i];
+                contours[contourStart + i] = new LinearContour
+                {
+                    PointStart = pointStart + contour.PointStart,
+                    PointCount = contour.PointCount,
+                    SegmentStart = segmentStart + contour.SegmentStart,
+                    SegmentCount = contour.SegmentCount,
+                    IsClosed = contour.IsClosed
+                };
+            }
+
+            pointStart += geometry.Info.PointCount;
+            contourStart += geometry.Info.ContourCount;
+            segmentStart += geometry.Info.SegmentCount;
+        }
+
+        RectangleF bounds = hasBounds ? RectangleF.FromLTRB(minX, minY, maxX, maxY) : RectangleF.Empty;
+
+        this.linearGeometry = new LinearGeometry(
+            new LinearGeometryInfo
+            {
+                Bounds = bounds,
+                ContourCount = contours.Length,
+                PointCount = points.Length,
+                SegmentCount = segmentCount
+            },
+            contours,
+            points);
+
+        return this.linearGeometry;
+    }
+
     /// <inheritdoc/>
     public IPath AsClosedPath()
     {
@@ -105,13 +199,19 @@ public IPath AsClosedPath()
             return this;
         }
 
+        if (this.closedPath is not null)
+        {
+            return this.closedPath;
+        }
+
         IPath[] paths = new IPath[this.paths.Length];
         for (int i = 0; i < this.paths.Length; i++)
         {
             paths[i] = this.paths[i].AsClosedPath();
         }
 
-        return new ComplexPolygon(paths);
+        this.closedPath = new ComplexPolygon(paths);
+        return this.closedPath;
     }
 
     /// <inheritdoc/>

src/ImageSharp.Drawing/ComplexPolygon.cs

@@ -12,15 +12,12 @@ namespace SixLabors.ImageSharp.Drawing;
 /// <seealso cref="ILineSegment" />
 public sealed class CubicBezierLineSegment : ILineSegment
 {
-    // code for this taken from <see href="http://devmag.org.za/2011/04/05/bzier-curves-a-tutorial/"/>
+    // Code for this taken from <see href="http://devmag.org.za/2011/04/05/bzier-curves-a-tutorial/"/>
     private const float MinimumSqrDistance = 1.75f;
     private const float DivisionThreshold = -.9995f;
 
-    /// <summary>
-    /// The line points.
-    /// </summary>
+    private RectangleF? bounds;
     private PointF[]? linePoints;
-
     private readonly PointF[] controlPoints;
 
     /// <summary>
@@ -64,11 +61,29 @@ public CubicBezierLineSegment(PointF start, PointF controlPoint1, PointF control
     /// </summary>
     public IReadOnlyList<PointF> ControlPoints => this.controlPoints;
 
+    /// <inheritdoc/>
+    public PointF StartPoint => this.controlPoints[0];
+
     /// <inheritdoc/>
     public PointF EndPoint => this.controlPoints[^1];
 
+    /// <inheritdoc />
+    public RectangleF Bounds => this.bounds ??= CalculateBounds(this.GetLinePoints());
+
+    /// <inheritdoc />
+    public int LinearVertexCount => this.GetLinePoints().Length;
+
     /// <inheritdoc/>
-    public ReadOnlyMemory<PointF> Flatten() => this.linePoints ??= GetDrawingPoints(this.controlPoints);
+    public ReadOnlyMemory<PointF> Flatten() => this.GetLinePoints();
+
+    /// <inheritdoc />
+    public void CopyTo(Span<PointF> destination, bool skipFirstPoint)
+    {
+        PointF[] linePoints = this.GetLinePoints();
+        int startIndex = skipFirstPoint ? 1 : 0;
+
+        linePoints.AsSpan(startIndex).CopyTo(destination);
+    }
 
     /// <summary>
     /// Gets the control points of this curve.
@@ -102,10 +117,15 @@ public CubicBezierLineSegment Transform(Matrix4x4 matrix)
     /// <inheritdoc/>
     ILineSegment ILineSegment.Transform(Matrix4x4 matrix) => this.Transform(matrix);
 
+    private PointF[] GetLinePoints()
+        => this.linePoints ??= GetDrawingPoints(this.controlPoints);
+
     private static PointF[] GetDrawingPoints(PointF[] controlPoints)
     {
-        List<PointF> drawingPoints = [];
+        // Each cubic contributes its end point plus a small number of midpoint inserts in the common case,
+        // so 4 points per curve is a cheap baseline that avoids most growth without a sizing prepass.
         int curveCount = (controlPoints.Length - 1) / 3;
+        List<PointF> drawingPoints = new(curveCount * 4);
 
         for (int curveIndex = 0; curveIndex < curveCount; curveIndex++)
         {
@@ -200,4 +220,26 @@ private static Vector2 CalculateBezierPoint(float t, Vector2 p0, Vector2 p1, Vec
 
         return p;
     }
+
+    /// <summary>
+    /// Computes the bounds for the cached linearized bezier points.
+    /// </summary>
+    private static RectangleF CalculateBounds(ReadOnlySpan<PointF> points)
+    {
+        float minX = float.MaxValue;
+        float minY = float.MaxValue;
+        float maxX = float.MinValue;
+        float maxY = float.MinValue;
+
+        for (int i = 0; i < points.Length; i++)
+        {
+            PointF point = points[i];
+            minX = MathF.Min(minX, point.X);
+            minY = MathF.Min(minY, point.Y);
+            maxX = MathF.Max(maxX, point.X);
+            maxY = MathF.Max(maxY, point.Y);
+        }
+
+        return RectangleF.FromLTRB(minX, minY, maxX, maxY);
+    }
 }

src/ImageSharp.Drawing/CubicBezierLineSegment.cs

@@ -10,6 +10,17 @@ namespace SixLabors.ImageSharp.Drawing;
 /// </summary>
 public sealed class EmptyPath : IPath
 {
+    private static readonly LinearGeometry EmptyGeometry = new(
+        new LinearGeometryInfo
+        {
+            Bounds = RectangleF.Empty,
+            ContourCount = 0,
+            PointCount = 0,
+            SegmentCount = 0
+        },
+        [],
+        []);
+
     private EmptyPath(PathTypes pathType) => this.PathType = pathType;
 
     /// <summary>
@@ -34,6 +45,9 @@ public sealed class EmptyPath : IPath
     /// <inheritdoc />
     public IEnumerable<ISimplePath> Flatten() => [];
 
+    /// <inheritdoc />
+    public LinearGeometry ToLinearGeometry() => EmptyGeometry;
+
     /// <inheritdoc />
     public IPath Transform(Matrix4x4 matrix) => this;
 }

src/ImageSharp.Drawing/EmptyPath.cs

@@ -10,6 +10,11 @@ namespace SixLabors.ImageSharp.Drawing;
 /// </summary>
 public interface ILineSegment
 {
+    /// <summary>
+    /// Gets the start point.
+    /// </summary>
+    public PointF StartPoint { get; }
+
     /// <summary>
     /// Gets the end point.
     /// </summary>
@@ -18,12 +23,29 @@ public interface ILineSegment
     /// </value>
     public PointF EndPoint { get; }
 
+    /// <summary>
+    /// Gets the bounds of the linearized segment output.
+    /// </summary>
+    public RectangleF Bounds { get; }
+
+    /// <summary>
+    /// Gets the number of linear vertices emitted by this segment.
+    /// </summary>
+    public int LinearVertexCount { get; }
+
     /// <summary>
     /// Converts the <see cref="ILineSegment" /> into a simple linear path..
     /// </summary>
     /// <returns>Returns the current <see cref="ILineSegment" /> as simple linear path.</returns>
     public ReadOnlyMemory<PointF> Flatten();
 
+    /// <summary>
+    /// Copies the linearized point data to the destination span.
+    /// </summary>
+    /// <param name="destination">The destination point span.</param>
+    /// <param name="skipFirstPoint">Whether to skip the first emitted point.</param>
+    public void CopyTo(Span<PointF> destination, bool skipFirstPoint);
+
     /// <summary>
     /// Transforms the current LineSegment using specified matrix.
     /// </summary>

src/ImageSharp.Drawing/ILineSegment.cs

@@ -26,6 +26,28 @@ public interface IPath
     /// <returns>Returns the current <see cref="IPath" /> as simple linear path.</returns>
     public IEnumerable<ISimplePath> Flatten();
 
+    /// <summary>
+    /// Converts this path into retained linear geometry for backend consumption.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The returned <see cref="LinearGeometry"/> is the canonical lowered representation for backend scene building.
+    /// It contains the point storage, contour metadata, and derived segment metadata needed to traverse the final
+    /// linearized geometry without repeatedly rediscovering it through <see cref="Flatten()"/>.
+    /// </para>
+    /// <para>
+    /// Closed contours are represented by contour metadata rather than by repeating the first point at the end of the
+    /// stored point run.
+    /// </para>
+    /// <para>
+    /// The returned geometry is expected to preserve the already-sanitized path shape. This method does not introduce
+    /// additional geometric simplification policy beyond the mechanical stitching required by the segment emission
+    /// contract.
+    /// </para>
+    /// </remarks>
+    /// <returns>The retained linear geometry for this path.</returns>
+    public LinearGeometry ToLinearGeometry();
+
     /// <summary>
     /// Transforms the path using the specified matrix.
     /// </summary>