Changeset 2289 for trunk/sources/HeuristicLab.CEDMA.Charting/3.3/BubbleChart.cs

Timestamp:

08/14/09 15:35:10 (15 years ago)

Author:

mkommend

Message:

• added VisualMatrix to represent data in BubbleChart
• made BubbleChart abstract and added inherited ModelingBubbleChart, which reacts as the BubbleChart
• moved classes between CEDMA.Core and CEDMA.Charting
• deleted unnecessary classes (results, resultsentry)

(ticket #723)

File:

• trunk/sources/HeuristicLab.CEDMA.Charting/3.3/BubbleChart.cs (modified) (10 diffs)

trunk/sources/HeuristicLab.CEDMA.Charting/3.3/BubbleChart.cs

@@ -27 +27 @@
 using HeuristicLab.Charting;
 using System.Windows.Forms;
-using HeuristicLab.CEDMA.Core;
 using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Core;
 using System.Diagnostics;
+using HeuristicLab.SparseMatrix;
 
 namespace HeuristicLab.CEDMA.Charting {
-  public class BubbleChart : Chart {
-    private const string X_JITTER = "__X_JITTER";
-    private const string Y_JITTER = "__Y_JITTER";
+  public abstract class BubbleChart : Chart {
     private const double maxXJitterPercent = 0.05;
     private const double maxYJitterPercent = 0.05;
@@ -55 +53 @@
     private double maxX = double.NegativeInfinity;
     private double maxY = double.NegativeInfinity;
-    private List<ResultsEntry> filteredEntries;
-    private Results results;
-    private Dictionary<IPrimitive, ResultsEntry> primitiveToEntryDictionary;
-    private Random random = new Random();
-    private Group points;
-
-    public BubbleChart(Results results, PointD lowerLeft, PointD upperRight)
+
+    protected Group points;
+    protected VisualMatrix matrix;
+    protected Dictionary<IPrimitive, VisualMatrixRow> primitiveToMatrixRowDictionary;
+
+    public BubbleChart(VisualMatrix matrix, PointD lowerLeft, PointD upperRight)
       : base(lowerLeft, upperRight) {
-      primitiveToEntryDictionary = new Dictionary<IPrimitive, ResultsEntry>();
-      this.results = results;
-      filteredEntries = new List<ResultsEntry>();
-
-      foreach (var resultsEntry in results.GetEntries()) {
-        if (resultsEntry.Get(X_JITTER) == null)
-          resultsEntry.Set(X_JITTER, random.NextDouble() * 2.0 - 1.0);
-        if (resultsEntry.Get(Y_JITTER) == null)
-          resultsEntry.Set(Y_JITTER, random.NextDouble() * 2.0 - 1.0);
-      }
-      results.Changed += new EventHandler(results_Changed);
-    }
-
-    void results_Changed(object sender, EventArgs e) {
-      Repaint();
-      EnforceUpdate();
-    }
-
-    public BubbleChart(Results results, double x1, double y1, double x2, double y2)
-      : this(results, new PointD(x1, y1), new PointD(x2, y2)) {
+      primitiveToMatrixRowDictionary = new Dictionary<IPrimitive, VisualMatrixRow>();
+      this.matrix = matrix;
+    }
+
+    public BubbleChart(VisualMatrix matrix, double x1, double y1, double x2, double y2)
+      : this(matrix, new PointD(x1, y1), new PointD(x2, y2)) {
     }
 
@@ -103 +86 @@
     }
 
-    internal void SetJitter(double xJitterFactor, double yJitterFactor) {
+    public void SetJitter(double xJitterFactor, double yJitterFactor) {
       this.xJitterFactor = xJitterFactor * maxXJitterPercent * Size.Width;
       this.yJitterFactor = yJitterFactor * maxYJitterPercent * Size.Height;
@@ -115 +98 @@
     }
 
-    private void Repaint() {
+    protected void Repaint() {
       if (xDimension == null || yDimension == null) return;
       double maxSize = 1;
       double minSize = 1;
-      if (sizeDimension != null && results.OrdinalVariables.Contains(sizeDimension)) {
-        var sizes = results.GetEntries()
+      if (sizeDimension != null && matrix.OrdinalVariables.Contains(sizeDimension)) {
+        var sizes = matrix.Rows
           .Select(x => Convert.ToDouble(x.Get(sizeDimension)))
           .Where(size => !double.IsInfinity(size) && size != double.MaxValue && size != double.MinValue)
@@ -132 +115 @@
       UpdateEnabled = false;
       Group.Clear();
-      primitiveToEntryDictionary.Clear();
+      primitiveToMatrixRowDictionary.Clear();
       points = new Group(this);
       Group.Add(new Axis(this, 0, 0, AxisType.Both));
       UpdateViewSize(0, 0, TransformPixelToWorld(new Size(5, 0)).Width);
-      foreach (ResultsEntry r in results.GetEntries().Where(x => x.Visible)) {
+      foreach (VisualMatrixRow r in matrix.Rows.Where(x => x.Visible)) {
         List<double> xs = new List<double>();
         List<double> ys = new List<double>();
@@ -142 +125 @@
         List<object> actualYValues = new List<object>();
         int size;
-        if (results.OrdinalVariables.Contains(xDimension) && r.Get(xDimension) != null) {
-          xs.Add(Convert.ToDouble(r.Get(xDimension)) + (double)r.Get(X_JITTER) * xJitterFactor);
+        if (matrix.OrdinalVariables.Contains(xDimension) && r.Get(xDimension) != null) {
+          xs.Add(Convert.ToDouble(r.Get(xDimension)) + r.XJitter * xJitterFactor);
           actualXValues.Add(r.Get(xDimension));
-        } else if (results.CategoricalVariables.Contains(xDimension) && r.Get(xDimension) != null) {
-          xs.Add(results.IndexOfCategoricalValue(xDimension, r.Get(xDimension)) + (double)r.Get(X_JITTER) * xJitterFactor);
+        } else if (matrix.CategoricalVariables.Contains(xDimension) && r.Get(xDimension) != null) {
+          xs.Add(matrix.IndexOfCategoricalValue(xDimension, r.Get(xDimension)) + r.XJitter * xJitterFactor);
           actualXValues.Add(r.Get(xDimension));
-        } else if (results.MultiDimensionalCategoricalVariables.Contains(xDimension)) {
+        } else if (matrix.MultiDimensionalCategoricalVariables.Contains(xDimension)) {
           var path = xDimension.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim());
-          IEnumerable<ResultsEntry> subEntries = (IEnumerable<ResultsEntry>)r.Get(path.ElementAt(0));
-          foreach (ResultsEntry subEntry in subEntries) {
-            if (subEntry.Get(path.ElementAt(1)) != null) {
-              xs.Add(results.IndexOfCategoricalValue(xDimension, subEntry.Get(path.ElementAt(1))) + (double)r.Get(X_JITTER) * xJitterFactor);
-              actualXValues.Add(subEntry.Get(path.ElementAt(1)));
-            }
-          }
-        } else if (results.MultiDimensionalOrdinalVariables.Contains(xDimension)) {
+          IEnumerable<VisualMatrixRow> subRows = (IEnumerable<VisualMatrixRow>)r.Get(path.ElementAt(0));
+          foreach (VisualMatrixRow subRow in subRows) {
+            if (subRow.Get(path.ElementAt(1)) != null) {
+              xs.Add(matrix.IndexOfCategoricalValue(xDimension, subRow.Get(path.ElementAt(1))) + r.YJitter * xJitterFactor);
+              actualXValues.Add(subRow.Get(path.ElementAt(1)));
+            }
+          }
+        } else if (matrix.MultiDimensionalOrdinalVariables.Contains(xDimension)) {
           var path = xDimension.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim());
-          IEnumerable<ResultsEntry> subEntries = (IEnumerable<ResultsEntry>)r.Get(path.ElementAt(0));
-          foreach (ResultsEntry subEntry in subEntries) {
-            if (subEntry.Get(path.ElementAt(1)) != null) {
-              xs.Add(Convert.ToDouble(subEntry.Get(path.ElementAt(1))) + (double)r.Get(X_JITTER) * xJitterFactor);
-              actualXValues.Add(subEntry.Get(path.ElementAt(1)));
-            }
-          }
-        }
-        if (results.OrdinalVariables.Contains(yDimension) && r.Get(yDimension) != null) {
-          ys.Add(Convert.ToDouble(r.Get(yDimension)) + (double)r.Get(Y_JITTER) * yJitterFactor);
+          IEnumerable<VisualMatrixRow> subRows = (IEnumerable<VisualMatrixRow>)r.Get(path.ElementAt(0));
+          foreach (VisualMatrixRow subRow in subRows) {
+            if (subRow.Get(path.ElementAt(1)) != null) {
+              xs.Add(Convert.ToDouble(subRow.Get(path.ElementAt(1))) + r.XJitter * xJitterFactor);
+              actualXValues.Add(subRow.Get(path.ElementAt(1)));
+            }
+          }
+        }
+        if (matrix.OrdinalVariables.Contains(yDimension) && r.Get(yDimension) != null) {
+          ys.Add(Convert.ToDouble(r.Get(yDimension)) + r.YJitter * yJitterFactor);
           actualYValues.Add(r.Get(yDimension));
-        } else if (results.CategoricalVariables.Contains(yDimension) && r.Get(yDimension) != null) {
-          ys.Add(results.IndexOfCategoricalValue(yDimension, r.Get(yDimension)) + (double)r.Get(Y_JITTER) * yJitterFactor);
+        } else if (matrix.CategoricalVariables.Contains(yDimension) && r.Get(yDimension) != null) {
+          ys.Add(matrix.IndexOfCategoricalValue(yDimension, r.Get(yDimension)) + r.YJitter * yJitterFactor);
           actualYValues.Add(r.Get(yDimension));
-        } else if (results.MultiDimensionalCategoricalVariables.Contains(yDimension)) {
+        } else if (matrix.MultiDimensionalCategoricalVariables.Contains(yDimension)) {
           var path = yDimension.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim());
-          IEnumerable<ResultsEntry> subEntries = (IEnumerable<ResultsEntry>)r.Get(path.ElementAt(0));
-          foreach (ResultsEntry subEntry in subEntries) {
-            if (subEntry.Get(path.ElementAt(1)) != null) {
-              ys.Add(results.IndexOfCategoricalValue(yDimension, subEntry.Get(path.ElementAt(1))) + (double)r.Get(Y_JITTER) * yJitterFactor);
-              actualYValues.Add(subEntry.Get(path.ElementAt(1)));
-            }
-          }
-        } else if (results.MultiDimensionalOrdinalVariables.Contains(yDimension)) {
+          IEnumerable<VisualMatrixRow> subRows = (IEnumerable<VisualMatrixRow>)r.Get(path.ElementAt(0));
+          foreach (VisualMatrixRow subRow in subRows) {
+            if (subRow.Get(path.ElementAt(1)) != null) {
+              ys.Add(matrix.IndexOfCategoricalValue(yDimension, subRow.Get(path.ElementAt(1))) + r.YJitter * yJitterFactor);
+              actualYValues.Add(subRow.Get(path.ElementAt(1)));
+            }
+          }
+        } else if (matrix.MultiDimensionalOrdinalVariables.Contains(yDimension)) {
           var path = yDimension.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim());
-          IEnumerable<ResultsEntry> subEntries = (IEnumerable<ResultsEntry>)r.Get(path.ElementAt(0));
-          foreach (ResultsEntry subEntry in subEntries) {
-            if (subEntry.Get(path.ElementAt(1)) != null) {
-              ys.Add(Convert.ToDouble(subEntry.Get(path.ElementAt(1))) + (double)r.Get(Y_JITTER) * yJitterFactor);
-              actualYValues.Add(subEntry.Get(path.ElementAt(1)));
+          IEnumerable<VisualMatrixRow> subRows = (IEnumerable<VisualMatrixRow>)r.Get(path.ElementAt(0));
+          foreach (VisualMatrixRow subRow in subRows) {
+            if (subRow.Get(path.ElementAt(1)) != null) {
+              ys.Add(Convert.ToDouble(subRow.Get(path.ElementAt(1))) + r.YJitter * yJitterFactor);
+              actualYValues.Add(subRow.Get(path.ElementAt(1)));
             }
           }
@@ -208 +191 @@
           if (double.IsInfinity(x) || x == double.MaxValue || x == double.MinValue) x = double.NaN;
           if (double.IsInfinity(y) || y == double.MaxValue || y == double.MinValue) y = double.NaN;
-          if (!double.IsNaN(x) && !double.IsNaN(y) && IsReasonablePoint(new PointD(x,y))) {
+          if (!double.IsNaN(x) && !double.IsNaN(y) && IsReasonablePoint(new PointD(x, y))) {
             string actualXValue = actualXValues[Math.Min(i, actualXValues.Count() - 1)].ToString();
             string actualYValue = actualYValues[Math.Min(i, actualYValues.Count() - 1)].ToString();
@@ -221 +204 @@
             points.Add(c);
             if (!r.Selected) c.IntoBackground();
-            primitiveToEntryDictionary[c] = r;
+            primitiveToMatrixRowDictionary[c] = r;
           }
         }
@@ -230 +213 @@
 
     private bool IsReasonablePoint(PointD pointD) {
-      return pointD.X > LowerLeft.X && pointD.X < UpperRight.X && pointD.Y > LowerLeft.Y && pointD.Y < UpperRight.Y; 
+      return pointD.X > LowerLeft.X && pointD.X < UpperRight.X && pointD.Y > LowerLeft.Y && pointD.Y < UpperRight.Y;
     }
 
@@ -274 +257 @@
     }
 
-    internal ResultsEntry GetResultsEntry(Point point) {
-      ResultsEntry r = null;
+    protected VisualMatrixRow GetMatrixRow(Point point) {
+      VisualMatrixRow r = null;
       IPrimitive p = points.GetPrimitive(TransformPixelToWorld(point));
       if (p != null) {
-        primitiveToEntryDictionary.TryGetValue(p, out r);
+        primitiveToMatrixRowDictionary.TryGetValue(p, out r);
       }
       return r;
     }
 
-    public override void MouseDrag(Point start, Point end, MouseButtons button) {
-      if (button == MouseButtons.Left && Mode == ChartMode.Select) {
-        PointD a = TransformPixelToWorld(start);
-        PointD b = TransformPixelToWorld(end);
-        double minX = Math.Min(a.X, b.X);
-        double minY = Math.Min(a.Y, b.Y);
-        double maxX = Math.Max(a.X, b.X);
-        double maxY = Math.Max(a.Y, b.Y);
-        HeuristicLab.Charting.Rectangle rect = new HeuristicLab.Charting.Rectangle(this, minX, minY, maxX, maxY);
-
-        List<IPrimitive> primitives = new List<IPrimitive>();
-        primitives.AddRange(points.Primitives);
-
-        foreach (FixedSizeCircle p in primitives) {
-          if (rect.ContainsPoint(p.Point)) {
-            ResultsEntry r;
-            primitiveToEntryDictionary.TryGetValue(p, out r);
-            if (r != null) r.ToggleSelected();
-          }
-        }
-        if (primitives.Count() > 0) results.FireChanged();
-      } else {
-        base.MouseDrag(start, end, button);
-      }
-    }
-
-    public override void MouseClick(Point point, MouseButtons button) {
-      if (button == MouseButtons.Left) {
-        ResultsEntry r = GetResultsEntry(point);
-        if (r != null) {
-          r.ToggleSelected();
-          results.FireChanged();
-        }
-      } else {
-        base.MouseClick(point, button);
-      }
-    }
-
-    public override void MouseDoubleClick(Point point, MouseButtons button) {
-      if (button == MouseButtons.Left) {
-        ResultsEntry entry = GetResultsEntry(point);
-        if (entry != null) {
-          var model = (IItem)PersistenceManager.RestoreFromGZip((byte[])entry.Get("PersistedData"));
-          PluginManager.ControlManager.ShowControl(model.CreateView());
-        }
-      } else {
-        base.MouseDoubleClick(point, button);
-      }
-    }
-
-    internal void ToggleSelected() {
-      foreach (ResultsEntry entry in results.GetEntries()) {
+    public virtual void ToggleSelected() {
+      foreach (VisualMatrixRow row in matrix.Rows) {
+        row.ToggleSelected();
+      }
+      matrix.FireChanged();
+    }
+
+    public virtual void ClearSelection() {
+      foreach (VisualMatrixRow entry in matrix.Rows.Where(x => x.Selected)) {
         entry.ToggleSelected();
       }
-      results.FireChanged();
-    }
-
-    internal void ClearSelection() {
-      foreach (ResultsEntry entry in results.GetEntries().Where(x=>x.Selected)) {
-        entry.ToggleSelected();
-      }
-      results.FireChanged();
-    }
-
-    internal void ApplyFilter(Func<ResultsEntry, bool> filterPred) {
-      foreach (ResultsEntry r in results.GetEntries()) {
+      matrix.FireChanged();
+    }
+
+    public virtual void ApplyFilter(Func<VisualMatrixRow, bool> filterPred) {
+      foreach (VisualMatrixRow r in matrix.Rows) {
         if (filterPred(r)) {
           r.Visible = false;
           r.Selected = false;
-          filteredEntries.Add(r);
-        } 
-      }
-      results.FireChanged();
-    }
-
-    internal void ClearFilter() {
-      foreach (ResultsEntry r in filteredEntries) {
+        }
+      }
+      matrix.FireChanged();
+    }
+
+    public virtual void ClearFilter() {
+      foreach (VisualMatrixRow r in matrix.Rows.Where(x => !x.Visible)) {
         r.Visible = true;
       }
-      filteredEntries.Clear();
-      results.FireChanged();
+      matrix.FireChanged();
     }
   }