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

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

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;
      genealogyGraphChart.GenealogyGraphNodeDoubleClicked += graphChart_GenealogyGraphNodeDoubleClicked;
      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.Data;
      symbolicExpressionTreeChart.Tree = tree;
      if (graphNode.InArcs.Any()) {
        var fragment = graphNode.InArcs.Last().Data as IFragment<ISymbolicExpressionTreeNode>;
        if (fragment != null) {
          treeChart_HighlightSubtree(graphNode.Data.NodeAt(fragment.Index1));
        }
      }
      if (graphNode.OutArcs.Any()) {
        var td = graphNode.OutArcs.Last().Data as Tuple<int, int, int, int>;
        if (td != null) {
          var s = graphNode.Data.NodeAt(td.Item3); // subtree index
          var f = graphNode.Data.NodeAt(td.Item4); // fragment index 
          treeChart_HighlightSubtree(s, Color.Orange);
          treeChart_HighlightSubtree(f, Color.RoyalBlue);
        }
      }
    }

    public void graphChart_GenealogyGraphNodeDoubleClicked(object sender, MouseEventArgs arcs) {
      var visualNode = (VisualGenealogyGraphNode)sender;
      var graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)visualNode.Data;
      //      var tree = graphNode.Data;
      //      var model = new RegressionModel();
      //      var solution = new RegressionSolution()
      //      MainFormManager.MainForm.ShowContent(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 graphNode = (IGenealogyGraphNode<ISymbolicExpressionTree>)genealogyGraphChart.SelectedGraphNode;
        var subtreeIndex = graphNode.Data.IterateNodesPrefix().ToList().IndexOf(subtree);
        var fragmentGraph = SymbolicDataAnalysisExpressionTracing.TraceSubtree(graphNode, subtreeIndex);

        if (fragmentGraph.Vertices.Any()) {
          var genealogyNodes = fragmentGraph.Vertices.Select(v => Content.GetByContent(v.Data));
          genealogyGraphChart.HighlightNodes(genealogyNodes);
          foreach (var a in fragmentGraph.Arcs) {
            genealogyGraphChart.HighlightArc(Content.GetByContent(a.Target.Data), Content.GetByContent(a.Source.Data));
          }
          MainFormManager.MainForm.ShowContent(fragmentGraph); // 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);
      }
    }

    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? color = null) {
      Color myColor = color == null ? Color.RoyalBlue : (Color)color;
      foreach (var s in subtree.IterateNodesPrefix()) {
        var visualNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(s);
        visualNode.LineColor = myColor;
        //        visualNode.FillColor = myColor;

        foreach (var c in s.Subtrees) {
          var visualArc = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNodeConnection(s, c);
          visualArc.LineColor = myColor;
        }
      }
      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

    private void hotPaths_button_Click(object sender, System.EventArgs e) {
      genealogyGraphChart.HighlightHotPaths();
    }
  }
}