source: branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphView.cs @ 9239

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 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.MainForm;
using HeuristicLab.Problems.DataAnalysis.Symbolic;
using HeuristicLab.Visualization;

namespace HeuristicLab.EvolutionaryTracking.Views {
  [View("SymbolicExpressionTreeGenealogyGraph")]
  [Content(typeof(SymbolicExpressionTreeGenealogyGraph), IsDefaultView = true)]
  public sealed partial class GenealogyGraphView : ItemView {
    private VisualSymbolicExpressionTreeNode selectedVisualSymbExprTreeNode;
    private SymbolicExpressionTreeNodeSimilarityComparer comparer;
    private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> clonedNodes;

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

    public GenealogyGraphView()
      : base() {
      InitializeComponent();
      // set button icons here because if set in the designer file, they get overwritten
      this.moveModeButton.Image = Common.Resources.VSImageLibrary.Pointer;
      this.zoomModeButton.Image = Common.Resources.VSImageLibrary.Zoom;
      this.selectModeButton.Image = Common.Resources.VSImageLibrary.Object;
      comparer = new SymbolicExpressionTreeNodeSimilarityComparer {
        MatchConstantValues = true,
        MatchVariableWeights = true,
        MatchVariableNames = true
      };
    }

    protected override void DeregisterContentEvents() {
      // TODO: Deregister your event handlers here
      genealogyGraphChart.GenealogyGraphNodeClicked -= graphChart_GenealogyGraphNodeClicked;
      symbolicExpressionTreeChart.SymbolicExpressionTreeNodeClicked -= treeChart_SymbolicExpressionTreeNodeClicked;
      base.DeregisterContentEvents();
    }

    protected override void RegisterContentEvents() {
      base.RegisterContentEvents();
      // TODO: Register your event handlers here
      genealogyGraphChart.GenealogyGraphNodeClicked += graphChart_GenealogyGraphNodeClicked;
      symbolicExpressionTreeChart.SymbolicExpressionTreeNodeClicked += treeChart_SymbolicExpressionTreeNodeClicked;
      symbolicExpressionTreeChart.SymbolicExpressionTreeNodeDoubleClicked += treeChart_SymbolicExpressionTreeNodeDoubleClicked;
    }

    #region Event Handlers (Content)
    // TODO: Put event handlers of the content here
    protected override void OnContentChanged() {
      base.OnContentChanged();
      if (Content == null)
        genealogyGraphChart.Graph = null;
      else {
        genealogyGraphChart.Graph = Content;
        var best = Content.Nodes.OrderByDescending(x => x.Quality).First();
        symbolicExpressionTreeChart.Tree = best.SymbolicExpressionTree;
      }
    }

    private void Content_GraphChanged(object sender, EventArgs e) {
    }

    protected override void SetEnabledStateOfControls() {
      base.SetEnabledStateOfControls();
      genealogyGraphChart.Enabled = Content != null;
    }
    #endregion

    #region Event Handlers (child controls)

    // TODO: Put event handlers of child controls here.
    private void graphChart_GenealogyGraphNodeClicked(object sender, MouseEventArgs e) {
      // the type hierarchy goes like this: VisualGenealogyGraphNode --> GenealogyGraphNode --> SymbolicExpressionTree
      var visualGenealogyGraphNode = (VisualGenealogyGraphNode)sender;
      var genealogyGraphNode = visualGenealogyGraphNode.Data;
      symbolicExpressionTreeChart.Tree = genealogyGraphNode.SymbolicExpressionTree;
      if (genealogyGraphNode.InEdges == null) return;
      var arc = genealogyGraphNode.InEdges.First(x => x.Source != x.Target && x.Data != null);
      if (arc == null) return;
      var fragment = (IFragment)arc.Data;
      if (fragment.Root == null) return;
      foreach (var node in fragment.Root.IterateNodesBreadth()) {
        var visualSymbExprTreeNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
        visualSymbExprTreeNode.LineColor = Color.OrangeRed;
      }
      symbolicExpressionTreeChart.Repaint(); // pain orange nodes
    }

    private void moveModeButton_CheckedChanged(object sender, EventArgs e) {
      var btn = (RadioButton)sender;
      if (btn.Checked) { genealogyGraphChart.Chart.Mode = ChartMode.Move; }
    }

    private void zoomModeButton_CheckedChanged(object sender, EventArgs e) {
      var btn = (RadioButton)sender;
      if (btn.Checked) { genealogyGraphChart.Chart.Mode = ChartMode.Zoom; }
    }

    private void selectModeButton_CheckedChanged(object sender, EventArgs e) {
      var btn = (RadioButton)sender;
      if (btn.Checked) { genealogyGraphChart.Chart.Mode = ChartMode.Select; }
    }

    private void treeChart_SymbolicExpressionTreeNodeClicked(object sender, MouseEventArgs e) {
      genealogyGraphChart.Chart.UpdateEnabled = false;
      switch (e.Button) {
        case MouseButtons.Left: {
            selectedVisualSymbExprTreeNode = (VisualSymbolicExpressionTreeNode)sender;
            if (selectedVisualSymbExprTreeNode == null) return;
            ISymbolicExpressionTreeNode selectedSubtree = selectedVisualSymbExprTreeNode.SymbolicExpressionTreeNode;
            var clonedSubtree = (ISymbolicExpressionTreeNode)selectedSubtree.Clone();
            // map original nodes to cloned nodes
            clonedNodes = selectedSubtree.IterateNodesPrefix()
                                         .Zip(clonedSubtree.IterateNodesPrefix(), (original, clone) => new { original, clone })
                                         .ToDictionary(p => p.original, p => p.clone);

            foreach (var node in symbolicExpressionTreeChart.Tree.IterateNodesPrefix()) {
              symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node).FillColor = Color.Transparent;
            }
            foreach (var node in selectedSubtree.IterateNodesPrefix()) {
              symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node).FillColor = Color.LightBlue;
            }
            break;
          }
        case MouseButtons.Middle: {
            var visualNode = (VisualSymbolicExpressionTreeNode)sender;
            if (selectedVisualSymbExprTreeNode == null || selectedVisualSymbExprTreeNode == visualNode) return;
            var selectedNode = visualNode.SymbolicExpressionTreeNode;
            if (clonedNodes.ContainsKey(selectedNode)) {
              var selectedClone = clonedNodes[selectedNode];
              var parent = selectedClone.Parent;
              parent.RemoveSubtree(parent.IndexOfSubtree(selectedClone));
              foreach (var node in selectedNode.IterateNodesPrefix()) {
                symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node).FillColor = Color.Transparent;
              }
            }
            break;
          }
      }
      if (selectedVisualSymbExprTreeNode == null || clonedNodes == null) return;
      // update visual graph nodes that contain matching trees
      MatchNodesAndRepaint();
      // refresh the tree chart
      symbolicExpressionTreeChart.Repaint();
    }

    void MatchNodesAndRepaint() {
      genealogyGraphChart.Chart.UpdateEnabled = false;
      genealogyGraphChart.ClearAllNodes(); // clear node colors
      var fragment = new Fragment(clonedNodes[selectedVisualSymbExprTreeNode.SymbolicExpressionTreeNode]);
      var fragmentLength = fragment.Length;
      genealogyGraphChart.HighlightNodes(from node in genealogyGraphChart.Graph.Nodes
                                         let tree = node.SymbolicExpressionTree
                                         where tree.Length >= fragmentLength
                                         where tree.Root.ContainsFragment(fragment, comparer)
                                         select tree, Color.DodgerBlue);
      genealogyGraphChart.Chart.UpdateEnabled = true;
      genealogyGraphChart.Chart.EnforceUpdate();
    }

    private void treeChart_SymbolicExpressionTreeNodeDoubleClicked(object sender, MouseEventArgs e) {
    }
    #endregion
    private void matchConstantsCheckBox_CheckedChanged(object sender, EventArgs e) {
      comparer.MatchConstantValues = matchConstantsCheckBox.Checked;
      if (selectedVisualSymbExprTreeNode != null)
        MatchNodesAndRepaint();
    }

    private void matchVariableWeightsCheckBox_CheckedChanged(object sender, EventArgs e) {
      comparer.MatchVariableWeights = matchVariableWeightsCheckBox.Checked;
      if (selectedVisualSymbExprTreeNode != null)
        MatchNodesAndRepaint();
    }

    private void matchVariableNamesCheckBox_CheckedChanged(object sender, EventArgs e) {
      comparer.MatchVariableNames = matchVariableNamesCheckBox.Checked;
      if (selectedVisualSymbExprTreeNode != null)
        MatchNodesAndRepaint();
    }
  }
}