source: branches/HeuristicLab.EvolutionaryTracking/HeuristicLab.EvolutionaryTracking.Views/3.4/GenealogyGraphChart.cs @ 8701

#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.Drawing.Drawing2D;
using System.Linq;
using System.Windows.Forms;
using HeuristicLab.Common;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Visualization;

namespace HeuristicLab.EvolutionaryTracking.Views {
  public partial class GenealogyGraphChart : ChartControl {
    private Dictionary<IGenealogyGraphNode, VisualGenealogyGraphNode> visualNodeMap;
    private Dictionary<Tuple<VisualGenealogyGraphNode, VisualGenealogyGraphNode>, VisualGenealogyGraphArc> visualArcMap;
    private const int Diameter = 20; // node diameter
    private int x, y; // coordinates for positioning each node
    private const int Cx = 30, Cy = 30; // position increments
    private VisualGenealogyGraphNode selectedGenealogyGraphNode;
    public VisualGenealogyGraphNode SelectedGenealogyGraphNode { get { return selectedGenealogyGraphNode; } }
    private Visualization.Rectangle targetRectangle; // provides a  rectangle mark of the currently selected genealogy graph node

    private SymbolicExpressionTreeGenealogyGraph graph;
    public SymbolicExpressionTreeGenealogyGraph Graph {
      get { return graph; }
      internal set {
        graph = value;
        visualNodeMap = new Dictionary<IGenealogyGraphNode, VisualGenealogyGraphNode>();
        visualArcMap = new Dictionary<Tuple<VisualGenealogyGraphNode, VisualGenealogyGraphNode>, VisualGenealogyGraphArc>();
        DrawGraph();
      }
    }

    public event MouseEventHandler GenealogyGraphNodeClicked;
    private void OnGenealogyGraphNodeClicked(object sender, MouseEventArgs e) {
      var clicked = GenealogyGraphNodeClicked;
      if (clicked != null) clicked(sender, e);
    }

    public GenealogyGraphChart() {
      Chart = new Chart(0, 0, PreferredSize.Width, PreferredSize.Height);
      x = 0;
      y = PreferredSize.Height + Cx + 2 * Diameter;
    }

    public void DrawGraph() {
      if (graph == null) return;
      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();
      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);
          var nl = Environment.NewLine;
          var visualNode = new VisualGenealogyGraphNode(Chart, x, y, x + Diameter, y + Diameter, pen, null) {
            Data = node,
            ToolTipText = "Id: " + node.Label + nl +
                          "Ranks: " + string.Join(",", node.Ranks) + nl +
                          "Quality: " + String.Format("{0:0.0000}", node.Quality) + nl +
                          "IsElite: " + node.IsElite
          };
          Chart.Group.Add(visualNode);
          if (!visualNodeMap.ContainsKey(node))
            visualNodeMap[node] = visualNode;

          x += Cx; // increment horizontal coordinate
        }

        y -= Cy; // decrement vertical coordinate (because the origin is upside down)

        // 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);
              }
            }
        }
      }
      // add arcs separately (to avoid some ordering problems)
      foreach (var node in visualNodeMap.Keys) {
        var visualNode = visualNodeMap[node];
        if (node.InEdges == null) continue;

        foreach (var arc in node.InEdges) {
          var visualParent = visualNodeMap[arc.Target];
          var pen = new Pen(Color.Transparent);
          visualArcMap[Tuple.Create(visualParent, visualNode)] = AddArc(Chart, visualParent, visualNode, pen);
        }
      }

      Chart.UpdateEnabled = true;
      Chart.EnforceUpdate();
    }

    // add an arc between the source and the target nodes, using the specified pen color
    // adds the arc to the arc lists of both nodes and to the primitive group of the chart
    private static VisualGenealogyGraphArc AddArc(IChart chart, VisualGenealogyGraphNode source, VisualGenealogyGraphNode target, Pen pen, Brush brush = null) {
      var arc = new VisualGenealogyGraphArc(chart, source, target, pen) { Brush = brush };
      arc.UpdatePosition();
      source.OutgoingArcs.Add(arc);
      target.IncomingArcs.Add(arc);
      chart.Group.Add(arc);
      return arc;
    }

    protected override void pictureBox_MouseUp(object sender, MouseEventArgs e) {
      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);
      }
    }

    public void ClearAllNodes() {
      foreach (var primitive in Chart.Group.Primitives) {
        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);
          }
        } else {
          primitive.Brush = null;
        }
      }
    }

    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);
          }
        }
    }

    public void HighlightNode(SymbolicExpressionGenealogyGraphNode graphNode, Color color) {
      visualNodeMap[graphNode].Brush = new SolidBrush(color);
    }

    public void HighlightInDegree() {
      Chart.UpdateEnabled = false;
      ClearAllNodes();
      double max = Graph.Nodes.Max(x => x.InEdges == null ? 0 : x.InEdges.Count);
      foreach (var graphNode in Graph.Nodes) {
        var visualNode = visualNodeMap[graphNode];
        double deg = graphNode.InEdges == null ? 0 : graphNode.InEdges.Count;
        int index = (int)(deg / max * ColorGradient.Colors.Count);
        if (index == ColorGradient.Colors.Count) --index;
        var color = ColorGradient.Colors[index];
        visualNode.Brush = new SolidBrush(color);
      }
      Chart.UpdateEnabled = true;
      Chart.EnforceUpdate();
    }

    public void HighlightOutDegree() {
      Chart.UpdateEnabled = false;
      ClearAllNodes();
      var graphNodes = Graph.Nodes;
      double max = graphNodes.Max(x => x.OutEdges == null ? 0 : x.OutEdges.Count);
      foreach (var graphNode in graphNodes) {
        var visualNode = visualNodeMap[graphNode];
        double deg = graphNode.OutEdges == null ? 0 : graphNode.OutEdges.Count;
        int index = (int)(deg / max * ColorGradient.Colors.Count);
        if (index == ColorGradient.Colors.Count) --index;
        var color = ColorGradient.Colors[index];
        visualNode.Brush = new SolidBrush(color);
      }
      Chart.UpdateEnabled = true;
      Chart.EnforceUpdate();
    }
  }

  internal static class Util {
    public static Color GetColor(this SymbolicExpressionGenealogyGraphNode node) {
      var colorIndex = (int)(node.Quality * ColorGradient.Colors.Count);
      if (colorIndex >= ColorGradient.Colors.Count) --colorIndex;
      return ColorGradient.Colors[colorIndex];
    }
  }
}