source: branches/HeuristicLab.TreeSimplifierView/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs @ 7422

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 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.ComponentModel;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using HeuristicLab.Common;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
using HeuristicLab.MainForm.WindowsForms;

namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
  public abstract partial class InteractiveSymbolicDataAnalysisSolutionSimplifierView : AsynchronousContentView {
    private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> replacementNodes;
    private Dictionary<ISymbolicExpressionTreeNode, double> nodeImpacts;
    private Dictionary<ISymbolicExpressionTreeNode, double> originalValues;
    private bool updateInProgress = false;
    private VisualSymbolicExpressionTreeNode visualTreeNode; // for correctly handling events when changing node values
    private ISymbolicExpressionTree model;

    public InteractiveSymbolicDataAnalysisSolutionSimplifierView() {
      InitializeComponent();
      this.replacementNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
      this.nodeImpacts = new Dictionary<ISymbolicExpressionTreeNode, double>();
      this.originalValues = new Dictionary<ISymbolicExpressionTreeNode, double>();
      this.Caption = "Interactive Solution Simplifier";
    }

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

    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);
    }

    private void Content_ModelChanged(object sender, EventArgs e) {
      OnModelChanged();
    }
    private void Content_ProblemDataChanged(object sender, EventArgs e) {
      OnProblemDataChanged();
    }

    protected virtual void OnModelChanged() {
      model = (model == null)
                ? (ISymbolicExpressionTree)Content.Model.SymbolicExpressionTree.Clone()
                : Content.Model.SymbolicExpressionTree;
      this.CalculateReplacementNodesAndNodeImpacts(model);
      this.PaintModel();
    }

    protected virtual void OnProblemDataChanged() {
      this.CalculateReplacementNodesAndNodeImpacts();
      this.PaintModel();
    }

    protected override void OnContentChanged() {
      model = (model == null)
          ? (ISymbolicExpressionTree)Content.Model.SymbolicExpressionTree.Clone()
          : Content.Model.SymbolicExpressionTree;
      base.OnContentChanged();
      this.CalculateReplacementNodesAndNodeImpacts(model);
      this.PaintModel();
      this.viewHost.Content = this.Content;
    }

    private void CalculateReplacementNodesAndNodeImpacts() {
      if (Content == null || Content.Model == null || Content.ProblemData == null) return;
      //var tree = Content.Model.SymbolicExpressionTree;
      var tree = model;
      var replacementValues = CalculateReplacementValues(tree);
      foreach (var pair in replacementValues.Where(pair => !(pair.Key is ConstantTreeNode))) {
        replacementNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
      }
      nodeImpacts = CalculateImpactValues(tree);

      if (!updateInProgress) {
        // automatically fold all branches with impact = 0
        List<ISymbolicExpressionTreeNode> nodeList = tree.Root.GetSubtree(0).IterateNodesPrefix().ToList();
        foreach (var parent in nodeList) {
          for (int subTreeIndex = 0; subTreeIndex < parent.SubtreeCount; subTreeIndex++) {
            var child = parent.GetSubtree(subTreeIndex);
            if (!(child.Symbol is Constant) && nodeImpacts[child].IsAlmost(0.0)) {
              SwitchNodeWithReplacementNode(parent, subTreeIndex);
            }
          }
        }
      }
      PaintModel();
    }

    private void CalculateReplacementNodesAndNodeImpacts(ISymbolicExpressionTree tree) {
      var replacementValues = CalculateReplacementValues(tree);
      foreach (var pair in replacementValues.Where(pair => !(pair.Key is ConstantTreeNode))) {
        replacementNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
      }
      nodeImpacts = CalculateImpactValues(tree);

      if (!updateInProgress) {
        // automatically fold all branches with impact = 0
        List<ISymbolicExpressionTreeNode> nodeList = tree.Root.GetSubtree(0).IterateNodesPrefix().ToList();
        foreach (var parent in nodeList) {
          for (int subTreeIndex = 0; subTreeIndex < parent.SubtreeCount; subTreeIndex++) {
            var child = parent.GetSubtree(subTreeIndex);
            if (!(child.Symbol is Constant) && nodeImpacts[child].IsAlmost(0.0)) {
              SwitchNodeWithReplacementNode(parent, subTreeIndex);
            }
          }
        }
      }
      PaintModel();
    }

    private void PaintModel() {
      // show only interesting part of solution 
      this.treeChart.Tree = model.Root.SubtreeCount > 1 ? new SymbolicExpressionTree(model.Root) : new SymbolicExpressionTree(model.Root.GetSubtree(0).GetSubtree(0));
      this.PaintNodeImpacts();
    }

    protected abstract Dictionary<ISymbolicExpressionTreeNode, double> CalculateReplacementValues(ISymbolicExpressionTree tree);
    protected abstract Dictionary<ISymbolicExpressionTreeNode, double> CalculateImpactValues(ISymbolicExpressionTree tree);
    protected abstract void UpdateModel(ISymbolicExpressionTree tree);

    private ConstantTreeNode MakeConstantTreeNode(double value) {
      Constant constant = new Constant();
      constant.MinValue = value - 1;
      constant.MaxValue = value + 1;
      ConstantTreeNode constantTreeNode = (ConstantTreeNode)constant.CreateTreeNode();
      constantTreeNode.Value = value;
      return constantTreeNode;
    }

    private void treeChart_SymbolicExpressionTreeNodeDoubleClicked(object sender, MouseEventArgs e) {
      visualTreeNode = (VisualSymbolicExpressionTreeNode)sender;
      var tree = model;
      // check if the node value/weight has been altered
      // if so, the first double click will return the node to its original value/weight
      // the next double click will replace the ConstantNode with the original SymbolicExpressionTreeNode
      if (originalValues.ContainsKey(visualTreeNode.SymbolicExpressionTreeNode)) {
        double value = originalValues[visualTreeNode.SymbolicExpressionTreeNode];
        var subTree = visualTreeNode.SymbolicExpressionTreeNode;
        if (subTree.Symbol is Constant)
          (subTree as ConstantTreeNode).Value = value;
        else if (subTree.Symbol is Variable)
          (subTree as VariableTreeNode).Weight = value;
        originalValues.Remove(subTree);
        updateInProgress = true;
        UpdateModel(tree);
        updateInProgress = false;
        return;
      }

      foreach (SymbolicExpressionTreeNode treeNode in tree.IterateNodesPostfix()) {
        for (int i = 0; i < treeNode.SubtreeCount; i++) {
          ISymbolicExpressionTreeNode subTree = treeNode.GetSubtree(i);
          // only allow to replace nodes for which a replacement value is known (replacement value for ADF nodes are not available)
          if (subTree == visualTreeNode.SymbolicExpressionTreeNode && replacementNodes.ContainsKey(subTree)) {
            SwitchNodeWithReplacementNode(treeNode, i);

            // show only interesting part of solution 
            if (tree.Root.SubtreeCount > 1)
              this.treeChart.Tree = new SymbolicExpressionTree(tree.Root); // RPB + ADFs
            else
              this.treeChart.Tree = new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0)); // 1st child of RPB

            updateInProgress = true;
            UpdateModel(tree);
            updateInProgress = false;
            return; // break all loops
          }
        }
      }
    }

    private void treeChart_SymbolicExpressionTreeNodeClicked(object sender, MouseEventArgs e) {
      if (e.Button == MouseButtons.Right) {
        var node = (sender as VisualSymbolicExpressionTreeNode).SymbolicExpressionTreeNode;
        var menu = treeChart.ContextMenuStrip;

        bool flag = (node.Symbol is Constant || node.Symbol is Variable);

        ToolStripItem[] items = menu.Items.Find("changeValueToolStripMenuItem", false);
        ToolStripItem changeValueMenuItem = null;
        if (items.Any())
          changeValueMenuItem = items[0];
        if (changeValueMenuItem != null) {
          changeValueMenuItem.Enabled = flag;
          changeValueMenuItem.Visible = flag;
        }
      }
    }

    private void treeChart_SymbolicExpressionTreeNodeChanged(object sender, EventArgs e) {
      visualTreeNode = sender as VisualSymbolicExpressionTreeNode;
      var subTree = visualTreeNode.SymbolicExpressionTreeNode;
      string title = String.Empty;
      double value = 0.0;

      if (subTree.Symbol is Constant) {
        title = "Change Constant Value";
        value = (subTree as ConstantTreeNode).Value;
      } else if (subTree.Symbol is Variable) {
        title = "Change Weight Value";
        value = (subTree as VariableTreeNode).Weight;
      }

      double originalValue = value;

      if (!originalValues.ContainsKey(subTree))
        originalValues.Add(subTree, value);
      else originalValue = originalValues[subTree];

      var dialog = new ValueChangeDialog(title, Math.Round(originalValue, 4).ToString(), Math.Round(value, 4).ToString());
      dialog.NewValueTextBox.Validated += OnNewValueValidated;
      dialog.ShowDialog(this);
    }

    private void OnNewValueValidated(object sender, EventArgs e) {
      var textBox = sender as TextBox;
      var value = double.Parse(textBox.Text);
      var subTree = visualTreeNode.SymbolicExpressionTreeNode;

      if (subTree.Symbol is Constant)
        (subTree as ConstantTreeNode).Value = value;
      else if (subTree.Symbol is Variable)
        (subTree as VariableTreeNode).Weight = value;

      PaintModel();
    }

    private void SwitchNodeWithReplacementNode(ISymbolicExpressionTreeNode parent, int subTreeIndex) {
      ISymbolicExpressionTreeNode subTree = parent.GetSubtree(subTreeIndex);
      parent.RemoveSubtree(subTreeIndex);
      if (replacementNodes.ContainsKey(subTree)) {
        var replacementNode = replacementNodes[subTree];
        parent.InsertSubtree(subTreeIndex, replacementNode);
        // exchange key and value 
        replacementNodes.Remove(subTree);
        replacementNodes.Add(replacementNode, subTree);
      }
    }

    private void PaintNodeImpacts() {
      var impacts = nodeImpacts.Values;
      double max = impacts.Max();
      double min = impacts.Min();
      foreach (ISymbolicExpressionTreeNode treeNode in model.IterateNodesPostfix()) {
        VisualSymbolicExpressionTreeNode visualTree = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
        bool flag1 = replacementNodes.ContainsKey(treeNode);
        bool flag2 = originalValues.ContainsKey(treeNode);
        bool flag3 = treeNode is ConstantTreeNode;

        if (flag2) // constant or variable node was changed
          visualTree.ToolTip += Environment.NewLine + "Original value: " + originalValues[treeNode];
        else if (flag1 && flag3) // node was folded to a constant
          visualTree.ToolTip += Environment.NewLine + "Original node: " + replacementNodes[treeNode];

        if (!(treeNode is ConstantTreeNode) && nodeImpacts.ContainsKey(treeNode)) {
          double impact = nodeImpacts[treeNode];

          // impact = 0 if no change
          // impact < 0 if new solution is better
          // impact > 0 if new solution is worse
          if (impact < 0.0) {
            // min is guaranteed to be < 0
            visualTree.FillColor = Color.FromArgb((int)(impact / min * 255), Color.Red);
          } else if (impact.IsAlmost(0.0)) {
            visualTree.FillColor = Color.White;
          } else {
            // max is guaranteed to be > 0
            visualTree.FillColor = Color.FromArgb((int)(impact / max * 255), Color.Green);
          }
          visualTree.ToolTip += Environment.NewLine + "Node impact: " + impact;
          var constantReplacementNode = replacementNodes[treeNode] as ConstantTreeNode;
          if (constantReplacementNode != null) {
            visualTree.ToolTip += Environment.NewLine + "Replacement value: " + constantReplacementNode.Value;
          }
        }
      }
      this.PaintCollapsedNodes();
      this.treeChart.Repaint();
    }

    private void PaintCollapsedNodes() {
      foreach (ISymbolicExpressionTreeNode treeNode in model.IterateNodesPostfix()) {
        bool flag1 = replacementNodes.ContainsKey(treeNode);
        bool flag2 = originalValues.ContainsKey(treeNode);
        if (flag1 && treeNode is ConstantTreeNode) {
          this.treeChart.GetVisualSymbolicExpressionTreeNode(treeNode).LineColor = flag2 ? Color.DarkViolet : Color.DarkOrange;
        } else if (flag2) {
          this.treeChart.GetVisualSymbolicExpressionTreeNode(treeNode).LineColor = Color.DodgerBlue;
        }
      }
    }

    private void btnSimplify_Click(object sender, EventArgs e) {
      SymbolicDataAnalysisExpressionTreeSimplifier simplifier = new SymbolicDataAnalysisExpressionTreeSimplifier();
      var simplifiedExpressionTree = simplifier.Simplify(model);
      UpdateModel(simplifiedExpressionTree);
    }

    protected abstract void btnOptimizeConstants_Click(object sender, EventArgs e);

    private void btnPrune_Click(object sender, EventArgs e) {
      btnPrune.Enabled = false;
      backgroundWorker1.RunWorkerAsync();
    }

    private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) {
      var worker = sender as BackgroundWorker;
      PruneTree(worker);
    }

    private void PruneTree(BackgroundWorker worker) {
      var tree = model;
      // get all tree nodes 
      foreach (var node in GetNodesAtDepth(tree.Root, new Data.IntRange(2, tree.Depth))) {
        if (worker.CancellationPending)
          break; // pruning cancelled
        if (!(node.Symbol is Constant) && nodeImpacts.ContainsKey(node) && nodeImpacts[node] < 0.001) {
          SwitchNodeWithReplacementNode(node.Parent, node.Parent.IndexOfSubtree(node));
          nodeImpacts = CalculateImpactValues(tree);
          // we do not refresh the replacementValues because they won't change when folding nodes with such low impacts (<0.001)
        }
      }
    }

    private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
      if (e.Cancelled) {
        // The user canceled the operation.
      } else if (e.Error != null) {
        // There was an error during the operation.
        // Error-handling
      } else {
        // The operation completed normally. We can update the model
        UpdateModel(model);
      }
      btnPrune.Enabled = true;
    }

    #region helpers
    private static IEnumerable<ISymbolicExpressionTreeNode> GetNodesAtDepth(ISymbolicExpressionTreeNode root, Data.IntRange range) {
      var list = new List<Tuple<ISymbolicExpressionTreeNode, int>> { new Tuple<ISymbolicExpressionTreeNode, int>(root, 0) };
      int offset = 0;
      int level = 0;
      while (level < range.End) {
        ++level;
        int count = list.Count;
        for (int i = offset; i != count; ++i) {
          if (list[i].Item1.Subtrees.Any())
            list.AddRange(from s in list[i].Item1.Subtrees select new Tuple<ISymbolicExpressionTreeNode, int>(s, level));
        }
        offset = count;
      }
      // taking advantage of the fact that the list is already sorted by level
      for (int i = list.Count - 1; i >= 0; --i) {
        if (list[i].Item2 >= range.Start)
          yield return list[i].Item1;
        else break;
      }
    }
    #endregion
  }
}