source: branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Tracking/SymbolicDataAnalysisGenealogyGraphView.cs @ 12231

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

namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
  [View("SymbolicDataAnalysisGenealogyGraphView")]
  [Content(typeof(IGenealogyGraph<ISymbolicExpressionTree>), IsDefaultView = true)]
  public partial class SymbolicDataAnalysisGenealogyGraphView : SymbolicDataAnalysisGenealogyGraphViewDesignable {
    private readonly ISymbolicExpressionTreeNodeEqualityComparer comparer;

    private ISymbolicExpressionTreeNode selectedSubtree;
    private ISymbolicExpressionTreeNode SelectedSubtree {
      get { return selectedSubtree; }
      set {
        if (value == null || selectedSubtree == value) return;
        selectedSubtree = value;
        ClonedSubtree = (ISymbolicExpressionTreeNode)selectedSubtree.Clone();
      }
    }
    // the clone is necessary in order to deselect parts of a tree (by removing subtrees) 
    // and do "high level" matching of the remaining part
    private ISymbolicExpressionTreeNode ClonedSubtree { get; set; }

    // we use the symbolic expression tree chart to call the drawing routines
    // and highlight relevant tree parts
    public SymbolicExpressionTreeChart SymbolicExpressionTreeChart {
      get {
        var view = (GraphicalSymbolicExpressionTreeView)base.viewHost.ActiveView;
        return view == null ? null : view.SymbolicExpressionTreeChart;
      }
    }

    public SymbolicDataAnalysisGenealogyGraphView() {
      InitializeComponent();
      comparer = new SymbolicExpressionTreeNodeEqualityComparer();
      viewHost.ViewType = typeof(GraphicalSymbolicExpressionTreeView);
    }
    #region event handlers
    protected override void OnContentChanged() {
      base.OnContentChanged();
      if (Content != null && Content != genealogyGraphChart.GenealogyGraph) {
        genealogyGraphChart.GenealogyGraph = Content;
      }
    }

    public override void graphChart_GenealogyGraphNodeClicked(object sender, MouseEventArgs args) {
      base.graphChart_GenealogyGraphNodeClicked(sender, args);
      var visualNode = (VisualGenealogyGraphNode)sender;
      var graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)visualNode.Data;

      nodeQualityLabel.Text = String.Format("{0:0.000}", graphNode.Quality);
      nodeRankLabel.Text = String.Format("{0:0.0}", graphNode.Rank);
      nodeDegreeLabel.Text = String.Format("{0} / {1}", graphNode.InDegree, graphNode.OutDegree);
      nodeWeightLabel.Text = String.Format("{0:0.00}", graphNode.Weight);

      if (openNew_CheckBox.Checked) {
        // get the ancestors into a new view
        var cloner = new Cloner();
        // clone arcs and vertices and use them to create a new graph 
        // that will include just the individual and its ancestors
        var graph = new GenealogyGraph<ISymbolicExpressionTree>();
        var ancestors = new[] { graphNode }.Concat(graphNode.Ancestors).ToList();
        graph.AddVertices(ancestors.Select(cloner.Clone));
        graph.AddArcs(ancestors.SelectMany(x => x.InArcs).Select(cloner.Clone));
        MainFormManager.MainForm.ShowContent(graph);
      }

      if (graphNode.InArcs.Any()) {
        var data = graphNode.InArcs.Last().Data;
        var fragment = data as IFragment<ISymbolicExpressionTreeNode>;
        var td = data as TraceData;
        //        double max = Content.Vertices.Max(x => x.Data.IterateNodesPrefix().Max(y => y.NodeWeight));

        // calculate max only in the current generation
        double max = Content.GetByRank(graphNode.Rank).Max(x => ((IGenealogyGraphNode<ISymbolicExpressionTree>)x).Data.IterateNodesPrefix().Max(y => y.NodeWeight));
        if (max.IsAlmost(0)) max = 1;
        int c = ColorGradient.Colors.Count - 1;
        const int alpha = 100;
        if (fragment != null) {
          // highlight the fragment with a blue line color
          foreach (var n in graphNode.Data.NodeAt(fragment.Index1).IterateNodesPrefix()) {
            treeChart_HighlightSubtree(n, Color.CornflowerBlue);
          }
          // highlight all the nodes according to their sample count
          var nodes = graphNode.Data.IterateNodesPrefix().ToList();
          foreach (var n in nodes.Skip(1)) {
            var i = (int)Math.Round(n.NodeWeight / max * c);
            var fillColor = Color.FromArgb(alpha, ColorGradient.Colors[i]);
            treeChart_HighlightSubtree(n, null, fillColor);
          }
        } else if (td != null) {
          var nodes = graphNode.Data.IterateNodesPrefix().ToList();
          foreach (var n in nodes.Skip(1)) { // skip program root symbol 
            var i = (int)Math.Round(n.NodeWeight / max * c);
            var fillColor = Color.FromArgb(alpha, ColorGradient.Colors[i]);
            treeChart_HighlightSubtree(n, null, fillColor);
          }
          treeChart_HighlightSubtree(nodes[td.LastSubtreeIndex], Color.Orange);
          treeChart_HighlightSubtree(nodes[td.LastFragmentIndex], Color.CornflowerBlue);
        }
      }
    }

    public void treeChart_SymbolicExpressionTreeNodeClicked(object sender, MouseEventArgs args) {
      var visualNode = (VisualTreeNode<ISymbolicExpressionTreeNode>)sender;
      var subtree = visualNode.Content;
      // highlight the selected subtree inside the displayed tree on the right hand side
      treeChart_ClearColors();
      treeChart_HighlightSubtree(subtree, Color.Black, Color.RoyalBlue);

      bool trace = genealogyGraphChart.TraceFragments; // check whether we are in 'trace' or 'match' mode

      switch (args.Button) {
        case MouseButtons.Left: {
            SelectedSubtree = subtree;
            if (trace) {
              // TODO: maybe highlight based on per generation maximum
              double max = Content.Vertices.Max(x => x.Data.IterateNodesPrefix().Average(y => y.NodeWeight));
              // perform fragment tracing
              var graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)genealogyGraphChart.SelectedGraphNode;
              var subtreeIndex = graphNode.Data.IterateNodesPrefix().ToList().IndexOf(subtree);
              var traceGraph = TraceCalculator.TraceSubtree(graphNode, subtreeIndex, updateVertexWeights: false, updateSubtreeWeights: false, cacheTraceNodes: true);
              if (traceGraph.Vertices.Any()) {
                var vertices = traceGraph.Vertices.Select(x => Content.GetByContent(x.Data));
                genealogyGraphChart.UpdateEnabled = false;
                genealogyGraphChart.ClearPrimitives();
                foreach (var v in vertices) {
                  var vNode = genealogyGraphChart.GetMappedNode(v);
                  var wSum = v.Data.IterateNodesPrefix().Average(x => x.NodeWeight);
                  // use a grayscal gradient
                  var color = ColorGradient.GrayscaledColors[(int)Math.Round(wSum / max * (ColorGradient.GrayscaledColors.Count - 1))];
                  vNode.Brush = new SolidBrush(color);
                }
                genealogyGraphChart.UpdateEnabled = true;
                genealogyGraphChart.EnforceUpdate();

                if (openNew_CheckBox.Checked) {
                  MainFormManager.MainForm.ShowContent(traceGraph); // display the fragment graph on the screen
                }
              }
            } else {
              // perform matching like it was done before
              // currently there is no possibility to specify the subtree matching criteria
              var trees = Content.Vertices.Select(x => x.Data);
              var matchingTrees = trees.Where(x => x.Root.ContainsSubtree(subtree, comparer));

              var matchingVertices = matchingTrees.Select(x => Content.GetByContent(x));
              graphChart_HighlightMatchingVertices(matchingVertices);
            }
            break;
          }
        case MouseButtons.Middle: {
            var index = SelectedSubtree.IterateNodesPrefix().ToList().IndexOf(subtree);
            if (index > 0) {
              var s = ClonedSubtree.NodeAt(index);
              s.Parent.RemoveSubtree(s.Parent.IndexOfSubtree(s));

              var trees = Content.Vertices.Select(x => x.Data);
              var matchingTrees = trees.Where(x => x.Root.ContainsSubtree(ClonedSubtree, comparer));

              var matchingVertices = matchingTrees.Select(x => Content.GetByContent(x));
              treeChart_HighlightSubtree(subtree, Color.Black, Color.White);
              graphChart_HighlightMatchingVertices(matchingVertices);
            }
            break;
          }
      }
    }
    #endregion

    protected override void RegisterContentEvents() {
      base.RegisterContentEvents();
      if (SymbolicExpressionTreeChart != null)
        SymbolicExpressionTreeChart.SymbolicExpressionTreeNodeClicked += treeChart_SymbolicExpressionTreeNodeClicked;
    }

    protected override void DeregisterContentEvents() {
      if (SymbolicExpressionTreeChart != null)
        SymbolicExpressionTreeChart.SymbolicExpressionTreeNodeClicked -= treeChart_SymbolicExpressionTreeNodeClicked;
      base.DeregisterContentEvents();
    }

    private void graphChart_HighlightMatchingVertices(IEnumerable<IGenealogyGraphNode> vertices) {
      genealogyGraphChart.Chart.UpdateEnabled = false;
      genealogyGraphChart.ClearPrimitives();
      genealogyGraphChart.HighlightNodes(vertices);
      genealogyGraphChart.Chart.UpdateEnabled = true;
      genealogyGraphChart.Chart.EnforceUpdate();
    }

    private void treeChart_ClearColors() {
      foreach (var node in SymbolicExpressionTreeChart.Tree.IterateNodesPrefix()) {
        var visualNode = SymbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
        if (visualNode != null) {
          visualNode.LineColor = Color.Black;
          visualNode.FillColor = Color.Transparent;
        }
      }
      SymbolicExpressionTreeChart.RepaintNodes();
    }

    private void treeChart_HighlightSubtree(ISymbolicExpressionTreeNode subtree, Color? lineColor = null, Color? fillColor = null) {
      if (lineColor == null && fillColor == null)
        return;

      foreach (var s in subtree.IterateNodesPrefix()) {
        var visualNode = SymbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(s);
        if (lineColor != null) {
          visualNode.LineColor = (Color)lineColor;
          foreach (var c in s.Subtrees) {
            var visualArc = SymbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNodeConnection(s, c);
            visualArc.LineColor = (Color)lineColor;
          }
        }
        if (fillColor != null)
          visualNode.FillColor = (Color)fillColor;
      }
      SymbolicExpressionTreeChart.RepaintNodes();
    }

    #region navigate the genealogy / trace graph
    private void navigateLeftButton_Click(object sender, EventArgs e) {
      var graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)genealogyGraphChart.SelectedGraphNode;
      var inArcs = (List<IArc>)((IVertex)graphNode).InArcs;
      if (inArcs.Count > 0) {
        genealogyGraphChart.SelectedGraphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)inArcs[0].Source;
      }
    }

    private void navigateRightButton_Click(object sender, EventArgs e) {
      var graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)genealogyGraphChart.SelectedGraphNode;
      var inArcs = graphNode.InArcs.ToList();
      if (inArcs.Count > 0) {
        var data = inArcs.Last().Data;
        var fragment = (data as IFragment<ISymbolicExpressionTreeNode>);
        var td = data as TraceData;
        if (fragment != null) {
          genealogyGraphChart.SelectedGraphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)inArcs.Last().Source;
        } else if (td != null) {
          if (inArcs.Count == 1) {
            genealogyGraphChart.SelectedGraphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)inArcs[0].Source;
            return;
          }
          // the first arc from inArcs will always represent the connection to the root parent
          // (tracing the body of the traced subtree)
          // therefore, in order to follow the correct non-root parent, we have to find the correct arc
          // But, the FragmentIndex recorded in the TraceData of the first arc has to match the SubtreeIndex recorded in the TraceData of the searched arc
          td = (TraceData)inArcs[0].Data;
          var f1 = (graphNode.Data).NodeAt(td.LastFragmentIndex);
          for (int i = 1; i < inArcs.Count; ++i) {
            td = (TraceData)inArcs[i].Data;
            var f2 = ((IGenealogyGraphNode<ISymbolicExpressionTree>)inArcs[i].Source).Data.NodeAt(td.SubtreeIndex);
            // if the subtrees are the same we have found a match
            // note: this is not necessarily 100% correct if in the trace graph we have identical fragments on different arcs
            if (f1.Difference(f2) == null) {
              genealogyGraphChart.SelectedGraphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)inArcs[i].Source;
              return;
            }
          }
          throw new InvalidOperationException("Error calculating the next step.");
        }
      }
    }
    #endregion
  }

  // bogus class needed in order to be able to "design" the view
  public class SymbolicDataAnalysisGenealogyGraphViewDesignable : GenealogyGraphView<ISymbolicExpressionTree> { }

  #region helper methods
  internal static class Util {
    internal static ISymbolicExpressionTreeNode NodeAt(this ISymbolicExpressionTree tree, int position) {
      return NodeAt(tree.Root, position);
    }
    internal static ISymbolicExpressionTreeNode NodeAt(this ISymbolicExpressionTreeNode root, int position) {
      return root.IterateNodesPrefix().ElementAt(position);
    }
  }
  #endregion
}