Fixes #4463 - Adds LineCanvas.GetRegion() - 10x performance regression in RenderLineCanvas (#4464)

* Initial plan

* Revert xunit maxParallelThreads to default to fix performance issue

Co-authored-by: tig <[email protected]>

* Fix 10x performance regression in RenderLineCanvas

Found via binary search of 51 commits that commit 0270183 introduced
the slowdown by calling context.AddDrawnRectangle() for every cell in
the LineCanvas (thousands of times per frame).

Fixed by reporting the entire LineCanvas.Bounds once instead of per-cell.

Test results:
- Before: 1m 33s (10x slower than v2_release)
- After: 9s (same as v2_release)

Fixes the performance issue in AllViews_Draw_Does_Not_Layout test.

Co-authored-by: tig <[email protected]>

* Add comment clarifying LineCanvas coordinate system

Addresses code review feedback about coordinate system conversion.
LineCanvas.Bounds is already in screen-relative coordinates since
cells are stored with screen positions (used with Driver.Move).

Co-authored-by: tig <[email protected]>

* Build non-rectangular Region from LineCanvas cells efficiently

Instead of reporting entire LineCanvas.Bounds (which includes empty space),
efficiently build a Region that encompasses only the actual line cells.

Algorithm groups contiguous horizontal cells into spans per row, avoiding
per-cell overhead while accurately representing the non-rectangular shape.

Performance maintained: 10s (same as v2_release)
All tests pass: 5695 drawing tests, 200 LineCanvas tests, 33 transparency tests

Co-authored-by: tig <[email protected]>

* Address code review feedback - improve robustness

- Remove redundant empty check (caller already verifies)
- Add safety check for empty row groups to prevent IndexOutOfRangeException
- Update documentation to clarify precondition

Tests still pass with 9s performance.

Co-authored-by: tig <[email protected]>

* Optimize BuildRegionFromLineCells - eliminate redundant sort

Remove redundant OrderBy since X values are already sorted from the
initial OrderBy().ThenBy() operation. Also remove unreachable empty
check since GroupBy guarantees non-empty groups.

Performance maintained at 9s.

Co-authored-by: tig <[email protected]>

* Final code review fixes - improve comments and add defensive check

- Clarify comment about sorting behavior
- Add defensive empty check for edge cases
- Performance maintained at 10s

Co-authored-by: tig <[email protected]>

* Move BuildRegionFromCells to LineCanvas class

Moved the BuildRegionFromCells method from View.Drawing.cs to LineCanvas
where it logically belongs as a public static method.

Updated View.Drawing.cs to call Drawing.LineCanvas.BuildRegionFromCells.

Performance maintained at 9s. All tests pass.

Co-authored-by: tig <[email protected]>

* Update documentation for BuildRegionFromCells

- Clarify that method handles empty cellMap gracefully
- Improve comment explaining the defensive empty check
- Performance maintained at 10s

Co-authored-by: tig <[email protected]>

* Rename BuildRegionFromCells to GetRegion

Renamed the method as requested to have a more concise name.

Performance maintained at 10s. All tests pass.

Co-authored-by: tig <[email protected]>

* Add GetCellMapWithRegion optimization for single-pass iteration

Implemented optimized method that builds both cell map and Region in a
single pass through the canvas bounds, eliminating the need for separate
GetCellMap() and GetRegion() calls.

Benefits:
- Reduces from 2 iterations to 1 (GetCellMap then GetRegion -> single pass)
- Eliminates sorting overhead (O(n log n) -> O(n))
- X values already sorted due to inner loop order
- Builds Region incrementally per row as cells are discovered

Performance maintained at 10s. All tests pass:
- AllViews_Draw_Does_Not_Layout: 10s
- 5695 drawing tests passed
- 200 LineCanvas tests passed
- 33 transparency tests passed

Co-authored-by: tig <[email protected]>

* Add comprehensive unit tests for GetRegion and GetCellMapWithRegion

Added 15 new unit tests covering:

GetRegion tests:
- Empty cell map handling
- Single cell regions
- Horizontal and vertical lines
- L-shaped regions
- Discontiguous cells creating separate spans
- Intersecting lines

GetCellMapWithRegion tests:
- Empty canvas handling
- Single horizontal/vertical lines
- Intersecting lines with proper intersection handling
- Complex shapes (boxes)
- Consistency with separate GetCellMap + GetRegion calls
- Negative coordinate handling
- Exclusion region support

All 215 LineCanvas tests pass. Performance maintained at 9s.

Co-authored-by: tig <[email protected]>

* Fix code style violations per CONTRIBUTING.md

- Replace var with explicit types (Dictionary<Point, Cell?>, LineCanvas, Region, etc.)
- Replace new TypeName() with target-typed new () where type is declared
- Fix foreach loop to use explicit IGrouping<int, Point> type
- Use StraightLine instead of var in foreach

All style violations fixed per CONTRIBUTING.md coding conventions.
Tests still pass: 215 LineCanvas tests, 9s performance maintained.

Co-authored-by: tig <[email protected]>

* Code cleanup.

* Upgrades Transparent Scenario to demonstrate LineCanvas transparency. "dotnet" is drawn using LineCanvas.

* Comment out debug assertions in View drawing logic

The debug assertions in the `View` class, which validated the relationships between `Margin`, `Border`, `Padding`, and their parent objects, as well as their `SubViewNeedsDraw` and `NeedsDraw` states, have been commented out. These assertions were conditionally executed when the current object and its `SuperView` were not of type `Adornment`.

The code has been retained as comments for potential future reference or debugging purposes, but the assertions are no longer active in the current implementation.

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: tig <[email protected]>
Co-authored-by: Tig <[email protected]>

Author: Copilot

Examples/UICatalog/Scenarios/Transparent.cs

@@ -219,11 +219,102 @@ protected override bool OnDrawingContent (DrawContext? context)
             return false;
         }
 
+        protected override bool OnRenderingLineCanvas ()
+        {
+            // Draw "dotnet" using LineCanvas 
+            Point screenPos = ViewportToScreen (new Point (7, 16));
+            DrawDotnet (LineCanvas, screenPos.X, screenPos.Y, LineStyle.Single, GetAttributeForRole (VisualRole.Normal));
+
+            return false;
+        }
+
         /// <inheritdoc />
         protected override bool OnClearingViewport () { return false; }
 
         /// <inheritdoc />
         protected override bool OnMouseEvent (MouseEventArgs mouseEvent) { return false; }
+
+
+        /// <summary>
+        /// Draws "dotnet" text using LineCanvas. The 'd' is 8 cells high.
+        /// </summary>
+        /// <param name="canvas">The LineCanvas to draw on</param>
+        /// <param name="x">Starting X position</param>
+        /// <param name="y">Starting Y position</param>
+        /// <param name="style">Line style to use</param>
+        /// <param name="attribute">Optional attribute for the lines</param>
+        private void DrawDotnet (LineCanvas canvas, int x, int y, LineStyle style = LineStyle.Single, Attribute? attribute = null)
+        {
+            int currentX = x;
+            int letterHeight = 8;
+            int letterSpacing = 2;
+
+            // Letter 'd' - lowercase, height 8
+            // Vertical stem on right (goes up full 8 cells)
+            canvas.AddLine (new (currentX + 3, y), letterHeight, Orientation.Vertical, style, attribute);
+            // Top horizontal
+            canvas.AddLine (new (currentX, y + 3), 4, Orientation.Horizontal, style, attribute);
+            // Left vertical (only bottom 5 cells, leaving top 3 for ascender space)
+            canvas.AddLine (new (currentX, y + 3), 5, Orientation.Vertical, style, attribute);
+            // Bottom horizontal
+            canvas.AddLine (new (currentX, y + 7), 4, Orientation.Horizontal, style, attribute);
+            currentX += 4 + letterSpacing;
+
+            // Letter 'o' - height 5 (x-height)
+            int oY = y + 3; // Align with x-height (leaving 3 cells for ascenders)
+                            // Top
+            canvas.AddLine (new (currentX, oY), 4, Orientation.Horizontal, style, attribute);
+            // Left
+            canvas.AddLine (new (currentX, oY), 5, Orientation.Vertical, style, attribute);
+            // Right
+            canvas.AddLine (new (currentX + 3, oY), 5, Orientation.Vertical, style, attribute);
+            // Bottom
+            canvas.AddLine (new (currentX, oY + 4), 4, Orientation.Horizontal, style, attribute);
+            currentX += 4 + letterSpacing;
+
+            // Letter 't' - height 7 (has ascender above x-height)
+            int tY = y + 1; // Starts 1 cell above x-height
+                            // Vertical stem
+            canvas.AddLine (new (currentX + 1, tY), 7, Orientation.Vertical, style, attribute);
+            // Top cross bar (at x-height)
+            canvas.AddLine (new (currentX, tY + 2), 3, Orientation.Horizontal, style, attribute);
+            // Bottom horizontal (foot)
+            canvas.AddLine (new (currentX + 1, tY + 6), 2, Orientation.Horizontal, style, attribute);
+            currentX += 3 + letterSpacing;
+
+            // Letter 'n' - height 5 (x-height)
+            int nY = y + 3;
+            // Left vertical
+            canvas.AddLine (new (currentX, nY), 5, Orientation.Vertical, style, attribute);
+            // Top horizontal
+            canvas.AddLine (new (currentX + 1, nY), 3, Orientation.Horizontal, style, attribute);
+            // Right vertical
+            canvas.AddLine (new (currentX + 3, nY), 5, Orientation.Vertical, style, attribute);
+            currentX += 4 + letterSpacing;
+
+            // Letter 'e' - height 5 (x-height)
+            int eY = y + 3;
+            // Top
+            canvas.AddLine (new (currentX, eY), 4, Orientation.Horizontal, style, attribute);
+            // Left
+            canvas.AddLine (new (currentX, eY), 5, Orientation.Vertical, style, attribute);
+            // Right
+            canvas.AddLine (new (currentX + 3, eY), 3, Orientation.Vertical, style, attribute);
+            // Middle horizontal bar
+            canvas.AddLine (new (currentX, eY + 2), 4, Orientation.Horizontal, style, attribute);
+            // Bottom
+            canvas.AddLine (new (currentX, eY + 4), 4, Orientation.Horizontal, style, attribute);
+            currentX += 4 + letterSpacing;
+
+            // Letter 't' - height 7 (has ascender above x-height) - second 't'
+            int t2Y = y + 1;
+            // Vertical stem
+            canvas.AddLine (new (currentX + 1, t2Y), 7, Orientation.Vertical, style, attribute);
+            // Top cross bar (at x-height)
+            canvas.AddLine (new (currentX, t2Y + 2), 3, Orientation.Horizontal, style, attribute);
+            // Bottom horizontal (foot)
+            canvas.AddLine (new (currentX + 1, t2Y + 6), 2, Orientation.Horizontal, style, attribute);
+        }
     }
 
 }

Terminal.Gui/Drawing/LineCanvas/LineCanvas.cs

@@ -179,7 +179,7 @@ public void Clear ()
                     }
                 }
                 // Safe as long as the list is not modified while the span is in use.
-                ReadOnlySpan<IntersectionDefinition> intersects = CollectionsMarshal.AsSpan(intersectionsBufferList);
+                ReadOnlySpan<IntersectionDefinition> intersects = CollectionsMarshal.AsSpan (intersectionsBufferList);
                 Cell? cell = GetCellForIntersects (intersects);
                 // TODO: Can we skip the whole nested looping if _exclusionRegion is null?
                 if (cell is { } && _exclusionRegion?.Contains (x, y) is null or false)
@@ -192,6 +192,136 @@ public void Clear ()
         return map;
     }
 
+    /// <summary>
+    ///     Evaluates the lines and returns both the cell map and a Region encompassing the drawn cells.
+    ///     This is more efficient than calling <see cref="GetCellMap"/> and <see cref="GetRegion"/> separately
+    ///     as it builds both in a single pass through the canvas bounds.
+    /// </summary>
+    /// <returns>A tuple containing the cell map and the Region of drawn cells</returns>
+    public (Dictionary<Point, Cell?> CellMap, Region Region) GetCellMapWithRegion ()
+    {
+        Dictionary<Point, Cell?> map = new ();
+        Region region = new ();
+
+        List<IntersectionDefinition> intersectionsBufferList = [];
+        List<int> rowXValues = [];
+
+        // walk through each pixel of the bitmap, row by row
+        for (int y = Bounds.Y; y < Bounds.Y + Bounds.Height; y++)
+        {
+            rowXValues.Clear ();
+
+            for (int x = Bounds.X; x < Bounds.X + Bounds.Width; x++)
+            {
+                intersectionsBufferList.Clear ();
+                foreach (StraightLine line in _lines)
+                {
+                    if (line.Intersects (x, y) is { } intersect)
+                    {
+                        intersectionsBufferList.Add (intersect);
+                    }
+                }
+                // Safe as long as the list is not modified while the span is in use.
+                ReadOnlySpan<IntersectionDefinition> intersects = CollectionsMarshal.AsSpan (intersectionsBufferList);
+                Cell? cell = GetCellForIntersects (intersects);
+
+                if (cell is { } && _exclusionRegion?.Contains (x, y) is null or false)
+                {
+                    map.Add (new (x, y), cell);
+                    rowXValues.Add (x);
+                }
+            }
+
+            // Build Region spans for this completed row
+            if (rowXValues.Count <= 0)
+            {
+                continue;
+            }
+
+            // X values are already sorted (inner loop iterates x in order)
+            int spanStart = rowXValues [0];
+            int spanEnd = rowXValues [0];
+
+            for (int i = 1; i < rowXValues.Count; i++)
+            {
+                if (rowXValues [i] == spanEnd + 1)
+                {
+                    // Continue the span
+                    spanEnd = rowXValues [i];
+                }
+                else
+                {
+                    // End the current span and add it to the region
+                    region.Combine (new Rectangle (spanStart, y, spanEnd - spanStart + 1, 1), RegionOp.Union);
+                    spanStart = rowXValues [i];
+                    spanEnd = rowXValues [i];
+                }
+            }
+
+            // Add the final span for this row
+            region.Combine (new Rectangle (spanStart, y, spanEnd - spanStart + 1, 1), RegionOp.Union);
+        }
+
+        return (map, region);
+    }
+
+    /// <summary>
+    ///     Efficiently builds a <see cref="Region"/> from line cells by grouping contiguous horizontal spans.
+    ///     This avoids the performance overhead of adding each cell individually while accurately
+    ///     representing the non-rectangular shape of the lines.
+    /// </summary>
+    /// <param name="cellMap">Dictionary of points where line cells are drawn. If empty, returns an empty Region.</param>
+    /// <returns>A Region encompassing all the line cells, or an empty Region if cellMap is empty</returns>
+    public static Region GetRegion (Dictionary<Point, Cell?> cellMap)
+    {
+        // Group cells by row for efficient horizontal span detection
+        // Sort by Y then X so that within each row group, X values are in order
+        IEnumerable<IGrouping<int, Point>> rowGroups = cellMap.Keys
+                                                              .OrderBy (p => p.Y)
+                                                              .ThenBy (p => p.X)
+                                                              .GroupBy (p => p.Y);
+
+        Region region = new ();
+
+        foreach (IGrouping<int, Point> row in rowGroups)
+        {
+            int y = row.Key;
+            // X values are sorted due to ThenBy above
+            List<int> xValues = row.Select (p => p.X).ToList ();
+
+            // Note: GroupBy on non-empty Keys guarantees non-empty groups, but check anyway for safety
+            if (xValues.Count == 0)
+            {
+                continue;
+            }
+
+            // Merge contiguous x values into horizontal spans
+            int spanStart = xValues [0];
+            int spanEnd = xValues [0];
+
+            for (int i = 1; i < xValues.Count; i++)
+            {
+                if (xValues [i] == spanEnd + 1)
+                {
+                    // Continue the span
+                    spanEnd = xValues [i];
+                }
+                else
+                {
+                    // End the current span and add it to the region
+                    region.Combine (new Rectangle (spanStart, y, spanEnd - spanStart + 1, 1), RegionOp.Union);
+                    spanStart = xValues [i];
+                    spanEnd = xValues [i];
+                }
+            }
+
+            // Add the final span for this row
+            region.Combine (new Rectangle (spanStart, y, spanEnd - spanStart + 1, 1), RegionOp.Union);
+        }
+
+        return region;
+    }
+
     // TODO: Unless there's an obvious use case for this API we should delete it in favor of the
     // simpler version that doesn't take an area.
     /// <summary>
@@ -227,7 +357,7 @@ public Dictionary<Point, Rune> GetMap (Rectangle inArea)
                     }
                 }
                 // Safe as long as the list is not modified while the span is in use.
-                ReadOnlySpan<IntersectionDefinition> intersects = CollectionsMarshal.AsSpan(intersectionsBufferList);
+                ReadOnlySpan<IntersectionDefinition> intersects = CollectionsMarshal.AsSpan (intersectionsBufferList);
 
                 Rune? rune = GetRuneForIntersects (intersects);
 
@@ -442,14 +572,14 @@ private void ConfigurationManager_Applied (object? sender, ConfigurationManagerE
         }
 
         // TODO: Remove these once we have all of the below ported to IntersectionRuneResolvers
-        bool useDouble = AnyLineStyles(intersects, [LineStyle.Double]);
-        bool useDashed = AnyLineStyles(intersects, [LineStyle.Dashed, LineStyle.RoundedDashed]);
-        bool useDotted = AnyLineStyles(intersects, [LineStyle.Dotted, LineStyle.RoundedDotted]);
+        bool useDouble = AnyLineStyles (intersects, [LineStyle.Double]);
+        bool useDashed = AnyLineStyles (intersects, [LineStyle.Dashed, LineStyle.RoundedDashed]);
+        bool useDotted = AnyLineStyles (intersects, [LineStyle.Dotted, LineStyle.RoundedDotted]);
 
         // horiz and vert lines same as Single for Rounded
-        bool useThick = AnyLineStyles(intersects, [LineStyle.Heavy]);
-        bool useThickDashed = AnyLineStyles(intersects, [LineStyle.HeavyDashed]);
-        bool useThickDotted = AnyLineStyles(intersects, [LineStyle.HeavyDotted]);
+        bool useThick = AnyLineStyles (intersects, [LineStyle.Heavy]);
+        bool useThickDashed = AnyLineStyles (intersects, [LineStyle.HeavyDashed]);
+        bool useThickDotted = AnyLineStyles (intersects, [LineStyle.HeavyDotted]);
 
         // TODO: Support ruler
         //var useRuler = intersects.Any (i => i.Line.Style == LineStyle.Ruler && i.Line.Length != 0);
@@ -727,10 +857,10 @@ private bool Has (HashSet<IntersectionType> intersects, ReadOnlySpan<Intersectio
     private static class CornerIntersections
     {
         // Names matching #region "Corner Conditions" IntersectionRuneType
-        internal static readonly IntersectionType[] UpperLeft = [IntersectionType.StartRight, IntersectionType.StartDown];
-        internal static readonly IntersectionType[] UpperRight = [IntersectionType.StartLeft, IntersectionType.StartDown];
-        internal static readonly IntersectionType[] LowerRight = [IntersectionType.StartUp, IntersectionType.StartLeft];
-        internal static readonly IntersectionType[] LowerLeft = [IntersectionType.StartUp, IntersectionType.StartRight];
+        internal static readonly IntersectionType [] UpperLeft = [IntersectionType.StartRight, IntersectionType.StartDown];
+        internal static readonly IntersectionType [] UpperRight = [IntersectionType.StartLeft, IntersectionType.StartDown];
+        internal static readonly IntersectionType [] LowerRight = [IntersectionType.StartUp, IntersectionType.StartLeft];
+        internal static readonly IntersectionType [] LowerLeft = [IntersectionType.StartUp, IntersectionType.StartRight];
     }
 
     private class BottomTeeIntersectionRuneResolver : IntersectionRuneResolver
@@ -773,14 +903,18 @@ private abstract class IntersectionRuneResolver
         internal Rune _thickBoth;
         internal Rune _thickH;
         internal Rune _thickV;
-        protected IntersectionRuneResolver () { SetGlyphs (); }
+
+        protected IntersectionRuneResolver ()
+        {
+            SetGlyphs ();
+        }
 
         public Rune? GetRuneForIntersects (ReadOnlySpan<IntersectionDefinition> intersects)
         {
             // Note that there aren't any glyphs for intersections of double lines with heavy lines
 
-            bool doubleHorizontal = AnyWithOrientationAndAnyLineStyle(intersects, Orientation.Horizontal, [LineStyle.Double]);
-            bool doubleVertical = AnyWithOrientationAndAnyLineStyle(intersects, Orientation.Vertical, [LineStyle.Double]);
+            bool doubleHorizontal = AnyWithOrientationAndAnyLineStyle (intersects, Orientation.Horizontal, [LineStyle.Double]);
+            bool doubleVertical = AnyWithOrientationAndAnyLineStyle (intersects, Orientation.Vertical, [LineStyle.Double]);
 
             if (doubleHorizontal)
             {
@@ -792,9 +926,9 @@ private abstract class IntersectionRuneResolver
                 return _doubleV;
             }
 
-            bool thickHorizontal = AnyWithOrientationAndAnyLineStyle(intersects, Orientation.Horizontal,
+            bool thickHorizontal = AnyWithOrientationAndAnyLineStyle (intersects, Orientation.Horizontal,
                 [LineStyle.Heavy, LineStyle.HeavyDashed, LineStyle.HeavyDotted]);
-            bool thickVertical = AnyWithOrientationAndAnyLineStyle(intersects, Orientation.Vertical,
+            bool thickVertical = AnyWithOrientationAndAnyLineStyle (intersects, Orientation.Vertical,
                 [LineStyle.Heavy, LineStyle.HeavyDashed, LineStyle.HeavyDotted]);
 
             if (thickHorizontal)