source: branches/HeuristicLab.RegressionSolutionGradientView/HeuristicLab.Problems.DataAnalysis.Views/3.4/RegressionSolutionTargetResponseGradientView.cs @ 13845

#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.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
using HeuristicLab.Common;
using HeuristicLab.MainForm;
using HeuristicLab.Visualization.ChartControlsExtensions;

namespace HeuristicLab.Problems.DataAnalysis.Views {
  [View("Target Response Gradient View")]
  [Content(typeof(IRegressionSolution))]
  public partial class RegressionSolutionTargetResponseGradientView : DataAnalysisSolutionEvaluationView {
    private readonly Dictionary<string, GradientChart> charts;
    private const int Points = 200;

    private IEnumerable<GradientChart> VisibleCharts {
      get { return gradientChartTableLayout.Controls.OfType<GradientChart>(); }
    }

    public RegressionSolutionTargetResponseGradientView() {
      InitializeComponent();
      charts = new Dictionary<string, GradientChart>();
    }

    public new IRegressionSolution Content {
      get { return (IRegressionSolution)base.Content; }
      set { base.Content = value; }
    }

    protected override void RegisterContentEvents() {
      base.RegisterContentEvents();
      variableListView.ItemChecked += variableListView_ItemChecked;
    }

    protected override void DeregisterContentEvents() {
      variableListView.ItemChecked -= variableListView_ItemChecked;
      base.DeregisterContentEvents();
    }

    protected override void OnContentChanged() {
      base.OnContentChanged();
      if (Content == null) return;
      var problemData = Content.ProblemData;
      // create dataset
      var allowedInputVariables = Content.ProblemData.AllowedInputVariables;
      var variableValues = allowedInputVariables.Select(x => new List<double> { problemData.Dataset.GetDoubleValues(x, problemData.TrainingIndices).Median() });
      var sharedFixedVariables = new ModifiableDataset(allowedInputVariables, variableValues);
      // create charts
      charts.Clear();
      foreach (var variableName in allowedInputVariables) {
        var gradientChart = new GradientChart {
          Dock = DockStyle.Fill,
          Margin = Padding.Empty,
          ShowLegend = false,
          ShowCursor = true,
          ShowXAxisLabel = true,
          ShowYAxisLabel = true,
          YAxisTicks = 5,
        };
        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);
        charts[variableName] = gradientChart;
      }
      // update variable list
      variableListView.Items.Clear();
      foreach (var variable in allowedInputVariables)
        variableListView.Items.Add(key: variable, text: variable, imageIndex: 0);

      foreach (var variable in Content.GetUsedVariablesForPrediction())
        variableListView.Items[variable].Checked = true;
    }

    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
    private void SortControls() {
      var tl = gradientChartTableLayout;
      var indices = variableListView.CheckedItems.Cast<ListViewItem>().ToDictionary(checkedItem => checkedItem.Text, checkedItem => checkedItem.Index);
      var count = tl.Controls.Count;
      var charts = new GradientChart[count];
      for (int i = 0; i < count; ++i) charts[i] = (GradientChart)tl.Controls[i];
      Array.Sort(charts, (a, b) => indices[a.FreeVariable].CompareTo(indices[b.FreeVariable]));
      tl.Controls.Clear();
      tl.Controls.AddRange(charts);
    }

    private async void variableListView_ItemChecked(object sender, ItemCheckedEventArgs e) {
      if (charts == null) return;
      var item = e.Item;
      var variable = item.Text;
      var chart = charts[variable];
      var tl = gradientChartTableLayout;
      tl.SuspendLayout();
      var columnWidth = tl.GetColumnWidths()[0]; // all columns have the same width
      var rowHeight = 0.8f * columnWidth;
      tl.RowStyles.Clear();
      if (item.Checked) {
        tl.Controls.Add(chart);
        await chart.RecalculateAsync();
      } else {
        tl.Controls.Remove(chart);
      }
      SyncYAxis();

      var count = tl.Controls.Count;
      SortControls();
      tl.RowCount = count / tl.ColumnCount + (count % tl.ColumnCount == 0 ? 0 : 1);
      for (int i = 0; i < count; ++i) {
        var control = tl.Controls[i];
        int rowIndex = i / tl.ColumnCount;
        int columnIndex = i % tl.ColumnCount;
        tl.SetRow(control, rowIndex);
        tl.SetColumn(control, columnIndex);
      }
      for (int i = 0; i < tl.RowCount; ++i) {
        tl.RowStyles.Add(new RowStyle(SizeType.Absolute, rowHeight));
      }
      tl.ResumeLayout();
    }
  }
}