source: branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/SymboldDataAnalysisGenealogyView.cs @ 10650

#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.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using HeuristicLab.Core.Views;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
using HeuristicLab.EvolutionTracking;
using HeuristicLab.EvolutionTracking.Views;
using HeuristicLab.MainForm;

using FragmentGraph = HeuristicLab.EvolutionTracking.IGenealogyGraph<HeuristicLab.EvolutionTracking.IFragment<HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.ISymbolicExpressionTreeNode>>;


using FragmentNode = HeuristicLab.EvolutionTracking.GenealogyGraphNode<HeuristicLab.EvolutionTracking.IFragment<HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.ISymbolicExpressionTreeNode>>;

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

    public SymboldDataAnalysisGenealogyView() {
      InitializeComponent();

      comparer = new SymbolicExpressionTreeNodeSimilarityComparer();
    }

    public new IGenealogyGraph<ISymbolicExpressionTree> Content {
      get { return (IGenealogyGraph<ISymbolicExpressionTree>)base.Content; }
      set { base.Content = value; }
    }

    #region event handlers

    protected override void OnContentChanged() {
      base.OnContentChanged();
      if (Content != null) {
        genealogyGraphChart.GenealogyGraph = Content;
      }
    }

    #endregion

    protected override void RegisterContentEvents() {
      genealogyGraphChart.GenealogyGraphNodeClicked += graphChart_GenealogyGraphNodeClicked;
      symbolicExpressionTreeChart.SymbolicExpressionTreeNodeClicked += treeChart_SymbolicExpressionNodeClicked;
      base.RegisterContentEvents();
    }

    protected override void DeregisterContentEvents() {
      base.DeregisterContentEvents();
      genealogyGraphChart.GenealogyGraphNodeClicked -= graphChart_GenealogyGraphNodeClicked;
      symbolicExpressionTreeChart.SymbolicExpressionTreeNodeClicked -= treeChart_SymbolicExpressionNodeClicked;
    }

    public void graphChart_GenealogyGraphNodeClicked(object sender, MouseEventArgs args) {
      var visualNode = (VisualGenealogyGraphNode)sender;
      var graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)visualNode.Data;
      var tree = graphNode.Content;
      symbolicExpressionTreeChart.Tree = tree;
    }

    public void treeChart_SymbolicExpressionNodeClicked(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);

      bool trace = genealogyGraphChart.TraceFragments; // check whether the mode is 'trace' or 'match'

      if (trace) {
        // perform fragment tracing
        var fragmentGraph = TraceSubtree(subtree);

        // find all the genealogy graph nodes that contain the building blocks which formed the currently selected subtree
        // this should maybe be limited to nodes of the ancestry (can be very computationally expensive)
        var vertices = from x in fragmentGraph.Nodes
                       let fragmentNode = (FragmentNode)x
                       let fragment = fragmentNode.Content
                       from y in Content.Nodes
                       let graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)y
                       let tree = graphNode.Content
                       where tree.Root.ContainsSubtree(fragment.Root, comparer)
                       select graphNode;

        graphChart_highlightMatchingVertices(vertices);
      } else {
        // perform matching like before
        var trees = Content.Nodes.Select(x => (ISymbolicExpressionTree)x.Content);
        var matchingTrees = trees.Where(x => x.Root.ContainsSubtree(subtree, comparer));

        var matchingVertices = matchingTrees.SelectMany(x => Content[x]).Cast<IGenealogyGraphNode<ISymbolicExpressionTree>>();
        graphChart_highlightMatchingVertices(matchingVertices);
      }
    }

    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) {
      foreach (var s in subtree.IterateNodesPrefix()) {
        var visualNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(s);
        visualNode.LineColor = Color.RoyalBlue;
        visualNode.FillColor = Color.LightBlue;

        foreach (var c in s.Subtrees) {
          var visualArc = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNodeConnection(s, c);
          visualArc.LineColor = Color.RoyalBlue;
        }
      }
      symbolicExpressionTreeChart.RepaintNodes();
    }

    #region events for configuring the behavior of the genealogy chart (trace/match, simple lineages, etc)
    private void trace_checkBox_CheckedChanged(object sender, System.EventArgs e) {
      genealogyGraphChart.TraceFragments = trace_checkBox.Checked;
    }

    private void simpleLineages_checkBox_CheckedChanged(object sender, System.EventArgs e) {
      genealogyGraphChart.SimpleLineages = simpleLineages_checkBox.Checked;
    }

    private void lockGraph_checkBox_CheckedChanged(object sender, System.EventArgs e) {
      genealogyGraphChart.LockGenealogy = lockGraph_checkBox.Checked;
    }
    #endregion

    #region fragment tracing
    private FragmentGraph TraceSubtree(ISymbolicExpressionTreeNode subtree) {
      var graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)genealogyGraphChart.SelectedGraphNode;
      var graph = new GenealogyGraph<IFragment<ISymbolicExpressionTreeNode>>();
      Trace(graphNode, subtree, graph);
      return graph;
    }

    private void Trace(IGenealogyGraphNode<ISymbolicExpressionTree> graphNode, ISymbolicExpressionTreeNode subtree, FragmentGraph fragmentGraph, FragmentNode fragmentNode = null) {
      // add the subtree as a vertex in the fragment graph
      var fn = new FragmentNode { Content = new Fragment<ISymbolicExpressionTreeNode> { Root = subtree }, Rank = graphNode.Rank };
      fragmentGraph.AddVertex(fn);

      // maybe we reached the end of the genealogy
      if (graphNode.InArcs == null) return;

      // the subtree must belong to the currently displayed tree which in turn must belong to the currently selected graph node
      var tree = graphNode.Content;
      var index = tree.IterateNodesPrefix().ToList().IndexOf(subtree);
      var length = subtree.GetLength();

      var fragment = (IFragment<ISymbolicExpressionTreeNode>)graphNode.InArcs.Last().Data;
      var fragmentLength = fragment.Root.GetLength();

      if (fragment.Index <= index && index < fragment.Index + fragmentLength) {
        // the selected subtree is contained by the fragment
        var fn1 = new FragmentNode { Content = fragment };
        if (fragmentNode != null) {
          AddChild(fragmentNode, fn1);
        }
        fragmentGraph.AddVertex(fn1);
        graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)graphNode.InArcs.Last().Source;
        subtree = graphNode.Content.IterateNodesPrefix().ToList()[fragment.OldIndex];
        Trace(graphNode, subtree, fragmentGraph, fn1);
      } else if (fragment.Index > index && fragment.Index < index + length) {
        // the selected subtree contains the fragment
        // first trace the fragment, then trace the subtree
        graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)graphNode.InArcs.Last().Source;
        subtree = graphNode.Content.IterateNodesPrefix().ToList()[fragment.OldIndex];

        var fn0 = new FragmentNode { Content = new Fragment<ISymbolicExpressionTreeNode> { Root = subtree } };
        var fn1 = new FragmentNode { Content = fragment };

        if (fragmentNode != null) {
          AddChild(fragmentNode, fn0);
          AddChild(fragmentNode, fn1);
        }
        fragmentGraph.AddVertex(fn0);
        fragmentGraph.AddVertex(fn1);

        var graphNode0 = (IGenealogyGraphNode<ISymbolicExpressionTree>)graphNode.InArcs[0].Source;
        var subtree0 = graphNode0.Content.IterateNodesPrefix().ToList()[index];
        Trace(graphNode0, subtree0, fragmentGraph, fn0);

        var graphNode1 = (IGenealogyGraphNode<ISymbolicExpressionTree>)graphNode.InArcs.Last().Source;
        var subtree1 = graphNode1.Content.IterateNodesPrefix().ToList()[fragment.OldIndex];
        Trace(graphNode1, subtree1, fragmentGraph, fn1);
      } else {
        // the fragment is not contained by the selected subtree, so we go one level up
        graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)graphNode.InArcs[0].Source;
        subtree = graphNode.Content.IterateNodesPrefix().ToList()[index];
        fragmentGraph.Clear(); // restart the trace one level up
        Trace(graphNode, subtree, fragmentGraph);
      }
    }

    private void AddChild(FragmentNode parent, FragmentNode child) {
      child.Rank = parent.Rank - 1;
      parent.AddForwardArc(child);
      child.AddReverseArc(parent);
    }
    #endregion
  }
}