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

#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.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);

        // open a FragmentGraphView displaying this fragmentGraph
      } else {
        // perform matching like it was done before
        // currently there is no possibility to specify the subtree matching criteria
        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 parentNode = null) {
      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();


      // below, we consider three cases:
      // 1) the selected subtree is the same as the fragment
      // 2) the fragment contains the selected subtree
      // 3) the fragment is contained by the selected subtree
      // In each case, the idea is to isolate and individually track the fragment and the rest of the subtree (for cases 2 and 3)
      if (fragment.Index == index) {
        // the selected subtree is the actual fragment
        if (fragmentLength != length) throw new Exception("Fragment and subtree lengths should be the same!");

        var node = new FragmentNode { Content = fragment, Rank = graphNode.Rank };

        if (parentNode != null) {
          AddChild(parentNode, node);
        }

        fragmentGraph.AddVertex(node);

        graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)graphNode.InArcs.Last().Source;
        subtree = graphNode.Content.IterateNodesPrefix().ToList()[fragment.OldIndex];
        Trace(graphNode, subtree, fragmentGraph, node);
      } else if (fragment.Index < index && index < fragment.Index + fragmentLength) {
        // the fragment contains the selected subtree 
        if (length >= fragmentLength) throw new Exception("Fragment contains subtree, so subtree length should be less than the fragment length.");

        var node = new FragmentNode { Content = fragment, Rank = graphNode.Rank };
        if (parentNode != null) {
          AddChild(parentNode, node);
        }

        fragmentGraph.AddVertex(node);

        graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)graphNode.InArcs.Last().Source;
        var i = fragment.Root.IterateNodesPrefix().ToList().IndexOf(subtree);
        subtree = graphNode.Content.IterateNodesPrefix().ToList()[fragment.OldIndex + i];
        Trace(graphNode, subtree, fragmentGraph, node);

      } else if (index < fragment.Index && fragment.Index < index + length) {
        // the selected subtree contains the fragment
        if (fragmentLength >= length) throw new Exception("Subtree contains fragment, so fragment length should be less than the subtree length.");

        var node = new FragmentNode { Content = new Fragment<ISymbolicExpressionTreeNode> { Root = subtree }, Rank = graphNode.Rank };

        if (parentNode != null) {
          AddChild(parentNode, node);
        }
        fragmentGraph.AddVertex(node);

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

        if (graphNode.InArcs.Count > 1) {
          var graphNode1 = (IGenealogyGraphNode<ISymbolicExpressionTree>)graphNode.InArcs[1].Source;
          var subtree1 = graphNode1.Content.IterateNodesPrefix().ToList()[fragment.OldIndex];
          Trace(graphNode1, subtree1, fragmentGraph, node);
        }
      }
    }

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