Changeset 9084 for branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphChart.cs

Timestamp:

12/20/12 16:27:58 (11 years ago)

Author:

bburlacu

Message:

#1772: HeuristicLab.EvolutionaryTracking.Views: refactored the GenealogyGraphChart and the GenealogyGraphView. Fixed lineage display bug.

File:

• branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphChart.cs (modified) (10 diffs)

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

@@ -28 +28 @@
 using HeuristicLab.Common;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
 using HeuristicLab.Visualization;
 
 namespace HeuristicLab.EvolutionaryTracking.Views {
   public partial class GenealogyGraphChart : ChartControl {
-    private Dictionary<IGenealogyGraphNode, VisualGenealogyGraphNode> visualNodeMap;
+    private Dictionary<string, VisualGenealogyGraphNode> visualNodeMap; // map the uid of the genealogy graph vertex with a visual node (in this way each node is uniquely determined)
     private Dictionary<Tuple<VisualGenealogyGraphNode, VisualGenealogyGraphNode>, VisualGenealogyGraphArc> visualArcMap;
     private const int Diameter = 20; // node diameter
@@ -46 +47 @@
       internal set {
         graph = value;
-        visualNodeMap = new Dictionary<IGenealogyGraphNode, VisualGenealogyGraphNode>();
+        // TODO: should move the subtree sorting code out of here and int the view
+        var canonicalSorter = new SymbolicExpressionTreeCanonicalSorter();
+        // sort subtrees in order to improve matching
+        foreach (var tree in graph.Nodes.Select(n => n.SymbolicExpressionTree))
+          canonicalSorter.SortSubtrees(tree);
+
+        visualNodeMap = new Dictionary<string, VisualGenealogyGraphNode>();
         visualArcMap = new Dictionary<Tuple<VisualGenealogyGraphNode, VisualGenealogyGraphNode>, VisualGenealogyGraphArc>();
+
+        Chart.Group.Clear();
         DrawGraph();
       }
+    }
+
+    private VisualGenealogyGraphNode GetVisualGenealogyGraphNode(IVertex node) {
+      VisualGenealogyGraphNode visualNode;
+      visualNodeMap.TryGetValue(node.Id, out visualNode);
+      return visualNode;
     }
 
@@ -68 +83 @@
       Chart.UpdateEnabled = false;
 
-      var layers = Graph.Nodes.GroupBy(n => n.Ranks[0]).OrderBy(g => g.Key).Select(g => new { Rank = g.Key, Nodes = g.ToList() }).ToList();
+      var layers = Graph.Nodes.GroupBy(n => n.Rank).OrderBy(g => g.Key).Select(g => new { Rank = g.Key, Nodes = g.ToList() }).ToList();
+
       for (int i = 0; i != layers.Count; ++i) {
         // sort descending by quality (using comparison defined in GenealogyGraphNode class)
         layers[i].Nodes.Sort((b, a) => Graph.Compare(a, b));
         x = 0; // reset horizontal coordinate
-        // start laying out visual nodes
         foreach (var node in layers[i].Nodes) {
           var pen = new Pen(Color.LightGray);
@@ -80 +95 @@
             Data = node,
             ToolTipText = "Id: " + node.Label + nl +
-                          "Ranks: " + string.Join(",", node.Ranks) + nl +
+                          "Rank: " + node.Rank + nl +
                           "Quality: " + String.Format("{0:0.0000}", node.Quality) + nl +
                           "IsElite: " + node.IsElite
           };
           Chart.Group.Add(visualNode);
-          if (!visualNodeMap.ContainsKey(node))
-            visualNodeMap[node] = visualNode;
+          visualNodeMap.Add(node.Id, visualNode);
 
           x += Cx; // increment horizontal coordinate
@@ -94 +108 @@
 
         // connect elites from successive layers with visual arcs
-        if (i > 0) {
-          for (int m = 0; m != layers[i].Nodes.Count; ++m)
-            for (int n = 0; n != layers[i - 1].Nodes.Count; ++n) {
-              if (layers[i].Nodes[m].SymbolicExpressionTree == layers[i - 1].Nodes[n].SymbolicExpressionTree) {
-                var v1 = visualNodeMap[layers[i].Nodes[m]];
-                var v2 = visualNodeMap[layers[i - 1].Nodes[n]];
-                var pen = new Pen(Color.LightGray);
-                visualArcMap[Tuple.Create(v2, v1)] = AddArc(Chart, v2, v1, pen);
-              }
-            }
+        if (i == 0) continue;
+        var currLayer = layers[i].Nodes;
+        var prevLayer = layers[i - 1].Nodes;
+        foreach (var n in currLayer) {
+          foreach (var m in prevLayer) {
+            if (n.SymbolicExpressionTree != m.SymbolicExpressionTree) continue;
+            var v1 = GetVisualGenealogyGraphNode(n);
+            var v2 = GetVisualGenealogyGraphNode(m);
+
+            var pen = new Pen(Color.LightGray);
+            visualArcMap[Tuple.Create(v2, v1)] = AddArc(Chart, v2, v1, pen);
+          }
         }
       }
       // add arcs separately (to avoid some ordering problems)
-      foreach (var node in visualNodeMap.Keys) {
-        var visualNode = visualNodeMap[node];
+      foreach (SymbolicExpressionGenealogyGraphNode node in Graph.Nodes) {
+        VisualGenealogyGraphNode visualNode = GetVisualGenealogyGraphNode(node);
         if (node.InEdges == null) continue;
 
-        foreach (var arc in node.InEdges) {
-          var visualParent = visualNodeMap[arc.Target];
+        foreach (Arc arc in node.InEdges) {
+          var visualParent = GetVisualGenealogyGraphNode(arc.Source);
           var pen = new Pen(Color.Transparent);
           visualArcMap[Tuple.Create(visualParent, visualNode)] = AddArc(Chart, visualParent, visualNode, pen);
@@ -134 +150 @@
 
     protected override void pictureBox_MouseUp(object sender, MouseEventArgs e) {
-      if (Chart.Mode != ChartMode.Select)
+      if (Chart.Mode != ChartMode.Select) {
         base.pictureBox_MouseUp(sender, e);
-      else { // select mode
-        // get selected node
-        var visualNodes = Chart.GetAllPrimitives(e.Location).Where(p => p is VisualGenealogyGraphNode).ToList();
-        if (visualNodes.Count > 0) {
-          if (selectedGenealogyGraphNode == visualNodes[0]) return;
-          selectedGenealogyGraphNode = visualNodes[0] as VisualGenealogyGraphNode;
-          if (selectedGenealogyGraphNode == null) return;
-          // new node has been selected, clean up
-          Chart.UpdateEnabled = false;
-          // clear colors
-          ClearAllNodes();
-          // use a rectangle to highlight the currently selected genealogy graph node
-          var center = selectedGenealogyGraphNode.Center;
-          var size = selectedGenealogyGraphNode.Size;
-          double x1 = center.X - size.Width / 2;
-          double x2 = x1 + size.Width;
-          double y1 = center.Y - size.Height / 2;
-          double y2 = y1 + size.Height;
-          if (targetRectangle == null) {
-            targetRectangle = new Visualization.Rectangle(Chart, x1, y1, x2, y2, new Pen(Color.Black), null);
-            Chart.Group.Add(targetRectangle);
-          } else {
-            targetRectangle.SetPosition(x1, y1, x2, y2);
-          }
-          var gNode = selectedGenealogyGraphNode.Data; // genealogy graph node (representing an individual in the population) 
-          //          double rank = Graph[gNode].Ranks[0];
-          double rank = ((SymbolicExpressionGenealogyGraphNode)gNode).Ranks[0];
-          // ancestors
-          var ancestors = gNode.Ancestors().Where(n => ((SymbolicExpressionGenealogyGraphNode)n).Ranks.Last() < rank).ToList();
-          ancestors.Add(gNode);
-          // descendants
-          var descendants = gNode.Descendants().Where(n => ((SymbolicExpressionGenealogyGraphNode)n).Ranks.Last() > rank).ToList();
-          descendants.Add(gNode);
-          // highlight ancestors
-          foreach (var node in ancestors.Select(n => visualNodeMap[n])) {
-            node.Brush = new SolidBrush(((SymbolicExpressionGenealogyGraphNode)node.Data).GetColor());
-            if (node.IncomingArcs != null)
-              foreach (var arc in node.IncomingArcs) {
-                var start = new Point((int)arc.Start.X, (int)arc.Start.Y);
-                var end = new Point((int)arc.End.X, (int)arc.End.Y);
-                var srcNode = arc.Source.Data as SymbolicExpressionGenealogyGraphNode;
-                var destNode = arc.Target.Data as SymbolicExpressionGenealogyGraphNode;
-                arc.Pen.Brush = new LinearGradientBrush(start, end, srcNode.GetColor(), destNode.GetColor());
-              }
-          }
-          // highlight descendants
-          foreach (var node in descendants.Select(n => visualNodeMap[n])) {
-            node.Brush = new SolidBrush((node.Data as SymbolicExpressionGenealogyGraphNode).GetColor());
-            if (node.OutgoingArcs != null)
-              foreach (var arc in node.OutgoingArcs) {
-                var start = new Point((int)arc.Start.X, (int)arc.Start.Y);
-                var end = new Point((int)arc.End.X, (int)arc.End.Y);
-                var srcNode = arc.Source.Data as SymbolicExpressionGenealogyGraphNode;
-                var destNode = arc.Target.Data as SymbolicExpressionGenealogyGraphNode;
-                arc.Pen.Brush = new LinearGradientBrush(start, end, srcNode.GetColor(), destNode.GetColor());
-              }
-          }
-        } else {
-          selectedGenealogyGraphNode = null;
-        }
-        // update
-        Chart.UpdateEnabled = true;
-        Chart.EnforceUpdate();
-        if (selectedGenealogyGraphNode != null)
-          /* emit clicked event */
-          OnGenealogyGraphNodeClicked(selectedGenealogyGraphNode, e);
+        return;
+      }
+      var visualNodes = Chart.GetAllPrimitives(e.Location).Where(p => p is VisualGenealogyGraphNode).ToList();
+      if (visualNodes.Count <= 0) {
+        selectedGenealogyGraphNode = null;
+        return;
+      }
+      if (selectedGenealogyGraphNode == visualNodes[0]) return;
+      selectedGenealogyGraphNode = visualNodes[0] as VisualGenealogyGraphNode;
+      if (selectedGenealogyGraphNode == null) return;
+      // new node has been selected, clean up
+      Chart.UpdateEnabled = false;
+      // clear colors
+      ClearAllNodes();
+      // use a rectangle to highlight the currently selected genealogy graph node
+      MarkSelectedNode();
+      var gNode = selectedGenealogyGraphNode.Data;
+      var visualNode = GetVisualGenealogyGraphNode(gNode);
+
+      DrawLineage(visualNode, n => n.IncomingArcs, a => a.Source);
+      DrawLineage(visualNode, n => n.OutgoingArcs, a => a.Target);
+
+      // update
+      Chart.UpdateEnabled = true;
+      Chart.EnforceUpdate();
+
+      if (selectedGenealogyGraphNode != null)
+        /* emit clicked event */
+        OnGenealogyGraphNodeClicked(selectedGenealogyGraphNode, e);
+    }
+
+    private void DrawLineage(VisualGenealogyGraphNode node,
+                             Func<VisualGenealogyGraphNode, IEnumerable<VisualGenealogyGraphArc>> arcSelector,
+                             Func<VisualGenealogyGraphArc, VisualGenealogyGraphNode> nodeSelector) {
+      node.Brush = new SolidBrush(node.Data.GetColor());
+      var arcs = arcSelector(node);
+      foreach (var arc in arcs) {
+        var source = arc.Source.Data;
+        var target = arc.Target.Data;
+        var start = new Point((int)arc.Start.X, (int)arc.Start.Y);
+        var end = new Point((int)arc.End.X, (int)arc.End.Y);
+        arc.Pen.Brush = new LinearGradientBrush(start, end, source.GetColor(), target.GetColor());
+        DrawLineage(nodeSelector(arc), arcSelector, nodeSelector);
+      }
+    }
+
+    void MarkSelectedNode() {
+      var center = selectedGenealogyGraphNode.Center;
+      var size = selectedGenealogyGraphNode.Size;
+      double x1 = center.X - size.Width / 2;
+      double x2 = x1 + size.Width;
+      double y1 = center.Y - size.Height / 2;
+      double y2 = y1 + size.Height;
+      if (targetRectangle == null) {
+        targetRectangle = new Visualization.Rectangle(Chart, x1, y1, x2, y2, new Pen(Color.Black), null);
+        Chart.Group.Add(targetRectangle);
+      } else {
+        targetRectangle.SetPosition(x1, y1, x2, y2);
       }
     }
@@ -209 +217 @@
         if (primitive is VisualGenealogyGraphArc) {
           var arc = primitive as VisualGenealogyGraphArc;
-          var sourceData = (arc.Source.Data as SymbolicExpressionGenealogyGraphNode).SymbolicExpressionTree;
-          var targetData = (arc.Target.Data as SymbolicExpressionGenealogyGraphNode).SymbolicExpressionTree;
-          if (sourceData != targetData) {
-            primitive.Pen.Brush = new SolidBrush(Color.Transparent);
-          } else {
-            primitive.Pen.Brush = new SolidBrush(Color.LightGray);
-          }
+          var sourceData = arc.Source.Data.SymbolicExpressionTree;
+          var targetData = arc.Target.Data.SymbolicExpressionTree;
+          primitive.Pen.Brush = sourceData != targetData ? new SolidBrush(Color.Transparent) : new SolidBrush(Color.LightGray);
         } else {
           primitive.Brush = null;
@@ -222 +226 @@
     }
 
-    public void HighlightLineage(IEnumerable<GenealogyGraphNode> nodes) {
-      foreach (var node in nodes.Select(n => visualNodeMap[n])) {
-        node.Brush = new SolidBrush((node.Data as SymbolicExpressionGenealogyGraphNode).GetColor());
-        if (node.IncomingArcs == null || node != visualNodeMap[node.Data]) continue;
-        foreach (var arc in node.IncomingArcs) {
-          if (arc.Source.Data == node.Data) continue;
-          var start = new Point((int)arc.Start.X, (int)arc.Start.Y);
-          var end = new Point((int)arc.End.X, (int)arc.End.Y);
-          var srcNode = arc.Source.Data as SymbolicExpressionGenealogyGraphNode;
-          var destNode = arc.Target.Data as SymbolicExpressionGenealogyGraphNode;
-          arc.Pen.Brush = new LinearGradientBrush(start, end, srcNode.GetColor(), destNode.GetColor());
-        }
-      }
-    }
-
     // TODO: optimize and reduce complexity of this method
     public void HighlightNodes(IEnumerable<ISymbolicExpressionTree> trees, Color color) {
-      foreach (var tree in trees)
-        foreach (var graphNode in Graph.Nodes) {
-          if (graphNode.SymbolicExpressionTree == tree) {
-            var visualNode = visualNodeMap[graphNode];
-            visualNode.Brush = new SolidBrush(color);
-          }
-        }
+      foreach (var tree in trees) {
+        var graphNodes = graph.GetGraphNodes(tree);
+        foreach (var graphNode in graphNodes) {
+          GetVisualGenealogyGraphNode(graphNode).Brush = new SolidBrush(color);
+        }
+      }
     }
 
     public void HighlightNode(SymbolicExpressionGenealogyGraphNode graphNode, Color color) {
-      visualNodeMap[graphNode].Brush = new SolidBrush(color);
+      GetVisualGenealogyGraphNode(graphNode).Brush = new SolidBrush(color);
     }
 
@@ -257 +245 @@
       double max = Graph.Nodes.Max(x => x.InEdges == null ? 0 : x.InEdges.Count);
       foreach (var graphNode in Graph.Nodes) {
-        var visualNode = visualNodeMap[graphNode];
+        var visualNode = GetVisualGenealogyGraphNode(graphNode);
         double deg = graphNode.InEdges == null ? 0 : graphNode.InEdges.Count;
         int index = (int)(deg / max * ColorGradient.Colors.Count);
@@ -274 +262 @@
       double max = graphNodes.Max(x => x.OutEdges == null ? 0 : x.OutEdges.Count);
       foreach (var graphNode in graphNodes) {
-        var visualNode = visualNodeMap[graphNode];
+        var visualNode = GetVisualGenealogyGraphNode(graphNode);
         double deg = graphNode.OutEdges == null ? 0 : graphNode.OutEdges.Count;
         int index = (int)(deg / max * ColorGradient.Colors.Count);