source: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs @ 10564

Last change on this file since 10564 was 10564, checked in by bburlacu, 6 years ago

#2076: Forgot to commit changes to the InteractiveSymbolicDataAnalysisSolutionSimplifierView for repainting node impacts after the InteractiveSymbolicExpressionTreeChart gets repainted.

File size: 7.8 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Drawing;
25using System.Linq;
26using System.Windows.Forms;
27using HeuristicLab.Common;
28using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
29using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
30using HeuristicLab.MainForm.WindowsForms;
31
32namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
33  public abstract partial class InteractiveSymbolicDataAnalysisSolutionSimplifierView : AsynchronousContentView {
34    private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> foldedNodes;
35    private Dictionary<ISymbolicExpressionTreeNode, double> nodeImpacts;
36    private enum TreeState { Valid, Invalid }
37
38    public InteractiveSymbolicDataAnalysisSolutionSimplifierView() {
39      InitializeComponent();
40      foldedNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
41      nodeImpacts = new Dictionary<ISymbolicExpressionTreeNode, double>();
42      this.Caption = "Interactive Solution Simplifier";
43    }
44
45    public new ISymbolicDataAnalysisSolution Content {
46      get { return (ISymbolicDataAnalysisSolution)base.Content; }
47      set { base.Content = value; }
48    }
49
50    protected override void RegisterContentEvents() {
51      base.RegisterContentEvents();
52      Content.ModelChanged += Content_Changed;
53      Content.ProblemDataChanged += Content_Changed;
54      treeChart.Repainted += treeChart_Repainted;
55    }
56    protected override void DeregisterContentEvents() {
57      base.DeregisterContentEvents();
58      Content.ModelChanged -= Content_Changed;
59      Content.ProblemDataChanged -= Content_Changed;
60      treeChart.Repainted -= treeChart_Repainted;
61    }
62
63    private void Content_Changed(object sender, EventArgs e) {
64      UpdateView();
65    }
66
67    protected override void OnContentChanged() {
68      base.OnContentChanged();
69      foldedNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
70      UpdateView();
71      viewHost.Content = this.Content;
72    }
73
74    private void treeChart_Repainted(object sender, EventArgs e) {
75      if (nodeImpacts != null && nodeImpacts.Count > 0)
76        PaintNodeImpacts();
77    }
78
79    private void UpdateView() {
80      if (Content == null || Content.Model == null || Content.ProblemData == null) return;
81      var tree = Content.Model.SymbolicExpressionTree;
82      treeChart.Tree = tree.Root.SubtreeCount > 1 ? new SymbolicExpressionTree(tree.Root) : new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0));
83
84      var impactAndReplacementValues = CalculateImpactAndReplacementValues(tree);
85      nodeImpacts = impactAndReplacementValues.ToDictionary(x => x.Key, x => x.Value.Item1);
86      var replacementValues = impactAndReplacementValues.ToDictionary(x => x.Key, x => x.Value.Item2);
87      foreach (var pair in replacementValues.Where(pair => !(pair.Key is ConstantTreeNode))) {
88        foldedNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
89      }
90      PaintNodeImpacts();
91    }
92
93    protected abstract Dictionary<ISymbolicExpressionTreeNode, double> CalculateReplacementValues(ISymbolicExpressionTree tree);
94    protected abstract Dictionary<ISymbolicExpressionTreeNode, double> CalculateImpactValues(ISymbolicExpressionTree tree);
95    protected abstract Dictionary<ISymbolicExpressionTreeNode, Tuple<double, double>> CalculateImpactAndReplacementValues(ISymbolicExpressionTree tree);
96    protected abstract void UpdateModel(ISymbolicExpressionTree tree);
97
98    private static ConstantTreeNode MakeConstantTreeNode(double value) {
99      var constant = new Constant { MinValue = value - 1, MaxValue = value + 1 };
100      var constantTreeNode = (ConstantTreeNode)constant.CreateTreeNode();
101      constantTreeNode.Value = value;
102      return constantTreeNode;
103    }
104
105    private void treeChart_SymbolicExpressionTreeNodeDoubleClicked(object sender, MouseEventArgs e) {
106      var visualNode = (VisualTreeNode<ISymbolicExpressionTreeNode>)sender;
107      var symbExprTreeNode = (SymbolicExpressionTreeNode)visualNode.Content;
108      if (symbExprTreeNode == null) return;
109      var tree = Content.Model.SymbolicExpressionTree;
110      var parent = symbExprTreeNode.Parent;
111      int indexOfSubtree = parent.IndexOfSubtree(symbExprTreeNode);
112      if (foldedNodes.ContainsKey(symbExprTreeNode)) {
113        // undo node folding
114        SwitchNodeWithReplacementNode(parent, indexOfSubtree);
115      }
116      UpdateModel(tree);
117    }
118
119    private void SwitchNodeWithReplacementNode(ISymbolicExpressionTreeNode parent, int subTreeIndex) {
120      ISymbolicExpressionTreeNode subTree = parent.GetSubtree(subTreeIndex);
121      parent.RemoveSubtree(subTreeIndex);
122      if (foldedNodes.ContainsKey(subTree)) {
123        var replacementNode = foldedNodes[subTree];
124        parent.InsertSubtree(subTreeIndex, replacementNode);
125        // exchange key and value
126        foldedNodes.Remove(subTree);
127        foldedNodes.Add(replacementNode, subTree);
128      }
129    }
130
131    private void PaintNodeImpacts() {
132      var impacts = nodeImpacts.Values;
133      double max = impacts.Max();
134      double min = impacts.Min();
135      foreach (var treeNode in Content.Model.SymbolicExpressionTree.IterateNodesPostfix()) {
136        VisualTreeNode<ISymbolicExpressionTreeNode> visualTree = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
137
138        if (!(treeNode is ConstantTreeNode) && nodeImpacts.ContainsKey(treeNode)) {
139          double impact = nodeImpacts[treeNode];
140
141          // impact = 0 if no change
142          // impact < 0 if new solution is better
143          // impact > 0 if new solution is worse
144          if (impact < 0.0) {
145            // min is guaranteed to be < 0
146            visualTree.FillColor = Color.FromArgb((int)(impact / min * 255), Color.Red);
147          } else if (impact.IsAlmost(0.0)) {
148            visualTree.FillColor = Color.White;
149          } else {
150            // max is guaranteed to be > 0
151            visualTree.FillColor = Color.FromArgb((int)(impact / max * 255), Color.Green);
152          }
153          visualTree.ToolTip += Environment.NewLine + "Node impact: " + impact;
154          var constantReplacementNode = foldedNodes[treeNode] as ConstantTreeNode;
155          if (constantReplacementNode != null) {
156            visualTree.ToolTip += Environment.NewLine + "Replacement value: " + constantReplacementNode.Value;
157          }
158        }
159        if (visualTree != null)
160          if (treeNode is ConstantTreeNode && foldedNodes.ContainsKey(treeNode)) {
161            visualTree.LineColor = Color.DarkOrange;
162          }
163      }
164      treeChart.RepaintNodes();
165    }
166
167    private void btnSimplify_Click(object sender, EventArgs e) {
168      var simplifier = new SymbolicDataAnalysisExpressionTreeSimplifier();
169      var simplifiedExpressionTree = simplifier.Simplify(Content.Model.SymbolicExpressionTree);
170      UpdateModel(simplifiedExpressionTree);
171    }
172
173    protected abstract void btnOptimizeConstants_Click(object sender, EventArgs e);
174  }
175}
Note: See TracBrowser for help on using the repository browser.