Changeset 8556 for branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphView.cs

Timestamp:

09/03/12 15:09:52 (12 years ago)

Author:

bburlacu

Message:

#1772: Modified genealogy graph chart and view to reflect changes in the class hierarchy.

File:

• branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphView.cs (modified) (6 diffs)

branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphView.cs

@@ -36 +36 @@
   [Content(typeof(SymbolicExpressionTreeGenealogyGraph), IsDefaultView = true)]
   public sealed partial class GenealogyGraphView : ItemView {
-    private VisualSymbolicExpressionTreeNode _selectedVisualSymbolicExpressionTreeNode;
-
+    private VisualSymbolicExpressionTreeNode selectedVisualSymbExprTreeNode;
     public new SymbolicExpressionTreeGenealogyGraph Content {
       get { return (SymbolicExpressionTreeGenealogyGraph)base.Content; }
@@ -43 +42 @@
     }
 
+    private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> clonedNodeMap;
+
     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;
+
+
       similarityModeSelector.SelectedIndex = 0; // set default similarity mode to "exact"
     }
@@ -61 +68 @@
       genealogyGraphChart.GenealogyGraphNodeClicked += graphChart_GenealogyGraphNodeClicked;
       symbolicExpressionTreeChart.SymbolicExpressionTreeNodeClicked += treeChart_SymbolicExpressionTreeNodeClicked;
+      symbolicExpressionTreeChart.SymbolicExpressionTreeNodeDoubleClicked += treeChart_SymbolicExpressionTreeNodeDoubleClicked;
     }
 
@@ -71 +79 @@
       else {
         genealogyGraphChart.Graph = Content;
-        var best = Content.Values.OrderByDescending(x => genealogyGraphChart.Graph[x].Quality).First();
-        symbolicExpressionTreeChart.Tree = (ISymbolicExpressionTree)best.Data;
+        var best = Content.Nodes.OrderByDescending(x => x.Quality).First();
+        symbolicExpressionTreeChart.Tree = best.SymbolicExpressionTree;
       }
     }
@@ -91 +99 @@
       // the type hierarchy goes like this: VisualGenealogyGraphNode --> GenealogyGraphNode --> symbolicExpressionTree
       var visualGenealogyGraphNode = (VisualGenealogyGraphNode)sender;
-      var genealogyGraphNode = (GenealogyGraphNode)visualGenealogyGraphNode.Data;
-      symbolicExpressionTreeChart.Tree = (ISymbolicExpressionTree)genealogyGraphNode.Data;
+      var genealogyGraphNode = (SymbolicExpressionGenealogyGraphNode)visualGenealogyGraphNode.Data;
+      symbolicExpressionTreeChart.Tree = genealogyGraphNode.SymbolicExpressionTree;
       // highlight the relevant fragment in the symbolic expression tree
-      if (_selectedVisualSymbolicExpressionTreeNode != null) {
+      selectedVisualSymbExprTreeNode = null;
+
+      bool repaint = false;
+
+      // paint highlighted nodes in symbolic expression tree
+      if (selectedVisualSymbExprTreeNode != null) {
+        // clear selected subtree from the tree chart
         var nodes = symbolicExpressionTreeChart.Tree.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
-        var fragments = _selectedVisualSymbolicExpressionTreeNode.SymbolicExpressionTreeNode.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
-        int index = SymbolicExpressionTreeMatching.FindMatch(nodes, fragments, similarityModeSelector.SelectedIndex);
+        var fragments = selectedVisualSymbExprTreeNode.SymbolicExpressionTreeNode.IterateNodesBreadth() as List<ISymbolicExpressionTreeNode>;
+        var similarityLevel = Enum.GetNames(typeof(SimilarityLevel))[similarityModeSelector.SelectedIndex];
+        int index = SymbolicExpressionTreeMatching.FindMatch(nodes, fragments, (SimilarityLevel)Enum.Parse(typeof(SimilarityLevel), similarityLevel));
         if (index != -1) {
-          _selectedVisualSymbolicExpressionTreeNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(nodes[index]);
-          var subtree = _selectedVisualSymbolicExpressionTreeNode.SymbolicExpressionTreeNode;
-          foreach (var visualNode in subtree.IterateNodesBreadth().Select(node => symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node))) {
-            visualNode.FillColor = Color.LightBlue;
-          }
-          symbolicExpressionTreeChart.Repaint();
+          selectedVisualSymbExprTreeNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(nodes[index]);
+          var subtree = selectedVisualSymbExprTreeNode.SymbolicExpressionTreeNode;
+          foreach (var node in subtree.IterateNodesBreadth()) {
+            var visualNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
+            visualNode.LineColor = Color.Blue;
+          }
+          repaint = true;
         }
       }
+      // paint graph nodes
       var tree = symbolicExpressionTreeChart.Tree;
-      var graphNode = Content.GetNode(tree);
-      if (graphNode.InEdges != null) {
-        var arc = graphNode.InEdges.Find(a => a.Data != null);
-        if (arc != null) {
-          var fragment = arc.Data as ISymbolicExpressionTreeNode;
-          foreach (var node in fragment.IterateNodesBreadth()) {
-            var visualNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
-            if (visualNode == null)
-              continue;
-            visualNode.FillColor = Color.LightGreen;
-          }
-          symbolicExpressionTreeChart.Repaint();
-        }
-      }
+      var graphNodes = Content.Nodes.Where(n => n.SymbolicExpressionTree == tree).ToList();
+      if (graphNodes.Count > 0) {
+        foreach (var graphNode in graphNodes)
+          if (graphNode != null && graphNode.InEdges != null) {
+            var arc = graphNode.InEdges.Find(a => a.Data != null);
+            if (arc != null) {
+              var fragment = arc.Data as ISymbolicExpressionTreeNode;
+              foreach (var node in fragment.IterateNodesBreadth()) {
+                var visualNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
+                if (visualNode == null)
+                  continue;
+                visualNode.LineColor = Color.Orange;
+              }
+            }
+            repaint = true;
+          }
+      }
+      if (repaint)
+        symbolicExpressionTreeChart.Repaint();
     }
 
@@ -140 +162 @@
 
     private void treeChart_SymbolicExpressionTreeNodeClicked(object sender, MouseEventArgs e) {
-      _selectedVisualSymbolicExpressionTreeNode = (VisualSymbolicExpressionTreeNode)sender;
-      // find out which individuals in the genealogy graph contain this specific subtree
-      var treeNode = _selectedVisualSymbolicExpressionTreeNode.SymbolicExpressionTreeNode;
+      ISymbolicExpressionTreeNode selectedSubtree = null;
+      genealogyGraphChart.Chart.UpdateEnabled = false;
+      switch (e.Button) {
+        case MouseButtons.Left: {
+            selectedVisualSymbExprTreeNode = (VisualSymbolicExpressionTreeNode)sender;
+            if (selectedVisualSymbExprTreeNode == null) return;
+            // find out which individuals in the genealogy graph contain this specific subtree
+            selectedSubtree = selectedVisualSymbExprTreeNode.SymbolicExpressionTreeNode;
+            // clone every node in the selected subtree so that edit operations are possible without altering the original subtree
+            // save the originalNode-->clone mapping to make it easier to work with subtrees
+            if (clonedNodeMap == null)
+              clonedNodeMap = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
+            clonedNodeMap.Clear();
+            var selectedSubtreeClone = selectedSubtree.Clone() as SymbolicExpressionTreeNode;
+            var subtreeNodes = selectedSubtree.IterateNodesPostfix().ToList();
+            var cloneNodes = selectedSubtreeClone.IterateNodesPostfix().ToList();
+            for (int i = 0; i != subtreeNodes.Count; ++i)
+              clonedNodeMap.Add(subtreeNodes[i], cloneNodes[i]);
+            // highlight subtree nodes in the tree chart
+            foreach (var node in symbolicExpressionTreeChart.Tree.IterateNodesPostfix()) {
+              var visualNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
+              visualNode.FillColor = Color.Transparent;
+            }
+            selectedSubtree.ForEachNodePostfix(node => {
+              symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node).FillColor = Color.LightBlue;
+            });
+          }
+          break;
+        case MouseButtons.Middle: {
+            var visualNode = (VisualSymbolicExpressionTreeNode)sender;
+            if (selectedVisualSymbExprTreeNode == null || selectedVisualSymbExprTreeNode == visualNode)
+              return;
+            selectedSubtree = clonedNodeMap[selectedVisualSymbExprTreeNode.SymbolicExpressionTreeNode];
+            var selectedNode = visualNode.SymbolicExpressionTreeNode;
+            if (clonedNodeMap.ContainsKey(selectedNode)) {
+              var selected = clonedNodeMap[selectedNode];
+              var parent = selected.Parent;
+              parent.RemoveSubtree(parent.IndexOfSubtree(selected));
+              selectedNode.ForEachNodePostfix(node => {
+                symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node).FillColor = Color.Transparent;
+                clonedNodeMap.Remove(node);
+              });
+            }
+          }
+          break;
+      }
+      // update visual graph nodes that contain matching trees
       Color[] colors = { Color.LightSkyBlue, Color.PaleGreen, Color.Tan };
-      // update visual graph nodes
-      genealogyGraphChart.Chart.UpdateEnabled = false;
       genealogyGraphChart.ClearAllNodes(); // clear node colors
-      // color each graph node according to the degree to which it matches the selected tree fragment
-      foreach (var i in Enum.GetValues(typeof(SymbolicExpressionTreeMatching.SimilarityLevel)).Cast<int>().Reverse()) {
-        var owners = genealogyGraphChart.Graph.TraceFragment(treeNode, i).ToList();
-        if (owners.Any()) genealogyGraphChart.HighlightNodes(owners, colors[i]); // highlight matching individuals from the genealogy
+      // color each graph node according to the degree to which it matches the selected tree fragment 
+      var similarityValues = Enum.GetValues(typeof(SimilarityLevel)).Cast<SimilarityLevel>().ToList();
+      foreach (var graphNode in genealogyGraphChart.Graph.Nodes) {
+        var tree = graphNode.SymbolicExpressionTree;
+        for (int i = 0; i != similarityValues.Count; ++i) {
+          if (tree.ContainsFragment(selectedSubtree, similarityValues[i])) {
+            genealogyGraphChart.HighlightNode(graphNode, colors[i]);
+            break;
+          }
+        }
       }
       genealogyGraphChart.Chart.UpdateEnabled = true;
       genealogyGraphChart.Chart.EnforceUpdate();
-
-      // highlight subtree nodes in the tree chart
-      foreach (var visualNode in symbolicExpressionTreeChart.Tree.IterateNodesPostfix().Select(node => symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node)))
-        visualNode.FillColor = Color.Transparent;
-
-      foreach (var visualNode in treeNode.IterateNodesPostfix().Select(node => symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node)))
-        visualNode.FillColor = Color.LightBlue;
-
       // refresh the tree chart
       symbolicExpressionTreeChart.Repaint();
     }
 
+    private void treeChart_SymbolicExpressionTreeNodeDoubleClicked(object sender, MouseEventArgs e) {
+    }
+
     private void similarityModeSelector_SelectedIndexChanged(object sender, EventArgs e) {
-      if (_selectedVisualSymbolicExpressionTreeNode == null) return;
-      var treeNode = _selectedVisualSymbolicExpressionTreeNode.SymbolicExpressionTreeNode;
-      var owners = genealogyGraphChart.Graph.TraceFragment(treeNode, similarityModeSelector.SelectedIndex).ToList();
+      if (selectedVisualSymbExprTreeNode == null) return;
+      var treeNode = selectedVisualSymbExprTreeNode.SymbolicExpressionTreeNode;
+      var similarityLevel = Enum.GetNames(typeof(SimilarityLevel))[similarityModeSelector.SelectedIndex];
+      var owners = genealogyGraphChart.Graph.TraceFragment(treeNode, (SimilarityLevel)Enum.Parse(typeof(SimilarityLevel), similarityLevel)).ToList();
       if (owners.Any()) {
         genealogyGraphChart.Chart.UpdateEnabled = false;
         genealogyGraphChart.ClearAllNodes(); // clear the fill color of all nodes
-        genealogyGraphChart.HighlightNodes(owners, Color.LightSkyBlue); // highlight matching individuals from the genealogy
+        genealogyGraphChart.HighlightNodes(owners, Color.LightSkyBlue);
+        // highlight matching individuals from the genealogy
         genealogyGraphChart.Chart.UpdateEnabled = true;
       }
       genealogyGraphChart.Chart.EnforceUpdate();
       // highlight subtree nodes in the tree chart
-      foreach (var visualNode in symbolicExpressionTreeChart.Tree.IterateNodesPostfix().Select(node => symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node)))
+      foreach (var node in symbolicExpressionTreeChart.Tree.IterateNodesPostfix()) {
+        var visualNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
         visualNode.FillColor = Color.Transparent;
-      foreach (var visualNode in treeNode.IterateNodesPostfix().Select(node => symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node)))
+      }
+      foreach (var node in treeNode.IterateNodesPostfix()) {
+        var visualNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
         visualNode.FillColor = Color.LightBlue;
+      }
     }
     #endregion