Free cookie consent management tool by TermsFeed Policy Generator

source: branches/2972_PDPRowSelect/HeuristicLab.Problems.DataAnalysis.Views/3.4/Controls/PartialDependencePlot.cs @ 16516

Last change on this file since 16516 was 16516, checked in by pfleck, 5 years ago

#2972 Updated UI for PDP variable values selection.

File size: 28.0 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2018 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections;
24using System.Collections.Generic;
25using System.Drawing;
26using System.Globalization;
27using System.Linq;
28using System.Threading;
29using System.Threading.Tasks;
30using System.Windows.Forms;
31using System.Windows.Forms.DataVisualization.Charting;
32using HeuristicLab.Common;
33using HeuristicLab.MainForm.WindowsForms;
34using HeuristicLab.Visualization.ChartControlsExtensions;
35
36namespace HeuristicLab.Problems.DataAnalysis.Views {
37  public partial class PartialDependencePlot : UserControl, IPartialDependencePlot {
38    private ModifiableDataset sharedFixedVariables; // used for syncronising variable values between charts
39    private ModifiableDataset internalDataset; // holds the x values for each point drawn
40
41    private CancellationTokenSource cancelCurrentRecalculateSource;
42
43    private readonly List<IRegressionSolution> solutions;
44    private readonly Dictionary<IRegressionSolution, Series> seriesCache;
45    private readonly Dictionary<IRegressionSolution, Series> ciSeriesCache;
46
47    private readonly ToolStripMenuItem configToolStripMenuItem;
48    private readonly PartialDependencePlotConfigurationDialog configurationDialog;
49
50    #region Properties
51    public string XAxisTitle {
52      get { return chart.ChartAreas[0].AxisX.Title; }
53      set { chart.ChartAreas[0].AxisX.Title = value; }
54    }
55
56    public string YAxisTitle {
57      get { return chart.ChartAreas[0].AxisY.Title; }
58      set { chart.ChartAreas[0].AxisY.Title = value; }
59    }
60
61    public bool ShowLegend {
62      get { return chart.Legends[0].Enabled; }
63      set { chart.Legends[0].Enabled = value; }
64    }
65    public bool ShowCursor {
66      get { return chart.Annotations[0].Visible; }
67      set {
68        chart.Annotations[0].Visible = value;
69        if (!value) chart.Titles[0].Text = string.Empty;
70      }
71    }
72
73    public bool ShowConfigButton {
74      get { return configurationButton.Visible; }
75      set { configurationButton.Visible = value; }
76    }
77
78    private int xAxisTicks = 5;
79    public int XAxisTicks {
80      get { return xAxisTicks; }
81      set {
82        if (value != xAxisTicks) {
83          xAxisTicks = value;
84          SetupAxis(chart, chart.ChartAreas[0].AxisX, trainingMin, trainingMax, XAxisTicks, FixedXAxisMin, FixedXAxisMax);
85          RecalculateInternalDataset();
86        }
87      }
88    }
89    private double? fixedXAxisMin;
90    public double? FixedXAxisMin {
91      get { return fixedXAxisMin; }
92      set {
93        if ((value.HasValue && fixedXAxisMin.HasValue && !value.Value.IsAlmost(fixedXAxisMin.Value)) || (value.HasValue != fixedXAxisMin.HasValue)) {
94          fixedXAxisMin = value;
95          SetupAxis(chart, chart.ChartAreas[0].AxisX, trainingMin, trainingMax, XAxisTicks, FixedXAxisMin, FixedXAxisMax);
96          RecalculateInternalDataset();
97          // set the vertical line position
98          if (VerticalLineAnnotation.X <= fixedXAxisMin) {
99            var axisX = chart.ChartAreas[0].AxisX;
100            var step = (axisX.Maximum - axisX.Minimum) / drawingSteps;
101            VerticalLineAnnotation.X = axisX.Minimum + step;
102          }
103        }
104      }
105    }
106    private double? fixedXAxisMax;
107    public double? FixedXAxisMax {
108      get { return fixedXAxisMax; }
109      set {
110        if ((value.HasValue && fixedXAxisMax.HasValue && !value.Value.IsAlmost(fixedXAxisMax.Value)) || (value.HasValue != fixedXAxisMax.HasValue)) {
111          fixedXAxisMax = value;
112          SetupAxis(chart, chart.ChartAreas[0].AxisX, trainingMin, trainingMax, XAxisTicks, FixedXAxisMin, FixedXAxisMax);
113          RecalculateInternalDataset();
114          // set the vertical line position
115          if (VerticalLineAnnotation.X >= fixedXAxisMax) {
116            var axisX = chart.ChartAreas[0].AxisX;
117            var step = (axisX.Maximum - axisX.Minimum) / drawingSteps;
118            VerticalLineAnnotation.X = axisX.Maximum - step;
119          }
120        }
121      }
122    }
123
124    private int yAxisTicks = 5;
125    public int YAxisTicks {
126      get { return yAxisTicks; }
127      set {
128        if (value != yAxisTicks) {
129          yAxisTicks = value;
130          SetupAxis(chart, chart.ChartAreas[0].AxisY, yMin, yMax, YAxisTicks, FixedYAxisMin, FixedYAxisMax);
131          RecalculateInternalDataset();
132        }
133      }
134    }
135    private double? fixedYAxisMin;
136    public double? FixedYAxisMin {
137      get { return fixedYAxisMin; }
138      set {
139        if ((value.HasValue && fixedYAxisMin.HasValue && !value.Value.IsAlmost(fixedYAxisMin.Value)) || (value.HasValue != fixedYAxisMin.HasValue)) {
140          fixedYAxisMin = value;
141          SetupAxis(chart, chart.ChartAreas[0].AxisY, yMin, yMax, YAxisTicks, FixedYAxisMin, FixedYAxisMax);
142        }
143      }
144    }
145    private double? fixedYAxisMax;
146    public double? FixedYAxisMax {
147      get { return fixedYAxisMax; }
148      set {
149        if ((value.HasValue && fixedYAxisMax.HasValue && !value.Value.IsAlmost(fixedYAxisMax.Value)) || (value.HasValue != fixedYAxisMax.HasValue)) {
150          fixedYAxisMax = value;
151          SetupAxis(chart, chart.ChartAreas[0].AxisY, yMin, yMax, YAxisTicks, FixedYAxisMin, FixedYAxisMax);
152        }
153      }
154    }
155
156    private double trainingMin = -1;
157    private double trainingMax = 1;
158
159    private int drawingSteps = 1000;
160    public int DrawingSteps {
161      get { return drawingSteps; }
162      set {
163        if (value != drawingSteps) {
164          drawingSteps = value;
165          RecalculateInternalDataset();
166          ResizeAllSeriesData();
167        }
168      }
169    }
170
171    private string freeVariable;
172    public string FreeVariable {
173      get { return freeVariable; }
174      set {
175        if (value == freeVariable) return;
176        if (solutions.Any(s => !s.ProblemData.Dataset.DoubleVariables.Contains(value))) {
177          throw new ArgumentException("Variable does not exist in the ProblemData of the Solutions.");
178        }
179        freeVariable = value;
180        RecalculateInternalDataset();
181      }
182    }
183
184    private double yMin;
185    public double YMin {
186      get { return yMin; }
187    }
188    private double yMax;
189    public double YMax {
190      get { return yMax; }
191    }
192
193    public bool IsZoomed {
194      get { return chart.ChartAreas[0].AxisX.ScaleView.IsZoomed; }
195    }
196
197    private VerticalLineAnnotation VerticalLineAnnotation {
198      get { return (VerticalLineAnnotation)chart.Annotations.SingleOrDefault(x => x is VerticalLineAnnotation); }
199    }
200
201    internal ElementPosition InnerPlotPosition {
202      get { return chart.ChartAreas[0].InnerPlotPosition; }
203    }
204    #endregion
205
206    public event EventHandler ChartPostPaint;
207
208    public PartialDependencePlot() {
209      InitializeComponent();
210
211      solutions = new List<IRegressionSolution>();
212      seriesCache = new Dictionary<IRegressionSolution, Series>();
213      ciSeriesCache = new Dictionary<IRegressionSolution, Series>();
214
215      // Configure axis
216      chart.CustomizeAllChartAreas();
217      chart.ChartAreas[0].CursorX.IsUserSelectionEnabled = false;
218      chart.ChartAreas[0].CursorY.IsUserSelectionEnabled = false;
219
220      chart.ChartAreas[0].Axes.ToList().ForEach(x => { x.ScaleView.Zoomable = false; });
221
222      configToolStripMenuItem = new ToolStripMenuItem("Configuration");
223      configToolStripMenuItem.Click += config_Click;
224      chart.ContextMenuStrip.Items.Add(new ToolStripSeparator());
225      chart.ContextMenuStrip.Items.Add(configToolStripMenuItem);
226      configurationDialog = new PartialDependencePlotConfigurationDialog(this);
227
228      Disposed += Control_Disposed;
229    }
230
231    private void Control_Disposed(object sender, EventArgs e) {
232      if (cancelCurrentRecalculateSource != null)
233        cancelCurrentRecalculateSource.Cancel();
234    }
235
236    public void Configure(IEnumerable<IRegressionSolution> solutions, ModifiableDataset sharedFixedVariables, string freeVariable, int drawingSteps, bool initializeAxisRanges = true) {
237      if (!SolutionsCompatible(solutions))
238        throw new ArgumentException("Solutions are not compatible with the problem data.");
239      this.freeVariable = freeVariable;
240      this.drawingSteps = drawingSteps;
241
242      this.solutions.Clear();
243      this.solutions.AddRange(solutions);
244
245      // add an event such that whenever a value is changed in the shared dataset,
246      // this change is reflected in the internal dataset (where the value becomes a whole column)
247      if (this.sharedFixedVariables != null) {
248        this.sharedFixedVariables.ItemChanged -= sharedFixedVariables_ItemChanged;
249        this.sharedFixedVariables.Reset -= sharedFixedVariables_Reset;
250      }
251
252      this.sharedFixedVariables = sharedFixedVariables;
253      this.sharedFixedVariables.ItemChanged += sharedFixedVariables_ItemChanged;
254      this.sharedFixedVariables.Reset += sharedFixedVariables_Reset;
255
256      RecalculateTrainingLimits(initializeAxisRanges);
257      RecalculateInternalDataset();
258
259      chart.Series.Clear();
260      seriesCache.Clear();
261      ciSeriesCache.Clear();
262      foreach (var solution in this.solutions) {
263        var series = CreateSeries(solution);
264        seriesCache.Add(solution, series.Item1);
265        if (series.Item2 != null)
266          ciSeriesCache.Add(solution, series.Item2);
267      }
268
269      // Set cursor and x-axis
270      // Make sure to allow a small offset to be able to distinguish the vertical line annotation from the axis
271      var defaultValue = sharedFixedVariables.GetDoubleValue(freeVariable, 0);
272      var step = (trainingMax - trainingMin) / drawingSteps;
273      var minimum = chart.ChartAreas[0].AxisX.Minimum;
274      var maximum = chart.ChartAreas[0].AxisX.Maximum;
275      if (defaultValue <= minimum)
276        VerticalLineAnnotation.X = minimum + step;
277      else if (defaultValue >= maximum)
278        VerticalLineAnnotation.X = maximum - step;
279      else
280        VerticalLineAnnotation.X = defaultValue;
281
282      if (ShowCursor)
283        chart.Titles[0].Text = FreeVariable + " : " + defaultValue.ToString("G5", CultureInfo.CurrentCulture);
284
285      ResizeAllSeriesData();
286      OrderAndColorSeries();
287    }
288
289    public async Task RecalculateAsync(bool updateOnFinish = true, bool resetYAxis = true) {
290      if (IsDisposed
291        || sharedFixedVariables == null || !solutions.Any() || string.IsNullOrEmpty(freeVariable)
292        || trainingMin > trainingMax || drawingSteps == 0)
293        return;
294
295      calculationPendingTimer.Start();
296
297      // cancel previous recalculate call
298      if (cancelCurrentRecalculateSource != null)
299        cancelCurrentRecalculateSource.Cancel();
300      cancelCurrentRecalculateSource = new CancellationTokenSource();
301      var cancellationToken = cancelCurrentRecalculateSource.Token;
302
303      // Update series
304      try {
305        var limits = await UpdateAllSeriesDataAsync(cancellationToken);
306        chart.Invalidate();
307
308        yMin = limits.Lower;
309        yMax = limits.Upper;
310        // Set y-axis
311        if (resetYAxis)
312          SetupAxis(chart, chart.ChartAreas[0].AxisY, yMin, yMax, YAxisTicks, FixedYAxisMin, FixedYAxisMax);
313
314        UpdateOutOfTrainingRangeStripLines();
315
316        calculationPendingTimer.Stop();
317        calculationPendingLabel.Visible = false;
318        if (updateOnFinish)
319          Update();
320      } catch (OperationCanceledException) { } catch (AggregateException ae) {
321        if (!ae.InnerExceptions.Any(e => e is OperationCanceledException))
322          throw;
323      }
324    }
325
326    public void UpdateTitlePosition() {
327      var title = chart.Titles[0];
328      var plotArea = InnerPlotPosition;
329
330      title.Visible = plotArea.Width != 0;
331
332      title.Position.X = plotArea.X + (plotArea.Width / 2);
333    }
334
335    private static void SetupAxis(EnhancedChart chart, Axis axis, double minValue, double maxValue, int ticks, double? fixedAxisMin, double? fixedAxisMax) {
336      //guard if only one distinct value is present
337      if (minValue.IsAlmost(maxValue)) {
338        minValue = minValue - 0.5;
339        maxValue = minValue + 0.5;
340      }
341
342      double axisMin, axisMax, axisInterval;
343      ChartUtil.CalculateAxisInterval(minValue, maxValue, ticks, out axisMin, out axisMax, out axisInterval);
344      axis.Minimum = fixedAxisMin ?? axisMin;
345      axis.Maximum = fixedAxisMax ?? axisMax;
346      axis.Interval = (axis.Maximum - axis.Minimum) / ticks;
347
348      chart.ChartAreas[0].RecalculateAxesScale();
349    }
350
351    private void RecalculateTrainingLimits(bool initializeAxisRanges) {
352      trainingMin = solutions.Select(s => s.ProblemData.Dataset.GetDoubleValues(freeVariable, s.ProblemData.TrainingIndices).Where(x => !double.IsNaN(x)).Min()).Max();
353      trainingMax = solutions.Select(s => s.ProblemData.Dataset.GetDoubleValues(freeVariable, s.ProblemData.TrainingIndices).Where(x => !double.IsNaN(x)).Max()).Min();
354
355      if (initializeAxisRanges) {
356        double xmin, xmax, xinterval;
357        //guard if only one distinct value is present
358        if (trainingMin.IsAlmost(trainingMax))
359          ChartUtil.CalculateAxisInterval(trainingMin - 0.5, trainingMax + 0.5, XAxisTicks, out xmin, out xmax, out xinterval);
360        else
361          ChartUtil.CalculateAxisInterval(trainingMin, trainingMax, XAxisTicks, out xmin, out xmax, out xinterval);
362
363        FixedXAxisMin = xmin;
364        FixedXAxisMax = xmax;
365      }
366    }
367
368    private void RecalculateInternalDataset() {
369      if (sharedFixedVariables == null)
370        return;
371
372      // we expand the range in order to get nice tick intervals on the x axis
373      double xmin, xmax, xinterval;
374      //guard if only one distinct value is present
375      if (trainingMin.IsAlmost(trainingMax))
376        ChartUtil.CalculateAxisInterval(trainingMin - 0.5, trainingMin + 0.5, XAxisTicks, out xmin, out xmax, out xinterval);
377      else
378        ChartUtil.CalculateAxisInterval(trainingMin, trainingMax, XAxisTicks, out xmin, out xmax, out xinterval);
379
380      if (FixedXAxisMin.HasValue) xmin = FixedXAxisMin.Value;
381      if (FixedXAxisMax.HasValue) xmax = FixedXAxisMax.Value;
382      double step = (xmax - xmin) / drawingSteps;
383
384      var xvalues = new List<double>();
385      for (int i = 0; i < drawingSteps; i++)
386        xvalues.Add(xmin + i * step);
387
388      if (sharedFixedVariables == null)
389        return;
390
391      var variables = sharedFixedVariables.VariableNames.ToList();
392      var values = new List<IList>();
393      foreach (var varName in variables) {
394        if (varName == FreeVariable) {
395          values.Add(xvalues);
396        } else if (sharedFixedVariables.VariableHasType<double>(varName)) {
397          values.Add(Enumerable.Repeat(sharedFixedVariables.GetDoubleValue(varName, 0), xvalues.Count).ToList());
398        } else if (sharedFixedVariables.VariableHasType<string>(varName)) {
399          values.Add(Enumerable.Repeat(sharedFixedVariables.GetStringValue(varName, 0), xvalues.Count).ToList());
400        }
401      }
402
403      internalDataset = new ModifiableDataset(variables, values);
404    }
405
406    private Tuple<Series, Series> CreateSeries(IRegressionSolution solution) {
407      var series = new Series {
408        ChartType = SeriesChartType.Line,
409        Name = solution.ProblemData.TargetVariable + " " + solutions.IndexOf(solution)
410      };
411      series.LegendText = series.Name;
412
413      var confidenceBoundSolution = solution as IConfidenceRegressionSolution;
414      Series confidenceIntervalSeries = null;
415      if (confidenceBoundSolution != null) {
416        confidenceIntervalSeries = new Series {
417          ChartType = SeriesChartType.Range,
418          YValuesPerPoint = 2,
419          Name = "95% Conf. Interval " + series.Name,
420          IsVisibleInLegend = false
421        };
422      }
423      return Tuple.Create(series, confidenceIntervalSeries);
424    }
425
426    private void OrderAndColorSeries() {
427      chart.SuspendRepaint();
428
429      chart.Series.Clear();
430      // Add mean series for applying palette colors
431      foreach (var solution in solutions) {
432        chart.Series.Add(seriesCache[solution]);
433      }
434
435      chart.Palette = ChartColorPalette.BrightPastel;
436      chart.ApplyPaletteColors();
437      chart.Palette = ChartColorPalette.None;
438
439      // Add confidence interval series before its coresponding series for correct z index
440      foreach (var solution in solutions) {
441        Series ciSeries;
442        if (ciSeriesCache.TryGetValue(solution, out ciSeries)) {
443          var series = seriesCache[solution];
444          ciSeries.Color = Color.FromArgb(40, series.Color);
445          int idx = chart.Series.IndexOf(seriesCache[solution]);
446          chart.Series.Insert(idx, ciSeries);
447        }
448      }
449
450      chart.ResumeRepaint(true);
451    }
452
453    private async Task<DoubleLimit> UpdateAllSeriesDataAsync(CancellationToken cancellationToken) {
454      var updateTasks = solutions.Select(solution => UpdateSeriesDataAsync(solution, cancellationToken));
455
456      double min = double.MaxValue, max = double.MinValue;
457      foreach (var update in updateTasks) {
458        var limit = await update;
459        if (limit.Lower < min) min = limit.Lower;
460        if (limit.Upper > max) max = limit.Upper;
461      }
462
463      return new DoubleLimit(min, max);
464    }
465
466    private Task<DoubleLimit> UpdateSeriesDataAsync(IRegressionSolution solution, CancellationToken cancellationToken) {
467      return Task.Run(() => {
468        var xvalues = internalDataset.GetDoubleValues(FreeVariable).ToList();
469        var yvalues = solution.Model.GetEstimatedValues(internalDataset, Enumerable.Range(0, internalDataset.Rows)).ToList();
470
471        double min = double.MaxValue, max = double.MinValue;
472
473        var series = seriesCache[solution];
474        for (int i = 0; i < xvalues.Count; i++) {
475          series.Points[i].SetValueXY(xvalues[i], yvalues[i]);
476          if (yvalues[i] < min) min = yvalues[i];
477          if (yvalues[i] > max) max = yvalues[i];
478        }
479
480        cancellationToken.ThrowIfCancellationRequested();
481
482        var confidenceBoundSolution = solution as IConfidenceRegressionSolution;
483        if (confidenceBoundSolution != null) {
484          var confidenceIntervalSeries = ciSeriesCache[solution];
485          var variances = confidenceBoundSolution.Model.GetEstimatedVariances(internalDataset, Enumerable.Range(0, internalDataset.Rows)).ToList();
486          for (int i = 0; i < xvalues.Count; i++) {
487            var lower = yvalues[i] - 1.96 * Math.Sqrt(variances[i]);
488            var upper = yvalues[i] + 1.96 * Math.Sqrt(variances[i]);
489            confidenceIntervalSeries.Points[i].SetValueXY(xvalues[i], lower, upper);
490            if (lower < min) min = lower;
491            if (upper > max) max = upper;
492          }
493        }
494
495        cancellationToken.ThrowIfCancellationRequested();
496        return new DoubleLimit(min, max);
497      }, cancellationToken);
498    }
499
500    private void ResizeAllSeriesData() {
501      if (internalDataset == null)
502        return;
503
504      var xvalues = internalDataset.GetDoubleValues(FreeVariable).ToList();
505      foreach (var solution in solutions)
506        ResizeSeriesData(solution, xvalues);
507    }
508    private void ResizeSeriesData(IRegressionSolution solution, IList<double> xvalues = null) {
509      if (xvalues == null)
510        xvalues = internalDataset.GetDoubleValues(FreeVariable).ToList();
511
512      var series = seriesCache[solution];
513      series.Points.SuspendUpdates();
514      series.Points.Clear();
515      for (int i = 0; i < xvalues.Count; i++)
516        series.Points.Add(new DataPoint(xvalues[i], 0.0));
517      series.Points.ResumeUpdates();
518
519      Series confidenceIntervalSeries;
520      if (ciSeriesCache.TryGetValue(solution, out confidenceIntervalSeries)) {
521        confidenceIntervalSeries.Points.SuspendUpdates();
522        confidenceIntervalSeries.Points.Clear();
523        for (int i = 0; i < xvalues.Count; i++)
524          confidenceIntervalSeries.Points.Add(new DataPoint(xvalues[i], new[] { -1.0, 1.0 }));
525        confidenceIntervalSeries.Points.ResumeUpdates();
526      }
527    }
528
529    public async Task AddSolutionAsync(IRegressionSolution solution) {
530      if (!SolutionsCompatible(solutions.Concat(new[] { solution })))
531        throw new ArgumentException("The solution is not compatible with the problem data.");
532      if (solutions.Contains(solution))
533        return;
534
535      solutions.Add(solution);
536      RecalculateTrainingLimits(true);
537
538      var series = CreateSeries(solution);
539      seriesCache.Add(solution, series.Item1);
540      if (series.Item2 != null)
541        ciSeriesCache.Add(solution, series.Item2);
542
543      ResizeSeriesData(solution);
544      OrderAndColorSeries();
545
546      await RecalculateAsync();
547      var args = new EventArgs<IRegressionSolution>(solution);
548      OnSolutionAdded(this, args);
549    }
550
551    public async Task RemoveSolutionAsync(IRegressionSolution solution) {
552      if (!solutions.Remove(solution))
553        return;
554
555      RecalculateTrainingLimits(true);
556
557      seriesCache.Remove(solution);
558      ciSeriesCache.Remove(solution);
559
560      await RecalculateAsync();
561      var args = new EventArgs<IRegressionSolution>(solution);
562      OnSolutionRemoved(this, args);
563    }
564
565    private static bool SolutionsCompatible(IEnumerable<IRegressionSolution> solutions) {
566      var refSolution = solutions.First();
567      var refSolVars = refSolution.ProblemData.Dataset.VariableNames;
568      foreach (var solution in solutions.Skip(1)) {
569        var variables1 = solution.ProblemData.Dataset.VariableNames;
570        if (!variables1.All(refSolVars.Contains))
571          return false;
572
573        foreach (var factorVar in variables1.Where(solution.ProblemData.Dataset.VariableHasType<string>)) {
574          var distinctVals = refSolution.ProblemData.Dataset.GetStringValues(factorVar).Distinct();
575          if (solution.ProblemData.Dataset.GetStringValues(factorVar).Any(val => !distinctVals.Contains(val))) return false;
576        }
577      }
578      return true;
579    }
580
581    private void UpdateOutOfTrainingRangeStripLines() {
582      var axisX = chart.ChartAreas[0].AxisX;
583      var lowerStripLine = axisX.StripLines[0];
584      var upperStripLine = axisX.StripLines[1];
585
586      lowerStripLine.IntervalOffset = axisX.Minimum;
587      lowerStripLine.StripWidth = Math.Abs(trainingMin - axisX.Minimum);
588
589      upperStripLine.IntervalOffset = trainingMax;
590      upperStripLine.StripWidth = Math.Abs(axisX.Maximum - trainingMax);
591    }
592
593    #region Events
594    public event EventHandler<EventArgs<IRegressionSolution>> SolutionAdded;
595    public void OnSolutionAdded(object sender, EventArgs<IRegressionSolution> args) {
596      var added = SolutionAdded;
597      if (added == null) return;
598      added(sender, args);
599    }
600
601    public event EventHandler<EventArgs<IRegressionSolution>> SolutionRemoved;
602    public void OnSolutionRemoved(object sender, EventArgs<IRegressionSolution> args) {
603      var removed = SolutionRemoved;
604      if (removed == null) return;
605      removed(sender, args);
606    }
607
608    public event EventHandler VariableValueChanged;
609    public void OnVariableValueChanged(object sender, EventArgs args) {
610      var changed = VariableValueChanged;
611      if (changed == null) return;
612      changed(sender, args);
613    }
614
615    public event EventHandler ZoomChanged;
616    public void OnZoomChanged(object sender, EventArgs args) {
617      var changed = ZoomChanged;
618      if (changed == null) return;
619      changed(sender, args);
620    }
621
622    private void sharedFixedVariables_ItemChanged(object o, EventArgs<int, int> e) {
623      if (o != sharedFixedVariables) return;
624      var variables = sharedFixedVariables.VariableNames.ToList();
625      var rowIndex = e.Value;
626      var columnIndex = e.Value2;
627
628      var variableName = variables[columnIndex];
629      if (variableName == FreeVariable) {
630        return;
631      }
632      if (internalDataset.VariableHasType<double>(variableName)) {
633        var v = sharedFixedVariables.GetDoubleValue(variableName, rowIndex);
634        var values = new List<double>(Enumerable.Repeat(v, internalDataset.Rows));
635        internalDataset.ReplaceVariable(variableName, values);
636      } else if (internalDataset.VariableHasType<string>(variableName)) {
637        var v = sharedFixedVariables.GetStringValue(variableName, rowIndex);
638        var values = new List<String>(Enumerable.Repeat(v, internalDataset.Rows));
639        internalDataset.ReplaceVariable(variableName, values);
640      } else {
641        // unsupported type
642        throw new NotSupportedException();
643      }
644    }
645
646    private void sharedFixedVariables_Reset(object sender, EventArgs e) {
647      var newValue = sharedFixedVariables.GetDoubleValue(FreeVariable, 0);
648      VerticalLineAnnotation.X = newValue;
649      UpdateCursor();  // triggers update of InternalDataset
650    }
651
652    private void chart_AnnotationPositionChanging(object sender, AnnotationPositionChangingEventArgs e) {
653      var step = (trainingMax - trainingMin) / drawingSteps;
654      double newLocation = step * (long)Math.Round(e.NewLocationX / step);
655      var axisX = chart.ChartAreas[0].AxisX;
656      if (newLocation >= axisX.Maximum)
657        newLocation = axisX.Maximum - step;
658      if (newLocation <= axisX.Minimum)
659        newLocation = axisX.Minimum + step;
660
661      e.NewLocationX = newLocation;
662
663      UpdateCursor();
664    }
665    private void chart_AnnotationPositionChanged(object sender, EventArgs e) {
666      UpdateCursor();
667    }
668    private void UpdateCursor() {
669      var x = VerticalLineAnnotation.X;
670
671      if (!sharedFixedVariables.GetDoubleValue(FreeVariable, 0).IsAlmost(x))
672        sharedFixedVariables.SetVariableValue(x, FreeVariable, 0);
673
674      if (ShowCursor) {
675        chart.Titles[0].Text = FreeVariable + " : " + x.ToString("G5", CultureInfo.CurrentCulture);
676        chart.Update();
677      }
678
679      OnVariableValueChanged(this, EventArgs.Empty);
680    }
681
682    private void chart_MouseMove(object sender, MouseEventArgs e) {
683      bool hitCursor = chart.HitTest(e.X, e.Y).ChartElementType == ChartElementType.Annotation;
684      chart.Cursor = hitCursor ? Cursors.VSplit : Cursors.Default;
685    }
686
687    private async void chart_DragDrop(object sender, DragEventArgs e) {
688      var data = e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat);
689      if (data != null) {
690        var solution = data as IRegressionSolution;
691        if (!solutions.Contains(solution))
692          await AddSolutionAsync(solution);
693      }
694    }
695    private void chart_DragEnter(object sender, DragEventArgs e) {
696      if (!e.Data.GetDataPresent(HeuristicLab.Common.Constants.DragDropDataFormat)) return;
697      e.Effect = DragDropEffects.None;
698
699      var data = e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat);
700      var regressionSolution = data as IRegressionSolution;
701      if (regressionSolution != null) {
702        e.Effect = DragDropEffects.Copy;
703      }
704    }
705
706    private void calculationPendingTimer_Tick(object sender, EventArgs e) {
707      calculationPendingLabel.Visible = true;
708      Update();
709    }
710
711    private void config_Click(object sender, EventArgs e) {
712      configurationDialog.ShowDialog(this);
713      OnZoomChanged(this, EventArgs.Empty);
714    }
715
716    private void chart_SelectionRangeChanged(object sender, CursorEventArgs e) {
717      OnZoomChanged(this, EventArgs.Empty);
718    }
719
720    private void chart_Resize(object sender, EventArgs e) {
721      UpdateTitlePosition();
722    }
723
724    private void chart_PostPaint(object sender, ChartPaintEventArgs e) {
725      if (ChartPostPaint != null)
726        ChartPostPaint(this, EventArgs.Empty);
727    }
728    #endregion
729  }
730}
731
Note: See TracBrowser for help on using the repository browser.