Changeset 8248

Timestamp:

07/06/12 11:24:34 (12 years ago)

Author:

bburlacu

Message:

#1772: Separated instance-specific attributes of graph node objects from the generic genealogy graph, into metadata objects kept by the specific graph class which corresponds to the specific problem instance (so for instance the SymbolicExpressionTreeGenealogyGraph will keep info about node ranks and qualities etc because that info is specific to symbolic data analysis problems).

Location:

branches/HeuristicLab.EvolutionaryTracking

Files:

• HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphChart.cs (modified) (9 diffs)
• HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphView.cs (modified) (1 diff)
• HeuristicLab.EvolutionaryTracking.Views/3.4/VisualGenealogyGraphNode.cs (modified) (2 diffs)
• HeuristicLab.EvolutionaryTracking/3.4/Analyzers/SymbolicExpressionTreeGenealogyAnalyzer.cs (modified) (4 diffs)
• HeuristicLab.EvolutionaryTracking/3.4/GenealogyGraph.cs (modified) (6 diffs)
• HeuristicLab.EvolutionaryTracking/3.4/SymbolicExpressionTreeGenealogyGraph.cs (modified) (3 diffs)
• HeuristicLab.Selection/3.3/Plugin.cs (modified) (1 diff)

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

@@ -69 +69 @@
 
       var genealogyGraphNodes = Graph.Values.ToList();
-      var layers = genealogyGraphNodes.GroupBy(n => n.Rank).OrderBy(g => g.Key).Select(g => Tuple.Create(g.Key, g.ToList())).ToList();
+      var layers = genealogyGraphNodes.GroupBy(n => Graph[n].Ranks[0]).OrderBy(g => g.Key).Select(g => new { Rank = g.Key, Nodes = g.ToList() }).ToList();
       List<GenealogyGraphNode> currentLayer = null;
       List<GenealogyGraphNode> previousLayer = null;
@@ -75 +75 @@
       for (int i = 0; i != layers.Count(); ++i) {
         var layer = layers[i];
-        double currentRank = layer.Item1;
+        double currentRank = layer.Rank;
         if (i > 0 && currentRank % 1 == 0) {
           previousLayer = currentLayer;
-          currentLayer = layer.Item2;
+          currentLayer = layer.Nodes;
           int d = previousLayer.Count - currentLayer.Count;
           if (d > 0)
             currentLayer.AddRange(previousLayer.Take(d));
         } else {
-          currentLayer = layer.Item2;
-        }
-        currentLayer.Sort(); // sort descending by quality (using comparison defined in GenealogyGraphNode class)
+          currentLayer = layer.Nodes;
+        }
+        currentLayer.Sort((b, a) => {
+          if (Graph[a].Quality.Equals(Graph[b].Quality)) {
+            if (Graph[a].IsElite) return 1;
+            if (Graph[b].IsElite) return -1;
+          }
+          return Graph[a].Quality.CompareTo(Graph[b].Quality);
+        }); // sort descending by quality (using comparison defined in GenealogyGraphNode class)
 
         x = 0; // reset horizontal coordinate
@@ -95 +101 @@
             Data = node,
             ToolTipText = "Id: " + node.Label + nl +
-                          "Rank: " + node.Rank + nl +
-                          "Quality: " + String.Format("{0:0.0000}", node.Quality) + nl +
-                          "IsElite: " + node.IsElite
+                          "Ranks: " + Graph[node].Ranks + nl +
+                          "Quality: " + String.Format("{0:0.0000}", Graph[node].Quality) + nl +
+                          "IsElite: " + Graph[node].IsElite
           };
           Chart.Group.Add(visualNode);
@@ -171 +177 @@
           }
           var gNode = _selectedGenealogyGraphNode.Data; // genealogy graph node (representing an individual in the population) 
-          double rank = gNode.Rank;
+          double rank = Graph[gNode].Ranks[0];
           // ancestors
-          var ancestors = gNode.Ancestors().Where(a => a.Rank < rank).ToList();
+          var ancestors = gNode.Ancestors().Where(n => Graph[n].Ranks.Last() < rank).ToList();
           ancestors.Add(gNode);
           // descendants
-          var descendants = gNode.Descendants().Where(a => a.Rank > rank).ToList();
+          var descendants = gNode.Descendants().Where(n => Graph[n].Ranks.Last() > rank).ToList();
           descendants.Add(gNode);
           // highlight ancestors
           foreach (var node in ancestors.Select(n => _visualNodeMap[n][0])) {
-            node.Brush = new SolidBrush(node.ToColor());
+            node.Brush = new SolidBrush(Graph[node.Data].GetColor());
             if (node.IncomingArcs != null)
               foreach (var arc in node.IncomingArcs) {
@@ -186 +192 @@
                 // (for purposes of display consistency)
                 bool isFirst = arc.Source == _visualNodeMap[arc.Source.Data][0];
-                if (arc.Source.Data != arc.Target.Data && isFirst) {
-                  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, arc.Source.ToColor(), arc.Target.ToColor());
-                }
+                if (arc.Source.Data == arc.Target.Data || !isFirst) 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);
+                arc.Pen.Brush = new LinearGradientBrush(start, end, Graph[arc.Source.Data].GetColor(), Graph[arc.Target.Data].GetColor());
               }
           }
           // highlight descendants
           foreach (var node in descendants.Select(n => _visualNodeMap[n][0])) {
-            node.Brush = new SolidBrush(node.ToColor());
+            node.Brush = new SolidBrush(Graph[node.Data].GetColor());
             if (node.OutgoingArcs != null)
               foreach (var arc in node.OutgoingArcs) {
@@ -201 +206 @@
                 // (for purposes of display consistency)
                 bool isFirst = arc.Target == _visualNodeMap[arc.Target.Data][0];
-                if (arc.Source.Data != arc.Target.Data && isFirst) {
-                  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, arc.Source.ToColor(), arc.Target.ToColor());
-                }
+                if (arc.Source.Data == arc.Target.Data || !isFirst) 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);
+                arc.Pen.Brush = new LinearGradientBrush(start, end, Graph[arc.Source.Data].GetColor(), Graph[arc.Target.Data].GetColor());
               }
           }
@@ -222 +226 @@
     public void ClearAllNodes() {
       foreach (var primitive in Chart.Group.Primitives) {
-        if (primitive.Brush != null)
-          primitive.Brush = null;
+        primitive.Brush = null;
         if (primitive is VisualGenealogyGraphArc) {
           var arc = primitive as VisualGenealogyGraphArc;
@@ -234 +237 @@
     public void HighlightLineage(IEnumerable<GenealogyGraphNode> nodes) {
       foreach (var node in nodes.SelectMany(n => _visualNodeMap[n])) {
-        node.Brush = new SolidBrush(node.ToColor());
-        if (node.IncomingArcs != null && node == _visualNodeMap[node.Data][0]) {
-          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);
-            arc.Pen.Brush = new LinearGradientBrush(start, end, arc.Source.ToColor(), arc.Target.ToColor());
-          }
+        node.Brush = new SolidBrush(Graph[node.Data].GetColor());
+        if (node.IncomingArcs == null || node != _visualNodeMap[node.Data][0]) 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);
+          arc.Pen.Brush = new LinearGradientBrush(start, end, Graph[arc.Source.Data].GetColor(), Graph[arc.Target.Data].GetColor());
         }
       }
@@ -284 +286 @@
     }
   }
+
+  internal static class Util {
+    public static Color GetColor(this NodeMetadata nm) {
+      var colorIndex = (int)(nm.Quality * ColorGradient.Colors.Count);
+      if (colorIndex >= ColorGradient.Colors.Count) --colorIndex;
+      return ColorGradient.Colors[colorIndex];
+    }
+  }
 }

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

@@ -71 +71 @@
       else {
         genealogyGraphChart.Graph = Content;
-        var best = Content.Values.OrderByDescending(x => x.Quality).First();
+        var best = Content.Values.OrderByDescending(x => genealogyGraphChart.Graph[x].Quality).First();
         symbolicExpressionTreeChart.Tree = (ISymbolicExpressionTree)best.Data;
       }

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

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Drawing;
-using HeuristicLab.Common;
 using HeuristicLab.Visualization;
 
@@ -75 +74 @@
       get { return new PointD((LowerLeft.X + UpperRight.X) / 2, (LowerLeft.Y + UpperRight.Y) / 2); }
     }
-
-    public Color ToColor() {
-      //      return Color.FromArgb((int)((1 - Data.Quality) * 255), (int)(Data.Quality * 255), 0);
-      int i = (int)(Data.Quality * ColorGradient.Colors.Count);
-      if (i == ColorGradient.Colors.Count) --i;
-      return ColorGradient.Colors[i];
-    }
-
-    public override void Draw(Graphics graphics) {
-      if (Data.IsElite) {
-        Point p = Chart.TransformWorldToPixel(new PointD(LowerLeft.X, LowerLeft.Y + Size.Height));
-        Size s = Chart.TransformWorldToPixel(Size);
-        if (Brush != null)
-          graphics.FillEllipse(Brush, p.X, p.Y, s.Width, s.Height);
-        graphics.DrawEllipse(Pen, p.X, p.Y, s.Width, s.Height);
-        graphics.DrawEllipse(Pen, p.X + 2, p.Y + 2, s.Width - 4, s.Height - 4);
-      } else {
-        base.Draw(graphics);
-      }
-    }
   }
 }

branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/Analyzers/SymbolicExpressionTreeGenealogyAnalyzer.cs

@@ -228 +228 @@
         }
         // get tree quality values (Key => Individual, Value => Quality)
-        var qualities = (from s in gScope.SubScopes
-                         let individual = s.Variables.First().Value
-                         let quality = (DoubleValue)s.Variables["Quality"].Value
-                         orderby quality.Value descending
-                         select Tuple.Create((ISymbolicExpressionTree)individual, quality.Value)).ToList();
+        var scopes = (from s in gScope.SubScopes
+                      let individual = s.Variables.First().Value
+                      let quality = (DoubleValue)s.Variables["Quality"].Value
+                      orderby quality.Value descending
+                      select new { Tree = (ISymbolicExpressionTree)individual, Quality = quality.Value }).ToList();
 
         // add all individuals to the evolutionary graph
         int generation = Generations.Value;
         // add nodes to genealogy graph
-        for (int i = 0; i != qualities.Count; ++i) {
-          var indiv = qualities[i].Item1;
-          var label = (generation * qualities.Count + i + 1).ToString(CultureInfo.InvariantCulture);
+        for (int i = 0; i != scopes.Count; ++i) {
+          var indiv = scopes[i].Tree;
+          var label = (generation * scopes.Count + i + 1).ToString(CultureInfo.InvariantCulture);
           if (!graph.HasNode(indiv)) {
             var node = new GenealogyGraphNode(indiv) {
-              Quality = qualities[i].Item2,
               Label = label,
-              Rank = generation,
-              IsElite = i < Elites.Value
             };
             graph.AddNode(node);
+            // node metadata
+            graph[node].Ranks.Add(generation);
+            graph[node].Quality = scopes[i].Quality;
+            graph[node].IsElite = i < Elites.Value;
           }
           if (generation == 0) continue;
@@ -256 +257 @@
             object data = ((GenericWrapper<SymbolicExpressionTreeNode>)GlobalFragmentMap[indiv]).Content;
             if (GlobalTraceMap.ContainsKey(parent)) {
-              double quality = Evaluate(parent);
-              var node = new GenealogyGraphNode(parent) { Quality = quality, Label = "X", Rank = generation - 0.5 };
+              var node = new GenealogyGraphNode(parent) { Label = "X" };
               graph.AddNode(node);
+              graph[node].Quality = Evaluate(parent);
+              graph[node].Ranks.Add(generation - 0.5);
               var pp = GlobalTraceMap[parent].Cast<SymbolicExpressionTree>();
               foreach (var p in pp) {
@@ -302 +304 @@
 
         foreach (var node in graph.Values) {
-          var color = Color.FromArgb((int)((1 - node.Quality) * 255), (int)(node.Quality * 255), 0);
+          var color = Color.FromArgb((int)((1 - graph[node].Quality) * 255), (int)(graph[node].Quality * 255), 0);
           string fillColor = String.Format("#{0:x2}{1:x2}{2:x2}", color.R, color.G, color.B);
           string shape = "circle";
-          if (node.IsElite)
+          if (graph[node].IsElite)
             shape = "doublecircle";
           file.WriteLine("\t\"" + node.Id + "\" [shape=" + shape + ",fillcolor=\"" + fillColor + "\",label=\"" + node.Label + "\"];");
@@ -316 +318 @@
           }
         }
-        foreach (var g in graph.Values.GroupBy(x => x.Rank)) {
+        foreach (var g in graph.Values.GroupBy(x => graph[x].Ranks[0])) {
           var sb = new StringBuilder();
           sb.Append("\t{rank=same;");

branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/GenealogyGraph.cs

@@ -34 +34 @@
     [Storable]
     private readonly Dictionary<T, GenealogyGraphNode> _nodes;
+    private readonly Dictionary<GenealogyGraphNode, List<double>> _nodeRanks;
 
     public GenealogyGraph() {
       _nodes = new Dictionary<T, GenealogyGraphNode>();
+      _nodeRanks = new Dictionary<GenealogyGraphNode, List<double>>();
     }
 
     public GenealogyGraph(GenealogyGraph<T> g) {
       _nodes = new Dictionary<T, GenealogyGraphNode>(g._nodes);
+      _nodeRanks = new Dictionary<GenealogyGraphNode, List<double>>(g._nodeRanks);
     }
 
@@ -72 +75 @@
     /// Adds a node representing an individual
     /// </summary>
-    /// <param name="t">The data this node is supposed to represent in the graph</param>
-    public void AddNode(T t) {
-      if (HasNode(t)) return;
-      _nodes[t] = new GenealogyGraphNode(t) { Quality = 0.0, Label = "", IsElite = false, Rank = 0.0 };
+    /// <param name="tree">The data this node is supposed to represent in the graph</param>
+    public virtual void AddNode(T tree) {
+      if (HasNode(tree)) return;
+      _nodes[tree] = new GenealogyGraphNode(tree);
     }
 
@@ -82 +85 @@
     /// </summary>
     /// <param name="node">The node to be added</param>
-    public void AddNode(GenealogyGraphNode node) {
+    public virtual void AddNode(GenealogyGraphNode node) {
       var t = (T)node.Data;
       if (HasNode(t))
@@ -144 +147 @@
   }
 
-  public class GenealogyGraphNode : IComparable {
+  public class GenealogyGraphNode {
     public string Id { get; private set; }
     public string Label { get; set; }
-    public bool IsElite { get; set; }
-    public double Quality { get; set; }
-    public double Rank { get; set; }
     public List<GenealogyGraphArc> InEdges { get; set; }
     public List<GenealogyGraphArc> OutEdges { get; set; }
@@ -176 +176 @@
     public GenealogyGraphNode(GenealogyGraphNode node) {
       Id = Guid.NewGuid().ToString();
-      Rank = node.Rank;
-      Quality = node.Quality;
-      IsElite = node.IsElite;
       Label = node.Label;
       Data = node.Data;
@@ -242 +239 @@
       else InEdges.Add(e);
     }
-
-    // comparable
-    // may seem weird, it is actually implemented so higher quality means "less than" in terms of ordering
-    // if quality is equal, the elite node takes precedence
-    public int CompareTo(object obj) {
-      if (obj == null) return 1;
-      var other = obj as GenealogyGraphNode;
-      if (other == null) return 1;
-      if (Quality.Equals(other.Quality)) {
-        if (IsElite) return -1;
-        return other.IsElite ? 1 : -1;
-      }
-      return other.Quality.CompareTo(Quality);
-    }
   }
 

branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking/3.4/SymbolicExpressionTreeGenealogyGraph.cs

@@ -11 +11 @@
   [StorableClass]
   public class SymbolicExpressionTreeGenealogyGraph : GenealogyGraph<ISymbolicExpressionTree> {
+
+    [Storable]
+    private readonly Dictionary<GenealogyGraphNode, NodeMetadata> _nodeInfo = new Dictionary<GenealogyGraphNode, NodeMetadata>();
+
     public SymbolicExpressionTreeGenealogyGraph() {
     }
@@ -27 +31 @@
     }
 
+    public override void AddNode(ISymbolicExpressionTree tree) {
+      if (HasNode(tree)) return;
+      var node = new GenealogyGraphNode(tree);
+      _nodeInfo[node] = new NodeMetadata();
+      base.AddNode(node);
+    }
+
+    public override void AddNode(GenealogyGraphNode node) {
+      var tree = (ISymbolicExpressionTree)node.Data;
+      if (HasNode(tree)) return;
+      _nodeInfo[node] = new NodeMetadata();
+      base.AddNode(node);
+    }
+
+    public NodeMetadata this[GenealogyGraphNode node] {
+      get {
+        NodeMetadata value;
+        _nodeInfo.TryGetValue(node, out value);
+        return value;
+      }
+      set {
+        _nodeInfo[node] = value;
+      }
+    }
+
     #region Fragment tracing
     public IEnumerable<ISymbolicExpressionTree> TraceFragment(ISymbolicExpressionTreeNode fragment, int mode = 0) {
@@ -33 +62 @@
     #endregion
   }
+
+  public class NodeMetadata {
+    public double Quality { get; set; }
+    public List<double> Ranks { get; set; }
+    public bool IsElite { get; set; }
+
+    public NodeMetadata() {
+      Ranks = new List<double>();
+    }
+  }
 }

branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.Selection/3.3/Plugin.cs

@@ -26 +26 @@
   /// Plugin class for HeuristicLab.Selection plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Selection", "3.3.6.8213")]
+  [Plugin("HeuristicLab.Selection", "3.3.6.8236")]
   [PluginFile("HeuristicLab.Selection-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Collections", "3.3")]