refactor BioPolymerCoverageMapViewModel to use mapper + scale abstraction

nbollis · nbollis · commit fd4a17772a36 · 2026-07-14T13:32:25.000-05:00
Wires up the new color-mapping architecture:
- Add CreateColorMapper() to resolve mapper from current ColorBy
- Add CreateNumericScale(mapper, filteredResults) to derive min/max/range
- Add DrawNumericLegend(...) helper to render gradient bar
- Drawing loop now calls mapper.GetBrush(result, scale) instead of inline ternaries
- Remove ViridisColors, InitViridisPalette, GetIntensityBrush, GetColorBrush
  (now owned by ViridisColorGradient and the mapper hierarchy)

Update existing tests to reflect new abstraction and add 4 new
reflection-based tests for CreateColorMapper and CreateNumericScale
(non-numeric returns null, numeric derives min/max, all-null precursor
intensity falls back to score).

75 color-mapping tests passing; 451 MetaDraw tests passing overall.
diff --git a/MetaMorpheus/GuiFunctions/MetaDraw/BioPolymerCoverage/BioPolymerCoverageMapViewModel.cs b/MetaMorpheus/GuiFunctions/MetaDraw/BioPolymerCoverage/BioPolymerCoverageMapViewModel.cs
@@ -63,14 +63,6 @@ public class BioPolymerCoverageMapViewModel : BaseViewModel
         new SolidColorBrush(Colors.MediumAquamarine)
     });
 
-    private static readonly SolidColorBrush[] ViridisColors = InitViridisPalette();
-
-    private static SolidColorBrush[] InitViridisPalette()
-    {
-        var hex = new[] { "440154","481467","482576","453781","3f4d8a","39568c","2e6f8e","238a8d","20a386","34b679","60c85d","93d443","c7df2b","eddf2b","f8e51d","fce61b","fbdf0e","f6d300","edc600","fde725" };
-        return hex.Select(h => new SolidColorBrush((Color)ColorConverter.ConvertFromString("#" + h))).ToArray();
-    }
-
     private static readonly Dictionary<string, SolidColorBrush> IdentifierToColor = [];
 
     public ColorResultsBy[] AllColorByTypes { get; } = Enum.GetValues<ColorResultsBy>();
@@ -92,18 +84,47 @@ public ColorResultsBy ColorBy
         }
     }
 
-    private SolidColorBrush GetColorBrush(BioPolymerCoverageResultModel result)
+    private BioPolymerCoverageColorMapper CreateColorMapper()
+    {
+        return BioPolymerCoverageColorMapperFactory.Create(
+            _colorBy,
+            identifierBrushResolver: GetColorByIdentifier);
+    }
+
+    private BioPolymerCoverageColorScale? CreateNumericScale(
+        BioPolymerCoverageColorMapper mapper,
+        List<BioPolymerCoverageResultModel> filteredResults)
     {
-        switch (_colorBy)
+        var gradient = ColorGradientFactory.Create(ColorGradientType.Viridis);
+
+        if (mapper is not NumericBioPolymerCoverageColorMapper numericMapper)
+            return null;
+
+        var values = filteredResults
+            .Select(numericMapper.GetNumericValue)
+            .Where(v => v.HasValue)
+            .Select(v => v.Value)
+            .ToList();
+
+        if (values.Count == 0 && numericMapper is PrecursorIntensityColorMapper)
         {
-            case ColorResultsBy.CoverageType:
-                return MetaDrawSettings.BioPolymerCoverageColors[result.CoverageType];
-            case ColorResultsBy.FileOrigin:
-                // Use FileName as identifier since FullFilePath is not available
-                return GetColorByIdentifier(result.Match.FileName);
-            default:
-                return new SolidColorBrush(Colors.Gray);
+            numericMapper = new ScoreColorMapper();
+            values = filteredResults
+                .Select(numericMapper.GetNumericValue)
+                .Where(v => v.HasValue)
+                .Select(v => v.Value)
+                .ToList();
         }
+
+        if (values.Count == 0)
+            return new BioPolymerCoverageColorScale(0, 0, gradient);
+
+        double minVal = values.Min();
+        double maxVal = values.Max();
+        double range = maxVal - minVal;
+        if (range < double.Epsilon) range = 1;
+
+        return new BioPolymerCoverageColorScale(minVal, maxVal, gradient);
     }
 
     // Helper method for FileOrigin coloring
@@ -120,12 +141,6 @@ private SolidColorBrush GetColorByIdentifier(string identifier)
         return brush;
     }
 
-    private SolidColorBrush GetIntensityBrush(double normalizedValue)
-    {
-        int bin = (int)Math.Clamp(normalizedValue * 19, 0, 19);
-        return ViridisColors[bin];
-    }
-
     #endregion
 
     private DrawingImage _coverageDrawing;
@@ -194,6 +209,9 @@ private void Redraw()
         var rowRectangles = new Dictionary<int, List<(int startCol, int endCol)>>();
         var rowOccupancy = new Dictionary<int, int[]>(); // row -> per-column track usage
 
+        var mapper = CreateColorMapper();
+        var scale = CreateNumericScale(mapper, filteredResults);
+
         var dv = new DrawingVisual();
         using (var dc = dv.RenderOpen())
         {
@@ -255,12 +273,12 @@ private void Redraw()
             var sepWidth = sep.Width;
 
             double legendY = metricsY + metricsFt.Height + legendSpacing;
-            var legendItems = CreateLegendItems(filteredResults, fontSize, dpi, ColorBy);
+            var legendItems = CreateLegendItems(filteredResults, fontSize, dpi, _colorBy);
 
             var legendLines = WrapLegendItems(legendItems, fontSize, usableWidth, sepWidth);
 
             double legendLineHeight = legendItems.Count == 0 ? 0 : Math.Max(fontSize * 0.8, legendItems.Max(li => li.Text.Height));
-            
+
 
             foreach (var line in legendLines)
             {
@@ -287,42 +305,9 @@ private void Redraw()
                 legendY += legendLineHeight + legendSpacing * 0.2;
             }
 
-            bool isIntensityMode = _colorBy is ColorResultsBy.PrecursorIntensity or ColorResultsBy.Score;
-
-            double minVal = 0, maxVal = 0, range = 0, gradientBlockH = 0;
-            if (isIntensityMode)
-            {
-                var vals = filteredResults
-                    .Select(r => _colorBy == ColorResultsBy.PrecursorIntensity
-                        ? r.Match.PrecursorIntensity ?? double.NaN
-                        : r.Match.Score)
-                    .Where(v => !double.IsNaN(v)).ToList();
-                if (vals.Count == 0 && _colorBy == ColorResultsBy.PrecursorIntensity)
-                    vals = filteredResults.Select(r => r.Match.Score).ToList();
-                if (vals.Count > 0) { minVal = vals.Min(); maxVal = vals.Max(); }
-                range = maxVal - minVal;
-                if (range < double.Epsilon) range = 1;
-
-                double barWidth = Math.Min(250, usableWidth * 0.6);
-                double barHeight = fontSize * 0.8;
-                double barX = plotMargin + (usableWidth - barWidth) / 2;
-                double barY = legendY + legendSpacing;
-                double bandW = barWidth / 20;
-                for (int i = 0; i < 20; i++)
-                    dc.DrawRectangle(ViridisColors[i], null, new Rect(barX + i * bandW, barY, bandW + 0.5, barHeight));
-
-                string metricName = _colorBy == ColorResultsBy.PrecursorIntensity ? "Precursor Intensity" : "Score";
-                var metricTxt = new FormattedText(metricName, System.Globalization.CultureInfo.CurrentCulture, FlowDirection.LeftToRight, new Typeface("Segoe UI"), fontSize * 0.7, Brushes.DimGray, dpi);
-                dc.DrawText(metricTxt, new Point(barX + (barWidth - metricTxt.Width) / 2, barY - metricTxt.Height - 2));
-
-                var minTxt = new FormattedText($"{minVal:G3}", System.Globalization.CultureInfo.CurrentCulture, FlowDirection.LeftToRight, new Typeface("Segoe UI"), fontSize * 0.7, Brushes.Black, dpi);
-                var maxTxt = new FormattedText($"{maxVal:G3}", System.Globalization.CultureInfo.CurrentCulture, FlowDirection.LeftToRight, new Typeface("Segoe UI"), fontSize * 0.7, Brushes.Black, dpi);
-                dc.DrawText(minTxt, new Point(barX, barY + barHeight + 2));
-                dc.DrawText(maxTxt, new Point(barX + barWidth - maxTxt.Width, barY + barHeight + 2));
-
-                gradientBlockH = barHeight + Math.Max(minTxt.Height, maxTxt.Height) + legendSpacing * 2;
-                legendY += gradientBlockH;
-            }
+            double gradientBlockH = 0;
+            if (mapper.IsNumeric && scale is not null)
+                gradientBlockH = DrawNumericLegend(dc, legendY, plotMargin, usableWidth, legendSpacing, fontSize, dpi, mapper, scale, out legendY);
 
             // --- Offset plot below header block (metrics + legend) ---
             double headerBlockHeight = bioPolymerNameText.Height + metricsFt.Height + legendSpacing
@@ -407,11 +392,7 @@ private void Redraw()
                         roundRight = true;
 
                     // Use a slightly opaque brush for fill
-                    var baseBrush = isIntensityMode
-                        ? GetIntensityBrush(((_colorBy == ColorResultsBy.PrecursorIntensity
-                            ? res.Match.PrecursorIntensity.GetValueOrDefault((minVal + maxVal) / 2)
-                            : res.Match.Score) - minVal) / range)
-                        : GetColorBrush(res);
+                    var baseBrush = mapper.GetBrush(res, scale);
                     var color = (baseBrush as SolidColorBrush)?.Color ?? Colors.Gray;
                     var brush = new SolidColorBrush(color) { Opacity = 0.75 };
                     brush.Freeze();
@@ -564,6 +545,43 @@ private void Redraw()
         CoverageDrawing = new DrawingImage(dv.Drawing);
     }
 
+    private double DrawNumericLegend(
+        DrawingContext dc,
+        double legendY,
+        double plotMargin,
+        double usableWidth,
+        double legendSpacing,
+        double fontSize,
+        double dpi,
+        BioPolymerCoverageColorMapper mapper,
+        BioPolymerCoverageColorScale scale,
+        out double newLegendY)
+    {
+        double barWidth = Math.Min(250, usableWidth * 0.6);
+        double barHeight = fontSize * 0.8;
+        double barX = plotMargin + (usableWidth - barWidth) / 2;
+        double barY = legendY + legendSpacing;
+        var brushes = scale.Gradient.GetBrushes();
+        double bandW = barWidth / brushes.Count;
+        for (int i = 0; i < brushes.Count; i++)
+            dc.DrawRectangle(brushes[i], null, new Rect(barX + i * bandW, barY, bandW + 0.5, barHeight));
+
+        string metricName = mapper.ColorBy == ColorResultsBy.PrecursorIntensity
+            ? "Precursor Intensity"
+            : mapper.ColorBy.ToString();
+        var metricTxt = new FormattedText(metricName, System.Globalization.CultureInfo.CurrentCulture, FlowDirection.LeftToRight, new Typeface("Segoe UI"), fontSize * 0.7, Brushes.DimGray, dpi);
+        dc.DrawText(metricTxt, new Point(barX + (barWidth - metricTxt.Width) / 2, barY - metricTxt.Height - 2));
+
+        var minTxt = new FormattedText($"{scale.MinValue:G3}", System.Globalization.CultureInfo.CurrentCulture, FlowDirection.LeftToRight, new Typeface("Segoe UI"), fontSize * 0.7, Brushes.Black, dpi);
+        var maxTxt = new FormattedText($"{scale.MaxValue:G3}", System.Globalization.CultureInfo.CurrentCulture, FlowDirection.LeftToRight, new Typeface("Segoe UI"), fontSize * 0.7, Brushes.Black, dpi);
+        dc.DrawText(minTxt, new Point(barX, barY + barHeight + 2));
+        dc.DrawText(maxTxt, new Point(barX + barWidth - maxTxt.Width, barY + barHeight + 2));
+
+        double blockH = barHeight + Math.Max(minTxt.Height, maxTxt.Height) + legendSpacing * 2;
+        newLegendY = legendY + blockH;
+        return blockH;
+    }
+
     // Preferred legend order
     private static readonly BioPolymerCoverageType[] LegendOrder =
     {
@@ -664,4 +682,4 @@ private void Redraw()
 
         return lines;
     }
-}
+}
diff --git a/MetaMorpheus/GuiFunctions/MetaDraw/BioPolymerCoverage/ColorMapping/IMPLEMENTATION_PLAN.md b/MetaMorpheus/GuiFunctions/MetaDraw/BioPolymerCoverage/ColorMapping/IMPLEMENTATION_PLAN.md
@@ -6,39 +6,39 @@ abstraction with `Viridis` as the first gradient.
 
 ## 1. Gradient types
 
-- [ ] Create `ColorMapping/ColorGradientType.cs` with `Viridis` enum value.
-- [ ] Create `ColorMapping/ColorGradient.cs` abstract base with:
+- [x] Create `ColorMapping/ColorGradientType.cs` with `Viridis` enum value.
+- [x] Create `ColorMapping/ColorGradient.cs` abstract base with:
   - `ColorGradientType GradientType { get; }`
   - `int BinCount { get; }`
   - `SolidColorBrush GetBrush(double normalizedValue)`
   - `IReadOnlyList<SolidColorBrush> GetBrushes()`
-- [ ] Create `ColorMapping/ViridisColorGradient.cs` with the current 20-bin palette.
-- [ ] Create `ColorMapping/ColorGradientFactory.cs` static `Create(ColorGradientType)`.
+- [x] Create `ColorMapping/ViridisColorGradient.cs` with the current 20-bin palette.
+- [x] Create `ColorMapping/ColorGradientFactory.cs` static `Create(ColorGradientType)`.
 
 ## 2. Scale value object
 
-- [ ] Create `ColorMapping/BioPolymerCoverageColorScale.cs` with:
+- [x] Create `ColorMapping/BioPolymerCoverageColorScale.cs` with:
   - `MinValue`, `MaxValue`, `Range`, `Gradient` properties
   - `Normalize(double value)` helper
 
 ## 3. Mapper hierarchy
 
-- [ ] Create `ColorMapping/BioPolymerCoverageColorMapper.cs` abstract base with:
+- [x] Create `ColorMapping/BioPolymerCoverageColorMapper.cs` abstract base with:
   - `ColorResultsBy ColorBy { get; }`
   - `bool IsNumeric { get; }`
   - `SolidColorBrush GetBrush(BioPolymerCoverageResultModel, BioPolymerCoverageColorScale?)`
   - `virtual string GetLegendTitle(BioPolymerCoverageColorScale?)`
-- [ ] Create `ColorMapping/CategoricalBioPolymerCoverageColorMapper.cs`
+- [x] Create `ColorMapping/CategoricalBioPolymerCoverageColorMapper.cs`
   - constructor takes `ColorResultsBy` and `Func<BioPolymerCoverageResultModel, SolidColorBrush>`
-- [ ] Create `ColorMapping/NumericBioPolymerCoverageColorMapper.cs` abstract base
+- [x] Create `ColorMapping/NumericBioPolymerCoverageColorMapper.cs` abstract base
   - `abstract double? GetNumericValue(BioPolymerCoverageResultModel)`
   - base `GetBrush` does normalize + gradient lookup
-- [ ] Create `ColorMapping/PrecursorIntensityColorMapper.cs`
-- [ ] Create `ColorMapping/ScoreColorMapper.cs`
+- [x] Create `ColorMapping/PrecursorIntensityColorMapper.cs`
+- [x] Create `ColorMapping/ScoreColorMapper.cs`
 
 ## 4. Mapper factory
 
-- [ ] Create `ColorMapping/BioPolymerCoverageColorMapperFactory.cs`
+- [x] Create `ColorMapping/BioPolymerCoverageColorMapperFactory.cs`
   - `Create(ColorResultsBy, Func<string, SolidColorBrush> identifierBrushResolver, ColorGradientType gradientType = Viridis)`
   - registrations:
     - `None` -> gray categorical mapper
@@ -49,30 +49,32 @@ abstraction with `Viridis` as the first gradient.
 
 ## 5. View model refactor (`BioPolymerCoverageMapViewModel.cs`)
 
-- [ ] Add `CreateColorMapper()` helper.
-- [ ] Add `CreateNumericScale(BioPolymerCoverageColorMapper, List<BioPolymerCoverageResultModel>)` helper.
-- [ ] Rename `GetColorByIdentifier` to `GetIdentifierBrush` and pass it to factory.
-- [ ] Replace intensity-specific normalization block in `Redraw()` with mapper + scale flow.
-- [ ] Update drawing loop to use `mapper.GetBrush(result, scale)`.
-- [ ] Update `CreateLegendItems` to accept mapper + scale and return empty for numeric modes.
-- [ ] Extract gradient-bar drawing into `DrawNumericLegend(...)` returning consumed height.
-- [ ] Remove `ViridisColors`, `InitViridisPalette`, `GetIntensityBrush`, and the direct intensity ternary.
+- [x] Add `CreateColorMapper()` helper.
+- [x] Add `CreateNumericScale(BioPolymerCoverageColorMapper, List<BioPolymerCoverageResultModel>)` helper.
+- [x] Pass `GetColorByIdentifier` to factory as identifier resolver.
+- [x] Replace intensity-specific normalization block in `Redraw()` with mapper + scale flow.
+- [x] Update drawing loop to use `mapper.GetBrush(result, scale)`.
+- [x] Update `CreateLegendItems` to keep returning empty for numeric modes (gradient bar draws via new path).
+- [x] Extract gradient-bar drawing into `DrawNumericLegend(...)` returning consumed height.
+- [x] Remove `ViridisColors`, `InitViridisPalette`, `GetIntensityBrush`, and the direct intensity ternary.
 
 ## 6. Tests
 
-- [ ] Add `ViridisColorGradient` tests (count, clamp, end colors).
-- [ ] Add mapper factory tests (categorical vs numeric resolution).
-- [ ] Add numeric mapper tests (extract value, brush usage).
-- [ ] Update view-model drawing tests to use new abstraction paths.
-- [ ] Add `CreateNumericScale` test for min/max derivation.
-- [ ] Add fallback test: `PrecursorIntensity` with all null falls back to score through new abstraction.
+- [x] Add `ViridisColorGradient` tests (count, clamp, end colors) - 12 tests
+- [x] Add `BioPolymerCoverageColorScale` tests (normalization, clamping, null guard) - 9 tests
+- [x] Add numeric mapper tests (extract value, brush usage) - 19 tests
+- [x] Add mapper factory tests (categorical vs numeric resolution) - 10 tests
+- [x] Update view-model drawing tests to use new abstraction paths.
+- [x] Add `CreateColorMapper` test for mapper resolution by `ColorBy`.
+- [x] Add `CreateNumericScale` tests for non-numeric returns null and numeric derives min/max.
+- [x] Add fallback test: `PrecursorIntensity` with all null falls back to score through new abstraction.
 
 ## 7. Build + verify
 
-- [ ] Build `GuiFunctions` project: 0 errors.
-- [ ] Build `Test` project: 0 errors.
-- [ ] Run all new and existing tests in `BioPolymerCoverageMapViewModelTests` and gradient/mapper tests.
-- [ ] Run full test suite to confirm no regressions.
+- [x] Build `GuiFunctions` project: 0 errors.
+- [x] Build `Test` project: 0 errors.
+- [x] Run all new and existing tests in `BioPolymerCoverageMapViewModelTests` and gradient/mapper tests.
+- [x] Run full MetaDraw test suite to confirm no regressions (451 tests passing).
 
 ## 8. Commit + push
 
diff --git a/MetaMorpheus/Test/MetaDraw/BioPolymerCoverageMapViewModelTests.cs b/MetaMorpheus/Test/MetaDraw/BioPolymerCoverageMapViewModelTests.cs
