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

#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.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Visualization;

namespace HeuristicLab.EvolutionaryTracking.Views {
  public partial class GenealogyGraphChart : ChartControl {
    private Dictionary<GenealogyGraphNode, List<VisualGenealogyGraphNode>> _visualNodeMap;
    private Dictionary<Tuple<VisualGenealogyGraphNode, VisualGenealogyGraphNode>, VisualGenealogyGraphArc> _visualArcMap;
    private const int Diameter = 20;
    private int x, y;
    private const int Cx = 30, Cy = 30;

    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<GenealogyGraphNode, List<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.Values.GroupBy(node => node.Rank).OrderBy(g => g.Key);
      // show elites in every graph level
      List<GenealogyGraphNode> currLayer = null, prevLayer = null;
      double currRank = 0.0;
      int count = layers.Count();
      for (int i = 0; i != count; ++i) {
        // propagate elites from successive layers
        if (currRank == (int)currRank) prevLayer = currLayer;
        currRank = layers.ElementAt(i).Key;
        currLayer = layers.ElementAt(i).ToList();
        if (i > 0 && currRank == (int)currRank) {
          // this code injects elites that propagate from the previous generation into the current graph layer, so that they can be represented as visual nodes
          int prevCount = prevLayer.Count(node => node.IsElite);
          int currCount = currLayer.Count(node => node.IsElite);
          for (int j = currCount; j < prevCount; ++j) currLayer.Add(prevLayer.ElementAt(j));
        }
        currLayer.Sort(); // uses the CompareTo() method inside the GenealogyGraphNode class

        foreach (var node in currLayer) {
          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 + "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] = new List<VisualGenealogyGraphNode>();
          _visualNodeMap[node].Add(visualNode);
          // connect visual nodes that actually represent the same individual in the genealogy graph (this applies for elites) with a dashed line
          if (_visualNodeMap[node].Count > 1) {
            for (int c = _visualNodeMap[node].Count; c >= 2; --c) {
              var n1 = _visualNodeMap[node][c - 1];
              var n2 = _visualNodeMap[node][c - 2];
              var visualArc = AddArc(Chart, n1, n2, new Pen(Color.LightGray) { DashStyle = DashStyle.Dash });
              _visualArcMap[Tuple.Create(n1, n2)] = visualArc;
            }
          }
          x += Cx; // increment horizontal coordinate
          if (node.InEdges == null) continue;
          // add visual edges
          foreach (var arc in node.InEdges) {
            var parent = arc.Target;
            // find the visual parent node that is closest to the current node in terms of vertical distance
            var visualParent = _visualNodeMap[parent].Where(p => p.Center.Y > visualNode.Center.Y).OrderByDescending(p => p.Center.Y).Last();
            DashStyle style;
            if (visualParent.Data == visualNode.Data) {
              style = DashStyle.Dash;
            } else {
              style = node.InEdges.Count == 2 ? DashStyle.Solid : DashStyle.Dash;
            }
            var arcPen = new Pen(Color.Transparent) { DashStyle = style };
            _visualArcMap[Tuple.Create(visualParent, visualNode)] = AddArc(Chart, visualParent, visualNode, arcPen);
          }
        }
        y -= Cy; // decrement vertical coordinate (because the origin is upside down)
        x = 0; // reset horizontal coordinate
      }

      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
        Chart.UpdateEnabled = false;
        // clear colors
        foreach (var primitive in Chart.Group.Primitives) {
          if (primitive is VisualGenealogyGraphNode) {
            var visualNode = primitive as VisualGenealogyGraphNode;
            visualNode.Brush = null;
          } else if (primitive is VisualGenealogyGraphArc) {
            var visualArc = primitive as VisualGenealogyGraphArc;
            if (visualArc.Source.Data != visualArc.Target.Data) visualArc.Pen.Brush = new SolidBrush(Color.Transparent);
          }
        }
        // get selected node
        var visualNodes = Chart.GetAllPrimitives(e.Location).Where(p => p is VisualGenealogyGraphNode).ToList();
        if (visualNodes.Count > 0) {
          _selectedGenealogyGraphNode = visualNodes[0] as VisualGenealogyGraphNode;
          // color selected node and its genealogy
          if (_selectedGenealogyGraphNode == null) return;
          // use special highlighting for the currently selected genealogy graph node
          var center = _selectedGenealogyGraphNode.Center;
          var size = _selectedGenealogyGraphNode.Size;
          double x1 = center.X - size.Width / 2, x2 = x1 + size.Width;
          double y1 = center.Y - size.Height / 2, y2 = y1 + size.Height;
          if (_targetRectangle != null) _targetRectangle.SetPosition(x1, y1, x2, y2);
          else {
            _targetRectangle = new Visualization.Rectangle(Chart, x1, y1, x2, y2, new Pen(Color.Black), null);
            Chart.Group.Add(_targetRectangle);
          }
          var gNode = _selectedGenealogyGraphNode.Data; // genealogy graph node (representing an individual in the population) 
          double rank = gNode.Rank;
          var ancestors = gNode.Ancestors().Where(a => a.Rank < rank).ToList();
          ancestors.Add(gNode);
          // highlight selected node and its ancestry
          foreach (var node in ancestors.SelectMany(n => _visualNodeMap[n])) {
            node.Brush = new SolidBrush(node.ToColor());
            if (node.IncomingArcs != null && node == _visualNodeMap[node.Data].First()) {
              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());
              }
            }
          }
          // highlight the descendants
          var descendants = gNode.Descendants().Where(a => a.Rank > rank).ToList();
          descendants.Add(gNode);
          foreach (var node in descendants.SelectMany(n => _visualNodeMap[n])) {
            node.Brush = new SolidBrush(node.ToColor());
            foreach (var arc in node.IncomingArcs.Where(a => descendants.Contains(a.Source.Data))) {
              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());
            }
          }
        } else {
          _selectedGenealogyGraphNode = null;
        }
        // update
        Chart.UpdateEnabled = true;
        Chart.EnforceUpdate();
        if (_selectedGenealogyGraphNode != null)
          /* emit clicked event */
          GenealogyGraphNodeClicked(_selectedGenealogyGraphNode, e);
      }
    }

    public void ClearAllNodes() {
      Chart.UpdateEnabled = false;
      foreach (var node in Chart.Group.Primitives.Where(p => p is VisualGenealogyGraphNode).Cast<VisualGenealogyGraphNode>()) {
        node.Brush = null;
        if (node.IncomingArcs != null)
          foreach (var arc in node.IncomingArcs)
            if (arc.Source.Data != node.Data) arc.Pen = new Pen(Color.Transparent);
      }
      Chart.UpdateEnabled = true;
      Chart.EnforceUpdate();
    }

    public void HighlightNodes(IEnumerable<ISymbolicExpressionTree> trees, Color color) {
      Chart.UpdateEnabled = false;
      foreach (var visualNode in trees.Select(tree => _visualNodeMap[Graph.GetNode(tree)]).SelectMany(vList => vList))
        visualNode.Brush = new SolidBrush(color);

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