Changeset 13843

Timestamp:

05/11/16 16:38:23 (9 years ago)

Author:

pfleck

Message:

#2597 Implemented "sync" y-axis for Target Response Gradient View.

Location:

branches/HeuristicLab.RegressionSolutionGradientView/HeuristicLab.Problems.DataAnalysis.Views/3.4

Files:

• GradientChart.cs (modified) (13 diffs)
• RegressionSolutionGradientView.Designer.cs (modified) (1 diff)
• RegressionSolutionTargetResponseGradientView.cs (modified) (5 diffs)

branches/HeuristicLab.RegressionSolutionGradientView/HeuristicLab.Problems.DataAnalysis.Views/3.4/GradientChart.cs

@@ -65 +65 @@
     public int XAxisTicks {
       get { return xAxisTicks; }
-      set { xAxisTicks = value; }
+      set {
+        if (value != xAxisTicks) {
+          xAxisTicks = value;
+          SetupAxis(chart.ChartAreas[0].AxisX, trainingMin, trainingMax, XAxisTicks, FixedXAxisMin, FixedXAxisMax);
+          RecalculateInternalDataset();
+        }
+      }
     }
     private double? fixedXAxisMin;
@@ -73 +79 @@
         if ((value.HasValue && fixedXAxisMin.HasValue && !value.Value.IsAlmost(fixedXAxisMin.Value)) || (value.HasValue != fixedXAxisMin.HasValue)) {
           fixedXAxisMin = value;
+          SetupAxis(chart.ChartAreas[0].AxisX, trainingMin, trainingMax, XAxisTicks, FixedXAxisMin, FixedXAxisMax);
           RecalculateInternalDataset();
         }
@@ -83 +90 @@
         if ((value.HasValue && fixedXAxisMax.HasValue && !value.Value.IsAlmost(fixedXAxisMax.Value)) || (value.HasValue != fixedXAxisMax.HasValue)) {
           fixedXAxisMax = value;
+          SetupAxis(chart.ChartAreas[0].AxisX, trainingMin, trainingMax, XAxisTicks, FixedXAxisMin, FixedXAxisMax);
           RecalculateInternalDataset();
         }
@@ -91 +99 @@
     public int YAxisTicks {
       get { return yAxisTicks; }
-      set { yAxisTicks = value; }
+      set {
+        if (value != yAxisTicks) {
+          yAxisTicks = value;
+          SetupAxis(chart.ChartAreas[0].AxisY, yMin, yMax, YAxisTicks, FixedYAxisMin, FixedYAxisMax);
+          RecalculateInternalDataset();
+        }
+      }
     }
     private double? fixedYAxisMin;
@@ -99 +113 @@
         if ((value.HasValue && fixedYAxisMin.HasValue && !value.Value.IsAlmost(fixedYAxisMin.Value)) || (value.HasValue != fixedYAxisMin.HasValue)) {
           fixedYAxisMin = value;
+          SetupAxis(chart.ChartAreas[0].AxisY, yMin, yMax, YAxisTicks, FixedYAxisMin, FixedYAxisMax);
         }
       }
@@ -108 +123 @@
         if ((value.HasValue && fixedYAxisMax.HasValue && !value.Value.IsAlmost(fixedYAxisMax.Value)) || (value.HasValue != fixedYAxisMax.HasValue)) {
           fixedYAxisMax = value;
-        }
-      }
-    }
-
-    private double trainingMin = double.MinValue;
-    public double TrainingMin {
-      get { return trainingMin; }
-      set { trainingMin = value; }
-    }
-    private double trainingMax = double.MaxValue;
-    public double TrainingMax {
-      get { return trainingMax; }
-      set { trainingMax = value; }
-    }
+          SetupAxis(chart.ChartAreas[0].AxisY, yMin, yMax, YAxisTicks, FixedYAxisMin, FixedYAxisMax);
+        }
+      }
+    }
+
+    private double trainingMin = 1;
+    private double trainingMax = -1;
 
     private int drawingSteps = 1000;
@@ -146 +154 @@
         RecalculateInternalDataset();
       }
+    }
+
+    private double yMin;
+    public double YMin {
+      get { return yMin; }
+    }
+    private double yMax;
+    public double YMax {
+      get { return yMax; }
     }
 
@@ -173 +190 @@
     }
     private void GradientChart_Disposed(object sender, EventArgs e) {
-      if (cancelCurrentRecalculateSource != null) {
-        if (cancelCurrentRecalculateSource.IsCancellationRequested)
-          cancelCurrentRecalculateSource.Cancel();
-      }
+      if (cancelCurrentRecalculateSource != null)
+        cancelCurrentRecalculateSource.Cancel();
     }
 
@@ -212 +227 @@
     }
 
-    public async Task RecalculateAsync() {
+    public async Task RecalculateAsync(bool updateOnFinish = true, bool resetYAxis = true) {
       if (IsDisposed
         || sharedFixedVariables == null || !solutions.Any() || string.IsNullOrEmpty(freeVariable)
@@ -230 +245 @@
       VerticalLineAnnotation.X = defaultValue;
       chart.ChartAreas[0].AxisX.Title = FreeVariable + " : " + defaultValue.ToString("N3", CultureInfo.CurrentCulture);
-      SetupAxis(chart.ChartAreas[0].AxisX, trainingMin, trainingMax, XAxisTicks, fixedXAxisMin, fixedXAxisMax);
 
       // Update series
       var cancellationToken = cancelCurrentRecalculateSource.Token;
       try {
-        await UpdateSeriesData(cancellationToken);
-        chart.Update();
-
+        var limits = await UpdateAllSeriesDataAsync(cancellationToken);
+        //cancellationToken.ThrowIfCancellationRequested();
+
+        yMin = limits.Lower;
+        yMax = limits.Upper;
         // Set y-axis
-        double ymin = 0, ymax = 0;
-        foreach (var vs in chart.Series.SelectMany(series => series.Points.Select(s => s.YValues))) {
-          for (int i = 0; i < vs.Length; i++) {
-            var v = vs[i];
-            if (ymin > v) ymin = v;
-            if (ymax < v) ymax = v;
-          }
-        }
-        SetupAxis(chart.ChartAreas[0].AxisY, ymin, ymax, YAxisTicks, FixedYAxisMin, FixedYAxisMax);
-        chart.ChartAreas[0].RecalculateAxesScale();
+        if (resetYAxis)
+          SetupAxis(chart.ChartAreas[0].AxisY, yMin, yMax, YAxisTicks, FixedYAxisMin, FixedYAxisMax);
 
         UpdateOutOfTrainingRangeStripLines();
 
         statusLabel.Visible = false;
-        Update(); // immediately show
+        if (updateOnFinish)
+          Update();
       }
       catch (OperationCanceledException) { }
@@ -262 +271 @@
     }
 
-    private static void SetupAxis(Axis axis, double minValue, double maxValue, int ticks, double? fixedAxisMin, double? fixedAxisMax) {
+    private void SetupAxis(Axis axis, double minValue, double maxValue, int ticks, double? fixedAxisMin, double? fixedAxisMax) {
       double axisMin, axisMax, axisInterval;
       ChartUtil.CalculateAxisInterval(minValue, maxValue, ticks, out axisMin, out axisMax, out axisInterval);
       axis.Minimum = fixedAxisMin ?? axisMin;
       axis.Maximum = fixedAxisMax ?? axisMax;
-      axis.Interval = (axisMax - axisMin) / ticks;
+      axis.Interval = (axis.Maximum - axis.Minimum) / ticks;
+
+      chart.ChartAreas[0].RecalculateAxesScale();
     }
 
@@ -283 +294 @@
 
     private void RecalculateInternalDataset() {
+      if (sharedFixedVariables == null)
+        return;
+
       // we expand the range in order to get nice tick intervals on the x axis
       double xmin, xmax, xinterval;
@@ -351 +365 @@
     }
 
-    private Task UpdateSeriesData(CancellationToken cancellationToken) {
+    private async Task<DoubleLimit> UpdateAllSeriesDataAsync(CancellationToken cancellationToken) {
+      var updateTasks = solutions.Select(solution => UpdateSeriesDataAsync(solution, cancellationToken));
+
+      double min = double.MaxValue, max = double.MinValue;
+      foreach (var update in updateTasks) {
+        var limit = await update;
+        if (limit.Lower < min) min = limit.Lower;
+        if (limit.Upper > max) max = limit.Upper;
+      }
+
+      return new DoubleLimit(min, max);
+    }
+
+    private Task<DoubleLimit> UpdateSeriesDataAsync(IRegressionSolution solution, CancellationToken cancellationToken) {
       return Task.Run(() => {
-        Parallel.ForEach(solutions, new ParallelOptions { CancellationToken = cancellationToken }, solution => {
-          var xvalues = internalDataset.GetDoubleValues(FreeVariable).ToList();
-          var yvalues = solution.Model.GetEstimatedValues(internalDataset, Enumerable.Range(0, internalDataset.Rows)).ToList();
-
-          var series = seriesCache[solution];
-          for (int i = 0; i < xvalues.Count; i++)
-            series.Points[i].SetValueXY(xvalues[i], yvalues[i]);
-
-          var confidenceBoundSolution = solution as IConfidenceBoundRegressionSolution;
-          if (confidenceBoundSolution != null) {
-            var confidenceIntervalSeries = ciSeriesCache[solution];
-
-            cancellationToken.ThrowIfCancellationRequested();
-            var variances =
-              confidenceBoundSolution.Model.GetEstimatedVariances(internalDataset,
-                Enumerable.Range(0, internalDataset.Rows)).ToList();
-            for (int i = 0; i < xvalues.Count; i++) {
-              var lower = yvalues[i] - 1.96 * Math.Sqrt(variances[i]);
-              var upper = yvalues[i] + 1.96 * Math.Sqrt(variances[i]);
-              confidenceIntervalSeries.Points[i].SetValueXY(xvalues[i], lower, upper);
-            }
+        var xvalues = internalDataset.GetDoubleValues(FreeVariable).ToList();
+        var yvalues = solution.Model.GetEstimatedValues(internalDataset, Enumerable.Range(0, internalDataset.Rows)).ToList();
+
+        double min = double.MaxValue, max = double.MinValue;
+
+        var series = seriesCache[solution];
+        for (int i = 0; i < xvalues.Count; i++) {
+          series.Points[i].SetValueXY(xvalues[i], yvalues[i]);
+          if (yvalues[i] < min) min = yvalues[i];
+          if (yvalues[i] > max) max = yvalues[i];
+        }
+
+        var confidenceBoundSolution = solution as IConfidenceBoundRegressionSolution;
+        if (confidenceBoundSolution != null) {
+          var confidenceIntervalSeries = ciSeriesCache[solution];
+
+          cancellationToken.ThrowIfCancellationRequested();
+          var variances =
+            confidenceBoundSolution.Model.GetEstimatedVariances(internalDataset,
+              Enumerable.Range(0, internalDataset.Rows)).ToList();
+          for (int i = 0; i < xvalues.Count; i++) {
+            var lower = yvalues[i] - 1.96 * Math.Sqrt(variances[i]);
+            var upper = yvalues[i] + 1.96 * Math.Sqrt(variances[i]);
+            confidenceIntervalSeries.Points[i].SetValueXY(xvalues[i], lower, upper);
+            if (lower < min) min = lower;
+            if (upper > max) max = upper;
           }
-          cancellationToken.ThrowIfCancellationRequested();
-        });
+        }
+
+        cancellationToken.ThrowIfCancellationRequested();
+        return new DoubleLimit(min, max);
       }, cancellationToken);
     }
 
     private void ResizeAllSeriesData() {
+      if (internalDataset == null)
+        return;
+
       var xvalues = internalDataset.GetDoubleValues(FreeVariable).ToList();
       foreach (var solution in solutions)

branches/HeuristicLab.RegressionSolutionGradientView/HeuristicLab.Problems.DataAnalysis.Views/3.4/RegressionSolutionGradientView.Designer.cs

@@ -82 +82 @@
       this.gradientChart.ShowCursor = false;
       this.gradientChart.ShowLegend = true;
-      this.gradientChart.ShowXAxisLabel = true;
+      this.gradientChart.ShowXAxisLabel = false;
       this.gradientChart.ShowYAxisLabel = true;
       this.gradientChart.Size = new System.Drawing.Size(715, 376);
       this.gradientChart.TabIndex = 0;
-      this.gradientChart.TrainingMax = 1.7976931348623157E+308D;
-      this.gradientChart.TrainingMin = -1.7976931348623157E+308D;
       this.gradientChart.XAxisTicks = 10;
       this.gradientChart.YAxisTicks = 5;

branches/HeuristicLab.RegressionSolutionGradientView/HeuristicLab.Problems.DataAnalysis.Views/3.4/RegressionSolutionTargetResponseGradientView.cs

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using System.Windows.Forms;
 using HeuristicLab.Common;
 using HeuristicLab.MainForm;
+using HeuristicLab.Visualization.ChartControlsExtensions;
 
 namespace HeuristicLab.Problems.DataAnalysis.Views {
@@ -33 +35 @@
     private readonly Dictionary<string, GradientChart> charts;
     private const int Points = 200;
+
+    private IEnumerable<GradientChart> VisibleCharts {
+      get { return gradientChartTableLayout.Controls.OfType<GradientChart>(); }
+    }
 
     public RegressionSolutionTargetResponseGradientView() {
@@ -72 +78 @@
           ShowXAxisLabel = true,
           ShowYAxisLabel = true,
+          YAxisTicks = 5,
         };
-        gradientChart.VariableValueChanged += (o, e) => {
-          foreach (var chart in gradientChartTableLayout.Controls.Cast<GradientChart>()) {
-            if (chart == (GradientChart)o) continue;
-            chart.RecalculateAsync();
-          }
+        gradientChart.VariableValueChanged += async (o, e) => {
+          var recalculations = VisibleCharts.Except(new[] { (GradientChart)o }).Select(async chart => {
+            await chart.RecalculateAsync(updateOnFinish: false, resetYAxis: false);
+          }).ToList();
+          await Task.WhenAll(recalculations);
+
+          if (recalculations.All(t => t.IsCompleted))
+            SyncYAxis();
         };
         gradientChart.Configure(new[] { Content }, sharedFixedVariables, variableName, Points);
@@ -86 +96 @@
       variableListView.Items.AddRange(variableNames.Select(x => new ListViewItem(x, 0)).ToArray());
     }
+
+    private void SyncYAxis() {
+      double min = double.MaxValue, max = double.MinValue;
+      foreach (var chart in VisibleCharts) {
+        if (chart.YMin < min) min = chart.YMin;
+        if (chart.YMax > max) max = chart.YMax;
+      }
+      double axisMin, axisMax, axisInterval;
+      ChartUtil.CalculateAxisInterval(min, max, 5, out axisMin, out axisMax, out axisInterval);
+
+      foreach (var chart in VisibleCharts) {
+        chart.FixedYAxisMin = axisMin;
+        chart.FixedYAxisMax = axisMax;
+        chart.Update();
+      }
+    }
+
     // sort chart controls so that they always appear in the same order as in the list view
     // the gradient chart layout should be suspended before calling this method
@@ -115 +142 @@
         tl.Controls.Remove(chart);
       }
+      SyncYAxis();
+
       var count = tl.Controls.Count;
       SortControls();