From 3d9e1e6dd1f8b67e1e0ff495964c8ae9d67b9eab Mon Sep 17 00:00:00 2001
From: RitaCh <ritach@uw.edu>
Date: Tue, 28 Jul 2026 16:04:16 -0700
Subject: [PATCH 1/3] Fixed sparse and marker-overlapping labels on Volcano and
 Relative Abundance plots

* Changed the label sampler cap from a product to a min so the two density caps act as hard limits instead of compounding
* Added a post-annealer pass that hides labels overlapping a kept label or covering another point's marker
* Fixed hit-testing to skip invisible labels so hidden labels no longer block mouse-over on visible ones

See ai/todos/active/TODO-20260521_labelSamplingFix.md

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../Shared/zedgraph/ZedGraph/GraphObjList.cs  |   6 +-
 .../Shared/zedgraph/ZedGraph/LabelLayout.cs   | 236 ++++++++++++++++--
 .../Controls/Graphs/LabelLayoutRunner.cs      |   8 +-
 .../Skyline/TestFunctional/LabelLayoutTest.cs |   6 +-
 4 files changed, 234 insertions(+), 22 deletions(-)

diff --git a/pwiz_tools/Shared/zedgraph/ZedGraph/GraphObjList.cs b/pwiz_tools/Shared/zedgraph/ZedGraph/GraphObjList.cs
index dcf99190aa4..8d6550be303 100644
--- a/pwiz_tools/Shared/zedgraph/ZedGraph/GraphObjList.cs
+++ b/pwiz_tools/Shared/zedgraph/ZedGraph/GraphObjList.cs
@@ -1,6 +1,6 @@
 //============================================================================
 //ZedGraph Class Library - A Flexible Line Graph/Bar Graph Library in C#
-//Copyright © 2004  John Champion
+//Copyright � 2004  John Champion
 //
 //This library is free software; you can redistribute it and/or
 //modify it under the terms of the GNU Lesser General Public
@@ -289,7 +289,9 @@ public bool FindPoint( PointF mousePt, PaneBase pane, Graphics g, float scaleFac
             // the same ZOrder value.
 			for ( int i=0; i<Count; i++ )
 			{
-				if ( this[i].PointInBox( mousePt, pane, g, scaleFactor ) )
+				// Skip hidden objects so an invisible object (e.g. a sampled-out or pruned
+				// label left in the list) cannot screen a visible one during hit-testing.
+				if ( this[i].IsVisible && this[i].PointInBox( mousePt, pane, g, scaleFactor ) )
 				{
 					if ( ( index >= 0 && this[i].ZOrder > this[index].ZOrder ) || index < 0 )
 						index = i;
diff --git a/pwiz_tools/Shared/zedgraph/ZedGraph/LabelLayout.cs b/pwiz_tools/Shared/zedgraph/ZedGraph/LabelLayout.cs
index 1b52108b0bd..9b4dd6449b4 100644
--- a/pwiz_tools/Shared/zedgraph/ZedGraph/LabelLayout.cs
+++ b/pwiz_tools/Shared/zedgraph/ZedGraph/LabelLayout.cs
@@ -115,6 +115,26 @@ private void FillDensityGrid()
                 }
             }
 
+            foreach (var markerRect in EnumerateMarkerRectangles())
+            {
+                foreach (var cell in GetRectangleCells(markerRect))
+                {
+                    var intersect = RectangleF.Intersect(markerRect, cell.Bounds);
+                    if (intersect != RectangleF.Empty)
+                    {
+                        cell.Density += intersect.Height * intersect.Width;
+                        cell.PointCount++;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Enumerates the screen-pixel rectangles of every visible point marker on the graph.
+        /// Shared by the density grid and the overlap pruner.
+        /// </summary>
+        private IEnumerable<RectangleF> EnumerateMarkerRectangles()
+        {
             foreach (var line in GetMarkerLinesSnapshot())
             {
                 int pointCount;
@@ -129,26 +149,14 @@ private void FillDensityGrid()
 
                 for (var i = 0; i < pointCount; i++)
                 {
+                    RectangleF markerRect;
                     try
                     {
-                        if (!line.GetCoords(this._graph, i, out var coords))
-                        {
+                        if (!line.GetCoords(_graph, i, out var coords))
                             continue;
-                        }
 
                         var sides = Array.ConvertAll(coords.Split(','), int.Parse);
-                        var markerRect = new Rectangle(sides[0], sides[1], sides[2] - sides[0],
-                            sides[3] - sides[1]);
-
-                        foreach (var cell in GetRectangleCells(markerRect))
-                        {
-                            var intersect = RectangleF.Intersect(markerRect, cell.Bounds);
-                            if (intersect != Rectangle.Empty)
-                            {
-                                cell.Density += intersect.Height * intersect.Width;
-                                cell.PointCount++;
-                            }
-                        }
+                        markerRect = new RectangleF(sides[0], sides[1], sides[2] - sides[0], sides[3] - sides[1]);
                     }
                     catch (InvalidOperationException)
                     {
@@ -158,6 +166,7 @@ private void FillDensityGrid()
                     {
                         break;
                     }
+                    yield return markerRect;
                 }
             }
         }
@@ -707,6 +716,203 @@ public bool ApplyPlacements(LayoutResult result, Graphics g)
             return true;
         }
 
+        /// <summary>
+        /// Removes labels whose final (post-annealing) rectangles either overlap another kept
+        /// label or sit squarely on top of a foreign data point (cover its marker center). The
+        /// pre-annealing sampler targets a label density the annealer can usually satisfy, but on
+        /// very dense plots some labels still land on top of each other or on markers. This second
+        /// pass enforces those invariants on the actual placed rectangles. Selected labels are
+        /// always kept. The processing order is deterministic (selected first, then by a stable
+        /// hash of the label text) so repeated layouts of the same data prune the same labels.
+        /// Pruned labels are hidden, their connectors removed, and they are dropped from the
+        /// layout so they are not persisted.
+        /// </summary>
+        public void PruneOverlappingLabels(Graphics g)
+        {
+            if (_labeledPoints.Count == 0)
+                return;
+
+            var entries = new List<LabelRect>();
+            foreach (var labeledPoint in _labeledPoints.Values)
+            {
+                var rect = _graph.GetRectScreen(labeledPoint.Label, g);
+                if (rect.Width <= 0 || rect.Height <= 0)
+                    continue;
+                entries.Add(new LabelRect(labeledPoint, rect));
+            }
+            if (entries.Count == 0)
+                return;
+
+            // Selected labels first (never pruned), then a stable hash of the label text so the
+            // survivors do not depend on alphabetical ordering and two runs over the same data agree.
+            entries.Sort((a, b) =>
+            {
+                if (a.Point.IsSelected != b.Point.IsSelected)
+                    return a.Point.IsSelected ? -1 : 1;
+                var hashCompare = a.Hash.CompareTo(b.Hash);
+                if (hashCompare != 0)
+                    return hashCompare;
+                return string.CompareOrdinal(a.Text, b.Text);
+            });
+
+            var bucketSize = 1;
+            foreach (var entry in entries)
+                bucketSize = Math.Max(bucketSize, (int)Math.Ceiling(Math.Max(entry.Rect.Width, entry.Rect.Height)));
+
+            // Spatial hash of point-marker centers so a label that sits squarely on top of a data
+            // point (covers its center) can be pruned. A label is allowed to overlap the marker of
+            // its own point - the connector already ties them together - so that one is excluded per
+            // candidate below.
+            var markerCentersByBucket = new Dictionary<long, List<PointF>>();
+            foreach (var markerRect in EnumerateMarkerRectangles())
+            {
+                if (markerRect.Width <= 0 || markerRect.Height <= 0)
+                    continue;
+                var center = new PointF(markerRect.X + markerRect.Width / 2f, markerRect.Y + markerRect.Height / 2f);
+                var key = BucketKey(center, bucketSize);
+                if (!markerCentersByBucket.TryGetValue(key, out var centers))
+                {
+                    centers = new List<PointF>();
+                    markerCentersByBucket[key] = centers;
+                }
+                centers.Add(center);
+            }
+
+            var keptByBucket = new Dictionary<long, List<RectangleF>>();
+            var pruned = new List<LabeledPoint>();
+            foreach (var entry in entries)
+            {
+                if (!entry.Point.IsSelected &&
+                    (OverlapsKept(entry.Rect, bucketSize, keptByBucket) ||
+                     CoversForeignMarker(entry, bucketSize, markerCentersByBucket)))
+                {
+                    pruned.Add(entry.Point);
+                    continue;
+                }
+                AddToBuckets(entry.Rect, bucketSize, keptByBucket);
+            }
+
+            foreach (var point in pruned)
+            {
+                point.Label.IsVisible = false;
+                if (point.Connector != null)
+                    _graph.GraphObjList.Remove(point.Connector);
+                _labeledPoints.Remove(point.Label);
+            }
+        }
+
+        // Distance (squared, in pixels) within which a marker center is treated as a label's own
+        // point rather than a foreign one it is sitting on top of.
+        private const float OWN_MARKER_TOLERANCE_SQ = 4f;
+
+        /// <summary>
+        /// Returns true if the label rectangle covers the center of any point marker other than the
+        /// marker of the label's own point.
+        /// </summary>
+        private bool CoversForeignMarker(LabelRect entry, int bucketSize, Dictionary<long, List<PointF>> markerCentersByBucket)
+        {
+            var ownCenter = _graph.TransformCoord(entry.Point.Point.X, entry.Point.Point.Y, CoordType.AxisXYScale);
+            foreach (var bucket in BucketKeys(entry.Rect, bucketSize))
+            {
+                if (!markerCentersByBucket.TryGetValue(bucket, out var centers))
+                    continue;
+                foreach (var center in centers)
+                {
+                    if (!entry.Rect.Contains(center))
+                        continue;
+                    var dx = center.X - ownCenter.X;
+                    var dy = center.Y - ownCenter.Y;
+                    if (dx * dx + dy * dy <= OWN_MARKER_TOLERANCE_SQ)
+                        continue;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private static long BucketKey(PointF pt, int bucketSize)
+        {
+            var bx = (int)Math.Floor(pt.X / bucketSize);
+            var by = (int)Math.Floor(pt.Y / bucketSize);
+            return ((long)bx << 32) ^ (uint)by;
+        }
+
+        private static bool OverlapsKept(RectangleF rect, int bucketSize, Dictionary<long, List<RectangleF>> keptByBucket)
+        {
+            foreach (var bucket in BucketKeys(rect, bucketSize))
+            {
+                if (!keptByBucket.TryGetValue(bucket, out var rects))
+                    continue;
+                foreach (var kept in rects)
+                {
+                    if (kept.IntersectsWith(rect))
+                        return true;
+                }
+            }
+            return false;
+        }
+
+        private static void AddToBuckets(RectangleF rect, int bucketSize, Dictionary<long, List<RectangleF>> keptByBucket)
+        {
+            foreach (var bucket in BucketKeys(rect, bucketSize))
+            {
+                if (!keptByBucket.TryGetValue(bucket, out var rects))
+                {
+                    rects = new List<RectangleF>();
+                    keptByBucket[bucket] = rects;
+                }
+                rects.Add(rect);
+            }
+        }
+
+        private static IEnumerable<long> BucketKeys(RectangleF rect, int bucketSize)
+        {
+            var minX = (int)Math.Floor(rect.Left / bucketSize);
+            var maxX = (int)Math.Floor(rect.Right / bucketSize);
+            var minY = (int)Math.Floor(rect.Top / bucketSize);
+            var maxY = (int)Math.Floor(rect.Bottom / bucketSize);
+            for (var bx = minX; bx <= maxX; bx++)
+            {
+                for (var by = minY; by <= maxY; by++)
+                    yield return ((long)bx << 32) ^ (uint)by;
+            }
+        }
+
+        private static uint StableTextHash(string text)
+        {
+            unchecked
+            {
+                const uint fnvOffset = 2166136261;
+                const uint fnvPrime = 16777619;
+                var hash = fnvOffset;
+                if (!string.IsNullOrEmpty(text))
+                {
+                    foreach (var ch in text)
+                    {
+                        hash ^= ch;
+                        hash *= fnvPrime;
+                    }
+                }
+                return hash;
+            }
+        }
+
+        private readonly struct LabelRect
+        {
+            public LabelRect(LabeledPoint point, RectangleF rect)
+            {
+                Point = point;
+                Rect = rect;
+                Text = point.Label?.Text ?? string.Empty;
+                Hash = StableTextHash(Text);
+            }
+
+            public LabeledPoint Point { get; }
+            public RectangleF Rect { get; }
+            public string Text { get; }
+            public uint Hash { get; }
+        }
+
         /// <summary>
         /// Calculates the total goal function for the current layout (all labels).
         /// </summary>
diff --git a/pwiz_tools/Skyline/Controls/Graphs/LabelLayoutRunner.cs b/pwiz_tools/Skyline/Controls/Graphs/LabelLayoutRunner.cs
index bff759f671d..8524faca9bf 100644
--- a/pwiz_tools/Skyline/Controls/Graphs/LabelLayoutRunner.cs
+++ b/pwiz_tools/Skyline/Controls/Graphs/LabelLayoutRunner.cs
@@ -35,7 +35,7 @@ internal sealed class LabelLayoutRunner
         private const int LABEL_LAYOUT_PROGRESS_INTERVAL_MS = 200;
         private const int LABEL_LAYOUT_DEBOUNCE_MS = 100;
         private const double MAX_LABELS_PER_CELL = 4.0;
-        private const double MAX_LABEL_AREA_RATIO = 0.5;
+        private const double MAX_LABEL_AREA_RATIO = 0.3;
 
         private Thread _labelLayoutWorkerThread;
         private CancellationTokenSource _labelLayoutCts;
@@ -173,7 +173,7 @@ private static List<LabeledPoint> SamplePointsByDensityGrid(LabelLayout labelLay
                 var cellPointCount = labelLayout.CellFromPoint(cellEntry.Item2).PointCount;
                 var cutoff = cellPointCount > MAX_LABELS_PER_CELL ? MAX_LABELS_PER_CELL / cellPointCount : 1.0;
 
-                if (cellEntry.Item1.Point.IsSelected || (double)cellEntry.Item1.Hash / maxHash <= (cutoff * areaSamplingRate))
+                if (cellEntry.Item1.Point.IsSelected || (double)cellEntry.Item1.Hash / maxHash <= Math.Min(cutoff, areaSamplingRate))
                 {
                     keep.Add(cellEntry.Item1.Point);
                 }
@@ -455,6 +455,10 @@ private void StartDebounced(LabelLayoutRequest request)
                                 {
                                     if (pane.ApplyLabelLayout(workerResult.LabelLayout, workerResult.Result, g))
                                     {
+                                        // Remove any labels the annealer could not separate. The sampler
+                                        // targets a workable density, but the densest plots still leave
+                                        // overlaps that only show up in the final placed positions.
+                                        workerResult.LabelLayout.PruneOverlappingLabels(g);
                                         saveLayout?.Invoke(pane.Layout?.PointsLayout);
                                         invalidate?.Invoke();
                                     }
diff --git a/pwiz_tools/Skyline/TestFunctional/LabelLayoutTest.cs b/pwiz_tools/Skyline/TestFunctional/LabelLayoutTest.cs
index aef305f387b..51cb4504447 100644
--- a/pwiz_tools/Skyline/TestFunctional/LabelLayoutTest.cs
+++ b/pwiz_tools/Skyline/TestFunctional/LabelLayoutTest.cs
@@ -35,14 +35,14 @@ namespace pwiz.SkylineTestFunctional
     public class LabelLayoutTest : AbstractFunctionalTestEx
     {
         private const float LABEL_TOLERANCE_PX = 2f;
-        private const int EXPECTED_POINT_COUNT = 14;
+        private const int EXPECTED_POINT_COUNT = 13;
         private static readonly ExpectedPointSnapshot[] EXPECTED_RANDOM_POINTS =
         {
             new ExpectedPointSnapshot(1, "EENGDFASFR", 55f, 545123.8f),
             new ExpectedPointSnapshot(4, "HEEEVERPAVEK", 86f, 191400.8f),
             new ExpectedPointSnapshot(7, "MLSGFIPLKPTVK", 98f, 138878.5f),
-            new ExpectedPointSnapshot(10, "TSDQIHFFFAK", 113f, 79212.3f),
-            new ExpectedPointSnapshot(13, "WTNPDGTTSK", 84f, 199644.5f),
+            new ExpectedPointSnapshot(9, "TSDQIHFFFAK", 113f, 79212.3f),
+            new ExpectedPointSnapshot(12, "WTNPDGTTSK", 84f, 199644.5f),
         };
 
         [TestMethod]

From 57bb5726948b4866b1a5f4f58aac41045f5676d1 Mon Sep 17 00:00:00 2001
From: RitaCh <ritach@uw.edu>
Date: Tue, 28 Jul 2026 16:46:24 -0700
Subject: [PATCH 2/3] Addressed self-review: deterministic prune tiebreak for
 duplicate label text

* Added a stable UniqueID-based final tiebreaker so points sharing the same label text prune in a deterministic order (List.Sort is not stable)
* Documented the Linear-axis assumption in the own-marker exclusion

See ai/todos/active/TODO-20260521_labelSamplingFix.md

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../Shared/zedgraph/ZedGraph/LabelLayout.cs       | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/pwiz_tools/Shared/zedgraph/ZedGraph/LabelLayout.cs b/pwiz_tools/Shared/zedgraph/ZedGraph/LabelLayout.cs
index 9b4dd6449b4..dc56a6f41f9 100644
--- a/pwiz_tools/Shared/zedgraph/ZedGraph/LabelLayout.cs
+++ b/pwiz_tools/Shared/zedgraph/ZedGraph/LabelLayout.cs
@@ -745,6 +745,8 @@ public void PruneOverlappingLabels(Graphics g)
 
             // Selected labels first (never pruned), then a stable hash of the label text so the
             // survivors do not depend on alphabetical ordering and two runs over the same data agree.
+            // The final tiebreaker on a position-independent identity keeps the order deterministic
+            // even when two points share the same label text (List.Sort is not a stable sort).
             entries.Sort((a, b) =>
             {
                 if (a.Point.IsSelected != b.Point.IsSelected)
@@ -752,7 +754,10 @@ public void PruneOverlappingLabels(Graphics g)
                 var hashCompare = a.Hash.CompareTo(b.Hash);
                 if (hashCompare != 0)
                     return hashCompare;
-                return string.CompareOrdinal(a.Text, b.Text);
+                var textCompare = string.CompareOrdinal(a.Text, b.Text);
+                if (textCompare != 0)
+                    return textCompare;
+                return string.CompareOrdinal(a.TieBreak, b.TieBreak);
             });
 
             var bucketSize = 1;
@@ -811,6 +816,10 @@ public void PruneOverlappingLabels(Graphics g)
         /// </summary>
         private bool CoversForeignMarker(LabelRect entry, int bucketSize, Dictionary<long, List<PointF>> markerCentersByBucket)
         {
+            // Own-marker exclusion assumes a non-ordinal (Linear) X axis: ownCenter is transformed
+            // from the data value while the marker centers come from LineItem.GetCoords, which uses
+            // the ordinal index on Text/ordinal axes. Both plots that use this layout (volcano and
+            // relative abundance) have Linear X axes, so the two agree to sub-pixel precision.
             var ownCenter = _graph.TransformCoord(entry.Point.Point.X, entry.Point.Point.Y, CoordType.AxisXYScale);
             foreach (var bucket in BucketKeys(entry.Rect, bucketSize))
             {
@@ -905,12 +914,16 @@ public LabelRect(LabeledPoint point, RectangleF rect)
                 Rect = rect;
                 Text = point.Label?.Text ?? string.Empty;
                 Hash = StableTextHash(Text);
+                // Stable, position-independent identity used as the final sort tiebreaker so
+                // that points sharing the same label text still prune in a deterministic order.
+                TieBreak = point.UniqueID?.ToString() ?? string.Empty;
             }
 
             public LabeledPoint Point { get; }
             public RectangleF Rect { get; }
             public string Text { get; }
             public uint Hash { get; }
+            public string TieBreak { get; }
         }
 
         /// <summary>

From 2bc19d22f6f9155570e2a11dd761f3e0e504f134 Mon Sep 17 00:00:00 2001
From: RitaCh <ritach@uw.edu>
Date: Sun, 16 Aug 2026 20:43:06 -0700
Subject: [PATCH 3/3] Addressed review feedback on PR #4495

* Gated LabelLayoutTest pinned snapshot on English; localized fonts change chart geometry and the kept label set
* Added culture-independent invariant checks mirroring the pruner (selected labels exempt)
* Cleared static saved layout per capture so batch language passes stay deterministic
* Snapshot marker geometry on the UI thread in LabelLayout; removed collection-race exception catches

See ai/todos/active/TODO-20260521_labelSamplingFix.md

Co-Authored-By: Claude <noreply@anthropic.com>
---
 .../Shared/zedgraph/ZedGraph/LabelLayout.cs   | 139 +++++++-----------
 .../Controls/Graphs/LabelLayoutRunner.cs      |   6 +-
 .../Skyline/TestFunctional/LabelLayoutTest.cs |  98 +++++++++++-
 3 files changed, 151 insertions(+), 92 deletions(-)

diff --git a/pwiz_tools/Shared/zedgraph/ZedGraph/LabelLayout.cs b/pwiz_tools/Shared/zedgraph/ZedGraph/LabelLayout.cs
index dc56a6f41f9..46f84dd0018 100644
--- a/pwiz_tools/Shared/zedgraph/ZedGraph/LabelLayout.cs
+++ b/pwiz_tools/Shared/zedgraph/ZedGraph/LabelLayout.cs
@@ -47,12 +47,20 @@
 
 namespace ZedGraph
 {
+    /// <summary>
+    /// Computes label placements for a graph pane. The constructor must be called on the UI
+    /// thread: it captures an immutable snapshot of the point-marker geometry from the live
+    /// curve list. All subsequent layout work, including <see cref="ComputePlacementsSimulatedAnnealing"/>
+    /// running on a background thread, reads only that snapshot, so it is never affected by
+    /// the UI thread modifying the graph's curves while the layout is being computed.
+    /// </summary>
     public class LabelLayout
     {
         private GraphPane _graph;
         private int _cellSize;
         private Random _randGenerator = new Random(123);
         private PointF _chartOffset;
+        private readonly MarkerInfo[] _markers;
         private Dictionary<TextObj, LabeledPoint> _labeledPoints = new Dictionary<TextObj, LabeledPoint>();
         private const float CROSSOVER_PENALTY = 5000f;
         private const float LABEL_OVERLAP_PENALTY = 5000f;
@@ -80,6 +88,7 @@ public LabelLayout(GraphPane graph, int cellSize)
             _cellSize = cellSize;
             var chartRect = _graph.Chart.Rect;
             _chartOffset = new PointF(chartRect.Location.X, chartRect.Location.Y);
+            _markers = SnapshotMarkers();
             FillDensityGrid();
         }
 
@@ -130,112 +139,48 @@ private void FillDensityGrid()
         }
 
         /// <summary>
-        /// Enumerates the screen-pixel rectangles of every visible point marker on the graph.
-        /// Shared by the density grid and the overlap pruner.
+        /// Captures the screen-pixel rectangle and center of every visible point marker on the
+        /// graph. Called once from the constructor, on the UI thread, because it iterates the
+        /// live curve list; everything else reads the returned immutable snapshot.
         /// </summary>
-        private IEnumerable<RectangleF> EnumerateMarkerRectangles()
+        private MarkerInfo[] SnapshotMarkers()
         {
-            foreach (var line in GetMarkerLinesSnapshot())
+            var markers = new List<MarkerInfo>();
+            foreach (var line in _graph.CurveList.OfType<LineItem>().Where(c => c.Symbol.Type != SymbolType.None))
             {
-                int pointCount;
-                try
-                {
-                    pointCount = line.Points.Count;
-                }
-                catch (InvalidOperationException)
+                for (var i = 0; i < line.Points.Count; i++)
                 {
-                    continue;
-                }
-
-                for (var i = 0; i < pointCount; i++)
-                {
-                    RectangleF markerRect;
-                    try
-                    {
-                        if (!line.GetCoords(_graph, i, out var coords))
-                            continue;
+                    if (!line.GetCoords(_graph, i, out var coords))
+                        continue;
 
-                        var sides = Array.ConvertAll(coords.Split(','), int.Parse);
-                        markerRect = new RectangleF(sides[0], sides[1], sides[2] - sides[0], sides[3] - sides[1]);
-                    }
-                    catch (InvalidOperationException)
-                    {
-                        break;
-                    }
-                    catch (ArgumentOutOfRangeException)
-                    {
-                        break;
-                    }
-                    yield return markerRect;
+                    var sides = Array.ConvertAll(coords.Split(','), int.Parse);
+                    var rect = new RectangleF(sides[0], sides[1], sides[2] - sides[0], sides[3] - sides[1]);
+                    var point = line.Points[i];
+                    var center = _graph.TransformCoord(point.X, point.Y, CoordType.AxisXYScale);
+                    markers.Add(new MarkerInfo(center, rect));
                 }
             }
+            return markers.ToArray();
         }
 
-        private LineItem[] GetMarkerLinesSnapshot()
+        /// <summary>
+        /// Enumerates the marker rectangles captured at construction.
+        /// Shared by the density grid and the overlap pruner.
+        /// </summary>
+        private IEnumerable<RectangleF> EnumerateMarkerRectangles()
         {
-            try
-            {
-                return _graph.CurveList.OfType<LineItem>().Where(c => c.Symbol.Type != SymbolType.None).ToArray();
-            }
-            catch (InvalidOperationException)
-            {
-                return Array.Empty<LineItem>();
-            }
+            return _markers.Select(m => m.Rect);
         }
 
         private void GetPointMarkerRectangle(PointF pt, out RectangleF rect)
         {
             rect = RectangleF.Empty;
-            foreach (var line in GetMarkerLinesSnapshot())
+            foreach (var marker in _markers)
             {
-                int pointCount;
-                try
+                if (Math.Abs(marker.Center.X - pt.X) < 1 && Math.Abs(marker.Center.Y - pt.Y) < 1)
                 {
-                    pointCount = line.Points.Count;
-                }
-                catch (InvalidOperationException)
-                {
-                    continue;
-                }
-
-                for (var i = 0; i < pointCount; i++)
-                {
-                    PointF screenPt;
-                    try
-                    {
-                        var point = line.Points[i];
-                        screenPt = _graph.TransformCoord(point.X, point.Y, CoordType.AxisXYScale);
-                    }
-                    catch (InvalidOperationException)
-                    {
-                        break;
-                    }
-                    catch (ArgumentOutOfRangeException)
-                    {
-                        break;
-                    }
-
-                    if (Math.Abs(screenPt.X - pt.X) < 1 && Math.Abs(screenPt.Y - pt.Y) < 1 )
-                    {
-                        try
-                        {
-                            if (!line.GetCoords(this._graph, i, out var coords))
-                            {
-                                continue;
-                            }
-                            var sides = Array.ConvertAll(coords.Split(','), int.Parse);
-                            rect = new Rectangle(sides[0], sides[1], sides[2] - sides[0], sides[3] - sides[1]);
-                            return;
-                        }
-                        catch (InvalidOperationException)
-                        {
-                            break;
-                        }
-                        catch (ArgumentOutOfRangeException)
-                        {
-                            break;
-                        }
-                    }
+                    rect = marker.Rect;
+                    return;
                 }
             }
         }
@@ -906,6 +851,22 @@ private static uint StableTextHash(string text)
             }
         }
 
+        /// <summary>
+        /// Immutable snapshot of a single point marker: its screen rectangle (as reported by
+        /// <see cref="LineItem.GetCoords"/>) and the transformed center of the data point.
+        /// </summary>
+        private readonly struct MarkerInfo
+        {
+            public MarkerInfo(PointF center, RectangleF rect)
+            {
+                Center = center;
+                Rect = rect;
+            }
+
+            public PointF Center { get; }
+            public RectangleF Rect { get; }
+        }
+
         private readonly struct LabelRect
         {
             public LabelRect(LabeledPoint point, RectangleF rect)
diff --git a/pwiz_tools/Skyline/Controls/Graphs/LabelLayoutRunner.cs b/pwiz_tools/Skyline/Controls/Graphs/LabelLayoutRunner.cs
index 8524faca9bf..42db11069e6 100644
--- a/pwiz_tools/Skyline/Controls/Graphs/LabelLayoutRunner.cs
+++ b/pwiz_tools/Skyline/Controls/Graphs/LabelLayoutRunner.cs
@@ -379,8 +379,10 @@ private void StartDebounced(LabelLayoutRequest request)
                         }
                         else
                         {
-                            var minLabelHeight = heights.FindAll(h => h > 0).Min();
-                            var labelLayout = workItem.LabelLayout ?? new LabelLayout(workItem.Pane, (int)Math.Ceiling(minLabelHeight));
+                            // The LabelLayout is always created on the UI thread in StartDebounced,
+                            // where it snapshots the marker geometry; the worker must never
+                            // construct one because that snapshot iterates the live curve list.
+                            var labelLayout = workItem.LabelLayout;
                             var progress = new WorkerProgress(progressPercent =>
                             {
                                 runOnUiThread(() =>
diff --git a/pwiz_tools/Skyline/TestFunctional/LabelLayoutTest.cs b/pwiz_tools/Skyline/TestFunctional/LabelLayoutTest.cs
index 51cb4504447..707e1b7234b 100644
--- a/pwiz_tools/Skyline/TestFunctional/LabelLayoutTest.cs
+++ b/pwiz_tools/Skyline/TestFunctional/LabelLayoutTest.cs
@@ -28,6 +28,7 @@
 using pwiz.Skyline.Controls.Graphs;
 using pwiz.Skyline.Properties;
 using pwiz.SkylineTestUtil;
+using ZedGraph;
 
 namespace pwiz.SkylineTestFunctional
 {
@@ -58,12 +59,14 @@ protected override void DoTest()
 
             OpenDocumentAndGraph();
             var firstSnapshot = CaptureLabelLayoutSnapshot();
+            VerifyLayoutInvariants();
 
             LoadNewDocument(true);
 
             RunUI(() => Settings.Default.GroupComparisonAvoidLabelOverlap = true);
             OpenDocumentAndGraph();
             var secondSnapshot = CaptureLabelLayoutSnapshot();
+            VerifyLayoutInvariants();
             CompareSnapshots(firstSnapshot, secondSnapshot);
         }
 
@@ -73,6 +76,12 @@ private void OpenDocumentAndGraph()
             WaitForDocumentLoaded();
             RunUI(() => SkylineWindow.ShowPeakAreaRelativeAbundanceGraph());
             WaitForGraphPane();
+            // The saved label layout is static so that label positions survive pane recreation -
+            // which also means it survives across runs and language passes in the same process.
+            // Toggling the overlap setting with the pane alive clears it, so every capture
+            // measures a fresh, deterministic layout instead of restoring the previous run's.
+            RunUI(() => Settings.Default.GroupComparisonAvoidLabelOverlap = false);
+            RunUI(() => Settings.Default.GroupComparisonAvoidLabelOverlap = true);
         }
 
         private SummaryRelativeAbundanceGraphPane WaitForGraphPane()
@@ -142,13 +151,20 @@ private void CompareSnapshots(List<PointSnapshot> first, List<PointSnapshot> sec
             }
 
             Assert.AreEqual(first.Count, second.Count, "Snapshots have different number of points.");
-            Assert.AreEqual(EXPECTED_POINT_COUNT, first.Count, "Plot point count is different from expected.");
             for (var i = 0; i < first.Count; i++)
             {
                 Assert.AreEqual(first[i].LabelText, second[i].LabelText, $@"Point {i} label text do not match.");
                 AssertPointPositionEqual(first[i].LabelPosition, second[i].LabelPosition, $@"Point {i} position does not match.");
             }
 
+            // The pinned snapshot below encodes the label choices and positions produced by
+            // English chart geometry. Localized axis titles and fonts change the chart
+            // rectangle, which legitimately changes which labels the sampler and pruner keep,
+            // so the pinned expectations are only checked when running in English.
+            if (!Equals("en", GetFolderNameForLanguage(CultureInfo.CurrentCulture)))
+                return;
+
+            Assert.AreEqual(EXPECTED_POINT_COUNT, first.Count, "Plot point count is different from expected.");
             foreach (var expectedPoint in EXPECTED_RANDOM_POINTS)
             {
                 AssertExpectedPoint(first, expectedPoint, "first");
@@ -189,6 +205,86 @@ private void AssertAxisEqual(float expected, float actual, string axisName, stri
         }
 
 
+        // Distance (squared, in pixels) within which a marker center counts as a label's own
+        // point. Mirrors LabelLayout.OWN_MARKER_TOLERANCE_SQ.
+        private const float OWN_MARKER_TOLERANCE_SQ = 4f;
+
+        /// <summary>
+        /// Verifies the invariants the post-annealing pruner guarantees, in any language and
+        /// with any chart geometry: no non-selected visible label overlaps any other visible
+        /// label, and no non-selected visible label covers the center of a point marker other
+        /// than its own. Selected labels are exempt as subjects, exactly as in the pruner: they
+        /// are never pruned, so when a saved layout is restored under different geometry (e.g.
+        /// a second language pass reusing the static saved layout) a selected label may
+        /// legitimately end up covering a marker or overlapping another selected label.
+        /// </summary>
+        private void VerifyLayoutInvariants()
+        {
+            RunUI(() =>
+            {
+                var summaryPane = FindGraphPane();
+                Assert.IsNotNull(summaryPane, "Missing relative abundance graph pane.");
+                var graphControl = summaryPane.GraphSummary.GraphControl;
+                var pane = graphControl.GraphPane;
+                var layout = pane.Layout;
+                Assert.IsNotNull(layout, "Missing label layout for invariant verification.");
+                using (var g = graphControl.CreateGraphics())
+                {
+                    var entries = new List<KeyValuePair<LabeledPoint, RectangleF>>();
+                    foreach (var labeledPoint in layout.LabeledPoints.Values.Where(lp => lp.Label.IsVisible))
+                    {
+                        var rect = pane.GetRectScreen(labeledPoint.Label, g);
+                        if (rect.Width > 0 && rect.Height > 0)
+                            entries.Add(new KeyValuePair<LabeledPoint, RectangleF>(labeledPoint, rect));
+                    }
+
+                    for (var i = 0; i < entries.Count; i++)
+                    {
+                        for (var j = i + 1; j < entries.Count; j++)
+                        {
+                            if (entries[i].Key.IsSelected && entries[j].Key.IsSelected)
+                                continue;
+                            AssertEx.IsFalse(entries[i].Value.IntersectsWith(entries[j].Value),
+                                string.Format("Labels '{0}' and '{1}' overlap after pruning.",
+                                    entries[i].Key.Label.Text, entries[j].Key.Label.Text));
+                        }
+                    }
+
+                    // Marker centers are derived the same way the pruner derives them: from the
+                    // integer marker rectangles reported by LineItem.GetCoords.
+                    var markerCenters = new List<PointF>();
+                    foreach (var line in pane.CurveList.OfType<LineItem>().Where(c => c.Symbol.Type != SymbolType.None))
+                    {
+                        for (var i = 0; i < line.Points.Count; i++)
+                        {
+                            if (!line.GetCoords(pane, i, out var coords))
+                                continue;
+                            var sides = Array.ConvertAll(coords.Split(','), int.Parse);
+                            markerCenters.Add(new PointF((sides[0] + sides[2]) / 2f, (sides[1] + sides[3]) / 2f));
+                        }
+                    }
+
+                    foreach (var entry in entries.Where(e => !e.Key.IsSelected))
+                    {
+                        var ownCenter = new PointF(pane.XAxis.Scale.Transform(entry.Key.Point.X),
+                            pane.YAxis.Scale.Transform(entry.Key.Point.Y));
+                        foreach (var center in markerCenters)
+                        {
+                            if (!entry.Value.Contains(center))
+                                continue;
+                            var dx = center.X - ownCenter.X;
+                            var dy = center.Y - ownCenter.Y;
+                            AssertEx.IsTrue(dx * dx + dy * dy <= OWN_MARKER_TOLERANCE_SQ,
+                                string.Format("Label '{0}' covers a foreign point marker. " +
+                                              "rect={1} center={2} ownCenter={3} chart={4} yScale={5}/{6} xScale={7}/{8}",
+                                    entry.Key.Label.Text, entry.Value, center, ownCenter, pane.Chart.Rect,
+                                    pane.YAxis.Scale.Min, pane.YAxis.Scale.Max, pane.XAxis.Scale.Min, pane.XAxis.Scale.Max));
+                        }
+                    }
+                }
+            });
+        }
+
         private SummaryRelativeAbundanceGraphPane FindGraphPane()
         {
             foreach (var graphSummary in SkylineWindow.ListGraphPeakArea)