source: branches/BubbleChart/HeuristicLab.Optimization.BubbleChart/3.3/BubbleChartView.cs @ 12388

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2015 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.Windows.Forms;
using System.Windows.Forms.DataVisualization.Charting;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Core.Views;
using HeuristicLab.Data;
using HeuristicLab.MainForm;

namespace HeuristicLab.Optimization.BubbleChart {
  [View("Bubble Chart (Recursive)")]
  [Content(typeof(RecursiveDataItem), false)]
  public partial class BubbleChartView : ItemView {

    private enum SizeDimension { Constant = 0 }
    private enum AxisDimension { Index = 0 }

    private string xAxisValue;
    private string yAxisValue;
    private string sizeAxisValue;

    private readonly Dictionary<RecursiveDataItem, int> itemToIndexMapping = new Dictionary<RecursiveDataItem, int>();
    private readonly Dictionary<string, Dictionary<object, double>> categoricalMapping = new Dictionary<string, Dictionary<object, double>>();

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

    public BubbleChartView() {
      InitializeComponent();
    }

    protected override void OnContentChanged() {
      base.OnContentChanged();

      UpdateTreeView();
      UpdateComboBoxes();
      UpdateDataPoints();
      //UpdateCaption();
    }

    #region Tree Queries
    private IEnumerable<string> GetAvailableKeys() {
      var collector = new List<string>(Content.Data.Keys);
      foreach (TreeNode node in treeView.Nodes)
        GetAvailableKeys(node, collector);
      return collector.Distinct();
    }
    private void GetAvailableKeys(TreeNode node, List<string> collector) {
      var item = (RecursiveDataItem)node.Tag;
      if (node.Checked)
        collector.AddRange(item.Data.Keys);
      foreach (TreeNode child in node.Nodes)
        GetAvailableKeys(child, collector);
    }

    private IEnumerable<RecursiveDataItem> GetAvailableItems() {
      var collector = new List<RecursiveDataItem>() { Content };
      foreach (TreeNode child in treeView.Nodes)
        GetAvailableItems(child, collector);
      return collector;
    }

    private void GetAvailableItems(TreeNode node, List<RecursiveDataItem> collector) {
      var item = (RecursiveDataItem)node.Tag;
      if (node.Checked)
        collector.Add(item);
      foreach (TreeNode child in node.Nodes)
        GetAvailableItems(child, collector);
    }
    #endregion

    #region Update Controls
    private void UpdateTreeView() {
      treeView.Nodes.Clear();

      if (Content != null) {
        foreach (var child in Content.Children)
          treeView.Nodes.Add(CreateTreeNode(child));
      }

      treeView.ExpandAll();
      splitContainer.Panel1Collapsed = treeView.Nodes.Count == 0;
    }
    private TreeNode CreateTreeNode(RecursiveDataItem item) {
      var node = new TreeNode(item.Name) {
        Tag = item,
        Checked = true
      };
      foreach (var child in item.Children)
        node.Nodes.Add(CreateTreeNode(child));
      return node;
    }

    private void UpdateComboBoxes() {
      var selectedXAxis = (string)xAxisComboBox.SelectedItem;
      var selectedYAxis = (string)yAxisComboBox.SelectedItem;
      var selectedSizeAxis = (string)sizeComboBox.SelectedItem;
      xAxisComboBox.Items.Clear();
      yAxisComboBox.Items.Clear();
      sizeComboBox.Items.Clear();

      if (Content != null) {
        var axisNames = GetAvailableKeys().ToArray();
        var additionalAxisDimension = Enum.GetNames(typeof(AxisDimension));
        var additionalSizeDimension = Enum.GetNames(typeof(SizeDimension));

        xAxisComboBox.Items.AddRange(additionalAxisDimension);
        xAxisComboBox.Items.AddRange(axisNames);
        yAxisComboBox.Items.AddRange(additionalAxisDimension);
        yAxisComboBox.Items.AddRange(axisNames);
        sizeComboBox.Items.AddRange(additionalSizeDimension);
        sizeComboBox.Items.AddRange(axisNames);
        sizeComboBox.SelectedItem = SizeDimension.Constant.ToString();

        bool changed = false;
        if (selectedXAxis != null && xAxisComboBox.Items.Contains(selectedXAxis)) {
          xAxisComboBox.SelectedItem = selectedXAxis;
          changed = true;
        }
        if (selectedYAxis != null && yAxisComboBox.Items.Contains(selectedYAxis)) {
          yAxisComboBox.SelectedItem = selectedYAxis;
          changed = true;
        }
        if (selectedSizeAxis != null && sizeComboBox.Items.Contains(selectedSizeAxis)) {
          sizeComboBox.SelectedItem = selectedSizeAxis;
          changed = true;
        }
        if (changed) {
          UpdateDataPoints();
          //UpdateAxisLabels();
        }
      }
    }

    private void UpdateDataPoints() {
      var series = chart.Series[0];
      series.Points.Clear();
      itemToIndexMapping.Clear();
      categoricalMapping.Clear();
      RebuildInverseIndex();

      chart.ChartAreas[0].AxisX.IsMarginVisible = xAxisValue != AxisDimension.Index.ToString();
      chart.ChartAreas[0].AxisY.IsMarginVisible = yAxisValue != AxisDimension.Index.ToString();

      if (Content != null) {
        var items = GetAvailableItems();
        foreach (var item in items) {
          var x = GetValue(item, xAxisValue);
          var y = GetValue(item, yAxisValue);
          var s = GetValue(item, sizeAxisValue);
          if (x.HasValue && y.HasValue && s.HasValue) {
            var dataPoint = new DataPoint(x.Value, new[] { y.Value, s.Value });
            series.Points.Add(dataPoint);
          }
        }
      }
    }
    private double? GetValue(RecursiveDataItem item, string key) {
      if (item == null || string.IsNullOrEmpty(key))
        return null;

      if (Enum.IsDefined(typeof(AxisDimension), key)) {
        var axisDimension = (AxisDimension)Enum.Parse(typeof(AxisDimension), key);
        return GetValue(item, axisDimension);
      } else if (Enum.IsDefined(typeof(SizeDimension), key)) {
        var sizeDimension = (SizeDimension)Enum.Parse(typeof(SizeDimension), key);
        return GetValue(item, sizeDimension);
      } else if (item.Data.ContainsKey(key)) {
        IItem value = item.Data[key];
        var doubleValue = value as DoubleValue;
        var intValue = value as IntValue;
        var timeSpanValue = value as TimeSpanValue;
        double? ret = null;
        if (doubleValue != null) {
          if (!double.IsNaN(doubleValue.Value) && !double.IsInfinity(doubleValue.Value))
            ret = doubleValue.Value;
        } else if (intValue != null)
          ret = intValue.Value;
        else if (timeSpanValue != null)
          ret = timeSpanValue.Value.TotalSeconds;
        else
          ret = GetCategoricalValue(item, key, value.ToString());
        return ret;
      } else {
        return null;
      }
    }
    private double? GetCategoricalValue(RecursiveDataItem item, string key, string value) {
      if (!categoricalMapping.ContainsKey(key)) {
        categoricalMapping[key] = new Dictionary<object, double>();
        var orderedCategories =
          GetAvailableItems().Where(x => x.Data.ContainsKey(key)).Select(x => x.Data[key].ToString())
            .Distinct().OrderBy(x => x, new NaturalStringComparer());
        int count = 1;
        foreach (var category in orderedCategories) {
          categoricalMapping[key].Add(category, count);
          count++;
        }
      }
      if (!this.categoricalMapping[key].ContainsKey(value)) return null;
      return this.categoricalMapping[key][value];
    }
    private double GetValue(RecursiveDataItem item, AxisDimension axisDimension) {
      double value = double.NaN;
      switch (axisDimension) {
        case AxisDimension.Index:
          value = itemToIndexMapping[item];
          break;
        default:
          throw new ArgumentException("No handling strategy for " + axisDimension.ToString() + " is defined.");
      }
      return value;
    }
    private double GetValue(RecursiveDataItem item, SizeDimension sizeDimension) {
      double value = double.NaN;
      switch (sizeDimension) {
        case SizeDimension.Constant:
          value = 2;
          break;
        default:
          throw new ArgumentException("No handling strategy for " + sizeDimension.ToString() + " is defined.");
      }
      return value;
    }
    private void RebuildInverseIndex() {
      if (Content != null) {
        itemToIndexMapping.Clear();
        int i = 0;
        foreach (var item in GetAvailableItems()) {
          // ToDo: do not add if key (which one?) is not present within item
          itemToIndexMapping.Add(item, i);
          i++;
        }
      }
    }
    #endregion

    #region Event Handlers
    private void treeView_AfterCheck(object sender, TreeViewEventArgs e) {
      UpdateComboBoxes();
      UpdateDataPoints();
    }

    private void axisComboBox_SelectedValueChanged(object sender, EventArgs e) {
      bool axisSelected = xAxisComboBox.SelectedIndex != -1 && yAxisComboBox.SelectedIndex != -1;

      xAxisValue = (string)xAxisComboBox.SelectedItem;
      yAxisValue = (string)yAxisComboBox.SelectedItem;
      sizeAxisValue = (string)sizeComboBox.SelectedItem;

      UpdateDataPoints();
      //UpdateAxisLabels();
    }
    #endregion


  }
}