source: branches/HeuristicLab.RegressionSolutionGradientView/HeuristicLab.Algorithms.DataAnalysis.Views/3.4/GaussianProcessRegressionSolutionIteractiveRangeEstimatorView.cs @ 13812

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Globalization;
using System.Linq;
using System.Windows.Forms;
using System.Windows.Forms.DataVisualization.Charting;
using HeuristicLab.Data;
using HeuristicLab.Data.Views;
using HeuristicLab.MainForm;
using HeuristicLab.MainForm.WindowsForms;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DataAnalysis.Views;
using HeuristicLab.Visualization.ChartControlsExtensions;

namespace HeuristicLab.Algorithms.DataAnalysis.Views {
  [View("Interactive Estimator")]
  [Content(typeof(GaussianProcessRegressionSolution))]
  public partial class GaussianProcessRegressionSolutionIteractiveRangeEstimatorView : DataAnalysisSolutionEvaluationView {
    const int TrackBarSteps = 1000;
    const int DrawingSteps = 1000;

    private const string EstimatedMeanSeriesName = "Estimated Mean";
    private const string EstimatedVarianceSeriesName = "95% Conficence Interval";

    private static readonly string LabelFormatString = "{0}:" + Environment.NewLine + "{1}";

    private List<string> variableNames;
    private List<DoubleRange> ranges;
    private List<RadioButton> radioButtons;
    private List<TrackBar> trackBars;


    private int ActiveDimension {
      get { return radioButtons.FindIndex(rb => rb.Checked); }
    }

    public new GaussianProcessRegressionSolution Content {
      get { return (GaussianProcessRegressionSolution)base.Content; }
      set { base.Content = value; }
    }
    public GaussianProcessRegressionSolutionIteractiveRangeEstimatorView()
        : base() {
      variableNames = new List<string>();
      ranges = new List<DoubleRange>();
      radioButtons = new List<RadioButton>();
      trackBars = new List<TrackBar>();

      InitializeComponent();
      tableLayoutPanel.HorizontalScroll.Maximum = 0;
      tableLayoutPanel.AutoScroll = false;
      tableLayoutPanel.HorizontalScroll.Visible = false;
      tableLayoutPanel.AutoScroll = true;

      //configure axis
      chart.CustomizeAllChartAreas();
      chart.ChartAreas[0].CursorX.IsUserSelectionEnabled = true;
      chart.ChartAreas[0].AxisX.ScaleView.Zoomable = true;
      chart.ChartAreas[0].CursorX.Interval = 1;

      chart.ChartAreas[0].CursorY.IsUserSelectionEnabled = true;
      chart.ChartAreas[0].AxisY.ScaleView.Zoomable = true;
      chart.ChartAreas[0].CursorY.Interval = 0;
    }

    private void RedrawChart() {
      chart.Series.Clear();
      chart.ChartAreas[0].AxisX.StripLines.Clear();
      if (Content == null) return;

      double minX = ranges[ActiveDimension].Start;
      double maxX = ranges[ActiveDimension].End;
      decimal stepSize = (decimal)((maxX - minX) / DrawingSteps);

      //double axisMin, axisMax, axisInterval;
      //ChartUtil.CalculateAxisInterval(minX, maxX, 10, out axisMin, out axisMax, out axisInterval);
      //decimal axisStepsSize = (decimal)((maxX - minX) / DrawingSteps);

      // Build dataset
      var activeXs = Enumerable.Range(0, DrawingSteps).Select(i => (decimal)minX + i * stepSize).ToList();
      var fixedXs = trackBars.Zip(ranges, (t, r) => (decimal)r.Start + ((decimal)r.End - (decimal)r.Start)/TrackBarSteps*t.Value).ToList();
      var values = new double[DrawingSteps, variableNames.Count];
      for (int r = 0; r < DrawingSteps; r++) {
        for (int c = 0; c < variableNames.Count; c++) {
          values[r, c] = (double)(c == ActiveDimension ? activeXs[r] : fixedXs[c]);
        }
      }
      var dataset = new Dataset(variableNames, values);

      // Estimations
      var model = Content.Model;
      var means = model.GetEstimatedValues(dataset, Enumerable.Range(0, DrawingSteps)).ToList();
      var variances = model.GetEstimatedVariance(dataset, Enumerable.Range(0, DrawingSteps)).ToList();

      // Charting config
      chart.ChartAreas[0].AxisX.Minimum = minX;
      chart.ChartAreas[0].AxisX.Maximum = maxX;
      chart.ChartAreas[0].AxisX.Interval = (maxX - minX) / 10;

      chart.Series.Add(EstimatedVarianceSeriesName);
      chart.Series[EstimatedVarianceSeriesName].LegendText = EstimatedVarianceSeriesName;
      chart.Series[EstimatedVarianceSeriesName].ChartType = SeriesChartType.Range;
      chart.Series[EstimatedVarianceSeriesName].EmptyPointStyle.Color = chart.Series[EstimatedVarianceSeriesName].Color;

      chart.Series.Add(EstimatedMeanSeriesName);
      chart.Series[EstimatedMeanSeriesName].LegendText = EstimatedMeanSeriesName;
      chart.Series[EstimatedMeanSeriesName].ChartType = SeriesChartType.FastLine;

      // Charting databind
      var lower = means.Zip(variances, GetLowerConfBound).ToList();
      var upper = means.Zip(variances, GetUpperConfBound).ToList();
      chart.Series[EstimatedVarianceSeriesName].Points.DataBindXY(activeXs, lower, upper);
      //InsertEmptyPoints(chart.Series[EstimatedVarianceSeriesName]);

      chart.Series[EstimatedMeanSeriesName].Points.DataBindXY(activeXs, means);
      //InsertEmptyPoints(chart.Series[EstimatedMeanSeriesName]);

      // Update StripLines
      var trainingValues = Content.ProblemData.Dataset.GetDoubleValues(variableNames[ActiveDimension], Content.ProblemData.TrainingIndices);
      var trainingRange = new DoubleRange(trainingValues.Min(), trainingValues.Max());
      if (minX < trainingRange.Start)
        CreateAndAddStripLine(minX, trainingRange.Start, Color.FromArgb(40, 223, 58, 2), Color.Transparent);
      if (maxX > trainingRange.End)
        CreateAndAddStripLine(trainingRange.End, maxX, Color.FromArgb(40, 223, 58, 2), Color.Transparent);
    }

    private void CreateAndAddStripLine(double start, double end, Color color, Color secondColor) {
      StripLine stripLine = new StripLine {
        BackColor = color,
        BackSecondaryColor = secondColor,
        StripWidth = end - start,
        IntervalOffset = start
      };
      chart.ChartAreas[0].AxisX.StripLines.Add(stripLine);
    }

    private void UpdateConfigurationControls() {
      tableLayoutPanel.SuspendRepaint();
      tableLayoutPanel.SuspendLayout();

      tableLayoutPanel.RowCount = 0;
      tableLayoutPanel.Controls.Clear();

      variableNames.Clear();
      ranges.Clear();
      radioButtons.Clear();
      trackBars.Clear();


      if (Content == null) {
        tableLayoutPanel.ResumeLayout(true);
        tableLayoutPanel.ResumeRepaint(true);
        return;
      }

      variableNames.AddRange(Content.ProblemData.AllowedInputVariables);
      for (int i = 0; i < variableNames.Count; i++) {
        var values = Content.ProblemData.Dataset.GetDoubleValues(variableNames[i], Content.ProblemData.AllIndices);
        double min, max, interval;
        ChartUtil.CalculateAxisInterval(values.Min(), values.Max(), 10, out min, out max, out interval);
        ranges.Add(new DoubleRange(min, max));
      }

      tableLayoutPanel.RowCount = variableNames.Count;
      while (tableLayoutPanel.RowStyles.Count < variableNames.Count)
        tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.AutoSize));

      for (int i = 0; i < variableNames.Count; i++) {
        var radioButton = new RadioButton {
          Text =  string.Format(LabelFormatString, variableNames[i], ranges[i].Start + (ranges[i].End - ranges[i].Start) / 2),
          Checked = i == 0,
          Anchor = AnchorStyles.Top | AnchorStyles.Left,
          AutoSize = true,
        };
        radioButton.CheckedChanged += radioButton_CheckedChanged;
        var trackBar = new TrackBar {
          Minimum = 0,
          Maximum = TrackBarSteps,
          Value = TrackBarSteps / 2,
          TickFrequency = TrackBarSteps / 10,
          LargeChange = TrackBarSteps / 10,
          Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right,
          Enabled = i != 0
        };
        trackBar.ValueChanged += trackBar_ValueChanged;
        var rangeView = new DoubleRangeView {
          Content = ranges[i],
          Anchor = AnchorStyles.Top | AnchorStyles.Right,
        };
        rangeView.Content.ValueChanged += rangeView_ValueChanged;

        tableLayoutPanel.RowStyles[i].SizeType = SizeType.AutoSize;
        tableLayoutPanel.Controls.Add(radioButton, 0, i);
        tableLayoutPanel.Controls.Add(trackBar, 1, i);
        tableLayoutPanel.Controls.Add(rangeView, 2, i);

        radioButtons.Add(radioButton);
        trackBars.Add(trackBar);
      }

      tableLayoutPanel.ResumeLayout(true);
      tableLayoutPanel.ResumeRepaint(true);
    }

    private void UpdateCurrentValueLabel(int dim = -1) {
      if (dim < 0) {
        for (int i = 0; i < radioButtons.Count; i++) {
          decimal value = (decimal)ranges[i].Start + ((decimal)ranges[i].End - (decimal)ranges[i].Start) / TrackBarSteps * trackBars[i].Value;
          radioButtons[i].Text = Text = string.Format(LabelFormatString, variableNames[i], i == ActiveDimension ? "<Plotted>" : value.ToString(CultureInfo.InvariantCulture));
        }
      } else {
        decimal value = (decimal)ranges[dim].Start + ((decimal)ranges[dim].End - (decimal)ranges[dim].Start)  /TrackBarSteps * trackBars[dim].Value;
        radioButtons[dim].Text = Text = string.Format(LabelFormatString, variableNames[dim], dim == ActiveDimension ? "<Plotted>" : value.ToString(CultureInfo.InvariantCulture));
      }
    }

    private void radioButton_CheckedChanged(object sender, EventArgs e) {
      var radioButton = sender as RadioButton;
      if (radioButton == null || !radioButton.Checked) return;

      int index = radioButtons.IndexOf(radioButton);

      var inputVariables = Content.ProblemData.AllowedInputVariables.ToList();
      for (int i = 0; i < inputVariables.Count; i++) {
        radioButtons[i].Checked = i == index;
        trackBars[i].Enabled = i != index;
      }

      UpdateCurrentValueLabel();
      RedrawChart();
    }
    private void trackBar_ValueChanged(object sender, EventArgs e) {
      UpdateCurrentValueLabel(trackBars.FindIndex(t => t == sender));
      RedrawChart();
    }
    private void rangeView_ValueChanged(object sender, EventArgs e) {
      UpdateCurrentValueLabel(ranges.FindIndex(r => r == sender));
      RedrawChart();
    }

    #region Events
    protected override void RegisterContentEvents() {
      base.RegisterContentEvents();
      Content.ModelChanged += new EventHandler(Content_ModelChanged);
      Content.ProblemDataChanged += new EventHandler(Content_ProblemDataChanged);
    }
    protected override void DeregisterContentEvents() {
      base.DeregisterContentEvents();
      Content.ModelChanged -= new EventHandler(Content_ModelChanged);
      Content.ProblemDataChanged -= new EventHandler(Content_ProblemDataChanged);
    }

    protected override void OnContentChanged() {
      base.OnContentChanged();
      UpdateConfigurationControls();
      RedrawChart();
    }
    private void Content_ModelChanged(object sender, EventArgs e) {
      RedrawChart();
    }
    private void Content_ProblemDataChanged(object sender, EventArgs e) {
      UpdateConfigurationControls();
      RedrawChart();
    }

    private void Chart_MouseDoubleClick(object sender, MouseEventArgs e) {
      var result = chart.HitTest(e.X, e.Y);
      if (true || result.ChartArea != null && (result.ChartElementType == ChartElementType.PlottingArea ||
                                       result.ChartElementType == ChartElementType.Gridlines) ||
                                       result.ChartElementType == ChartElementType.StripLines) {
        foreach (var axis in result.ChartArea.Axes)
          axis.ScaleView.ZoomReset(int.MaxValue);
      }
    }
    private void chart_MouseMove(object sender, MouseEventArgs e) {
      //HitTestResult result = chart.HitTest(e.X, e.Y);
      //if (result.ChartElementType == ChartElementType.LegendItem && result.Series.Name != TARGETVARIABLE_SERIES_NAME)
      //  Cursor = Cursors.Hand;
      //else
      //  Cursor = Cursors.Default;
    }
    private void chart_MouseDown(object sender, MouseEventArgs e) {
      //HitTestResult result = chart.HitTest(e.X, e.Y);
      //if (result.ChartElementType == ChartElementType.LegendItem && result.Series.Name != TARGETVARIABLE_SERIES_NAME) {
      //  ToggleSeriesData(result.Series);
      //}
    }
    private void chart_CustomizeLegend(object sender, CustomizeLegendEventArgs e) {
      //if (chart.Series.Count != 4) return;
      //e.LegendItems[0].Cells[1].ForeColor = this.chart.Series[EstimatedMeanSeriesName].Points.Count == 0 ? Color.Gray : Color.Black;
      //e.LegendItems[1].Cells[1].ForeColor = this.chart.Series[ESTIMATEDVALUES_TEST_SERIES_NAME].Points.Count == 0 ? Color.Gray : Color.Black;
      //e.LegendItems[2].Cells[1].ForeColor = this.chart.Series[ESTIMATEDVALUES_ALL_SERIES_NAME].Points.Count == 0 ? Color.Gray : Color.Black;
      //e.LegendItems[3].Cells[1].ForeColor = this.chart.Series[TARGETVARIABLE_SERIES_NAME].Points.Count == 0 ? Color.Gray : Color.Black;
    }
    #endregion

    #region Helper
    private double GetLowerConfBound(double m, double s2) {
      return m - 1.96 * Math.Sqrt(s2);
    }
    private double GetUpperConfBound(double m, double s2) {
      return m + 1.96 * Math.Sqrt(s2);
    }
    #endregion
  }
}