Changeset 7411 for branches/HeuristicLab.TreeSimplifierView/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs

Timestamp:

01/25/12 17:26:29 (12 years ago)

Author:

bburlacu

Message:

#1763: Improved ValueChangeDialog and overall behavior. Implemented pruning operation on background thread. TODO: Test, improve. This is a work-in-progress.

File:

• branches/HeuristicLab.TreeSimplifierView/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs (modified) (8 diffs)

branches/HeuristicLab.TreeSimplifierView/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Drawing;
 using System.Linq;
@@ -36 +37 @@
     private Dictionary<ISymbolicExpressionTreeNode, double> originalValues;
     private bool updateInProgress = false;
+    private VisualSymbolicExpressionTreeNode visualTreeNode; // need some kind of state for correctly handling events 
 
     public InteractiveSymbolicDataAnalysisSolutionSimplifierView() {
@@ -129 +131 @@
 
     private void treeChart_SymbolicExpressionTreeNodeDoubleClicked(object sender, MouseEventArgs e) {
-      VisualSymbolicExpressionTreeNode visualTreeNode = (VisualSymbolicExpressionTreeNode)sender;
+      visualTreeNode = (VisualSymbolicExpressionTreeNode)sender;
       var tree = Content.Model.SymbolicExpressionTree;
       // check if the node value/weight has been altered
@@ -189 +191 @@
 
     private void treeChart_SymbolicExpressionTreeNodeChanged(object sender, EventArgs e) {
-      var tree = Content.Model.SymbolicExpressionTree;
-      var visualTreeNode = sender as VisualSymbolicExpressionTreeNode;
+      visualTreeNode = sender as VisualSymbolicExpressionTreeNode;
       var subTree = visualTreeNode.SymbolicExpressionTreeNode;
       string title = String.Empty;
@@ -203 +204 @@
       }
 
+      double originalValue = value;
+
       if (!originalValues.ContainsKey(subTree))
         originalValues.Add(subTree, value);
-      var dialog = new ValueChangeDialog(title, Math.Round(value,4).ToString());
+      else originalValue = originalValues[subTree];
+
+      var dialog = new ValueChangeDialog(title, Math.Round(originalValue, 4).ToString(), Math.Round(value, 4).ToString());
+      dialog.NewValueTextBox.Validated += OnNewValueValidated;
       dialog.ShowDialog(this);
-      if (dialog.DialogResult == DialogResult.OK) {
-        value = double.Parse(dialog.NewValue);
-        if (subTree.Symbol is Constant)
-          (subTree as ConstantTreeNode).Value = value;
-        else if (subTree.Symbol is Variable)
-          (subTree as VariableTreeNode).Weight = value;
-        // show only interesting part of solution 
-        treeChart.Tree = tree.Root.SubtreeCount > 1 ? new SymbolicExpressionTree(tree.Root) : new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0));
-        updateInProgress = true;
-        UpdateModel(tree);
-        updateInProgress = false;
-      }
+    }
+
+    private void OnNewValueValidated(object sender, EventArgs e) {
+      var textBox = sender as TextBox;
+      var value = double.Parse(textBox.Text);
+      var subTree = visualTreeNode.SymbolicExpressionTreeNode;
+      var tree = Content.Model.SymbolicExpressionTree;
+
+      if (subTree.Symbol is Constant)
+        (subTree as ConstantTreeNode).Value = value;
+      else if (subTree.Symbol is Variable)
+        (subTree as VariableTreeNode).Weight = value;
+
+      // show only interesting part of solution 
+      treeChart.Tree = tree.Root.SubtreeCount > 1 ? new SymbolicExpressionTree(tree.Root) : new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0));
+      updateInProgress = true;
+      UpdateModel(tree);
+      updateInProgress = false;
     }
 
@@ -238 +250 @@
       double min = impacts.Min();
       foreach (ISymbolicExpressionTreeNode treeNode in Content.Model.SymbolicExpressionTree.IterateNodesPostfix()) {
+        VisualSymbolicExpressionTreeNode visualTree = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
+        bool flag1 = replacementNodes.ContainsKey(treeNode);
+        bool flag2 = originalValues.ContainsKey(treeNode);
+        bool flag3 = treeNode is ConstantTreeNode;
+
+        if (flag2) // constant or variable node was changed
+          visualTree.ToolTip += Environment.NewLine + "Original value: " + originalValues[treeNode];
+        else if (flag1 && flag3) // node was folded to a constant
+          visualTree.ToolTip += Environment.NewLine + "Original node: " + replacementNodes[treeNode];
+
         if (!(treeNode is ConstantTreeNode) && nodeImpacts.ContainsKey(treeNode)) {
           double impact = nodeImpacts[treeNode];
-          VisualSymbolicExpressionTreeNode visualTree = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
 
           // impact = 0 if no change
@@ -267 +288 @@
     private void PaintCollapsedNodes() {
       foreach (ISymbolicExpressionTreeNode treeNode in Content.Model.SymbolicExpressionTree.IterateNodesPostfix()) {
-        if (originalValues.ContainsKey(treeNode)) 
-          this.treeChart.GetVisualSymbolicExpressionTreeNode(treeNode).LineColor = Color.Blue;
-        else if (treeNode is ConstantTreeNode && replacementNodes.ContainsKey(treeNode))
-          this.treeChart.GetVisualSymbolicExpressionTreeNode(treeNode).LineColor = Color.DarkOrange;
-        else {
-          VisualSymbolicExpressionTreeNode visNode = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
-          if (visNode != null)
-            visNode.LineColor = Color.Black;
+        bool flag1 = replacementNodes.ContainsKey(treeNode);
+        bool flag2 = originalValues.ContainsKey(treeNode);
+        if (flag1 && treeNode is ConstantTreeNode) {
+          this.treeChart.GetVisualSymbolicExpressionTreeNode(treeNode).LineColor = flag2 ? Color.DarkViolet : Color.DarkOrange;
+        } else if (flag2) {
+          this.treeChart.GetVisualSymbolicExpressionTreeNode(treeNode).LineColor = Color.DodgerBlue;
         }
       }
@@ -285 +304 @@
     }
 
+    private void btnPrune_Click(object sender, EventArgs e) {
+      backgroundWorker1.RunWorkerAsync();
+    }
+
+    private static IEnumerable<ISymbolicExpressionTreeNode> GetNodesAtDepth(ISymbolicExpressionTreeNode root, Data.IntRange range) {
+      var list = new List<Tuple<ISymbolicExpressionTreeNode, int>> { new Tuple<ISymbolicExpressionTreeNode, int>(root, 0) };
+      int offset = 0;
+      int level = 0;
+      while (level < range.End) {
+        ++level;
+        int count = list.Count;
+        for (int i = offset; i != count; ++i) {
+          if (list[i].Item1.Subtrees.Any())
+            list.AddRange(from s in list[i].Item1.Subtrees select new Tuple<ISymbolicExpressionTreeNode, int>(s, level));
+        }
+        offset = count;
+      }
+      // taking advantage of the fact that the list is already sorted by level
+      for (int i = list.Count - 1; i >= 0; --i) {
+        if (list[i].Item2 >= range.Start)
+          yield return list[i].Item1;
+        else break;
+      }
+    }
+
     protected abstract void btnOptimizeConstants_Click(object sender, EventArgs e);
+
+    private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) {
+      BackgroundWorker worker = sender as BackgroundWorker;
+      PruneTree(worker);
+
+    }
+
+    private void PruneTree(BackgroundWorker worker) {
+      var tree = Content.Model.SymbolicExpressionTree;
+      // get all tree nodes 
+      foreach (var node in GetNodesAtDepth(tree.Root, new Data.IntRange(2, tree.Depth))) {
+        if (worker.CancellationPending)
+          break; // pruning cancelled
+        if (!(node.Symbol is Constant) && nodeImpacts.ContainsKey(node) && nodeImpacts[node] < 0.001) {
+          SwitchNodeWithReplacementNode(node.Parent, node.Parent.IndexOfSubtree(node));
+          CalculateReplacementNodesAndNodeImpacts();
+        }
+      }
+    }
+
+    private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
+      if (e.Cancelled) {
+        // The user canceled the operation.
+      } else if (e.Error != null) {
+        // There was an error during the operation.
+        // Error-handling
+      } else {
+        // The operation completed normally. We can update the model
+        UpdateModel(Content.Model.SymbolicExpressionTree);
+      }
+    }
   }
 }