Changeset 2295

Timestamp:

08/18/09 18:17:04 (15 years ago)

Author:

mkommend

Message:

adapted CEDMA.BubbleChart to meet needs of new ModelAnalyzer (ticket #723)

Location:

trunk/sources

Files:

• HeuristicLab.CEDMA.Charting/3.3/BubbleChart.cs (modified) (5 diffs)
• HeuristicLab.CEDMA.Charting/3.3/BubbleChartView.cs (modified) (1 diff)
• HeuristicLab.CEDMA.Charting/3.3/ModelingBubbleChart.cs (modified) (1 diff)
• HeuristicLab.CEDMA.Charting/3.3/VisualMatrix.cs (modified) (3 diffs)
• HeuristicLab.CEDMA.Charting/3.3/VisualMatrixRow.cs (modified) (3 diffs)
• HeuristicLab.CEDMA.Core/3.3/Console.cs (modified) (2 diffs)

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

@@ -71 +71 @@
       this.sizeDimension = dimension;
       this.invertSize = inverted;
+      Refresh();
+    }
+
+    public void Refresh() {
       Repaint();
       EnforceUpdate();
@@ -133 +137 @@
         } else if (matrix.MultiDimensionalCategoricalVariables.Contains(xDimension)) {
           var path = xDimension.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim());
-          IEnumerable<VisualMatrixRow> subRows = (IEnumerable<VisualMatrixRow>)r.Get(path.ElementAt(0));
-          foreach (VisualMatrixRow subRow in subRows) {
+          IEnumerable<MatrixRow> subRows = (IEnumerable<MatrixRow>)r.Get(path.ElementAt(0));
+          foreach (MatrixRow subRow in subRows) {
             if (subRow.Get(path.ElementAt(1)) != null) {
               xs.Add(matrix.IndexOfCategoricalValue(xDimension, subRow.Get(path.ElementAt(1))) + r.YJitter * xJitterFactor);
@@ -142 +146 @@
         } else if (matrix.MultiDimensionalOrdinalVariables.Contains(xDimension)) {
           var path = xDimension.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim());
-          IEnumerable<VisualMatrixRow> subRows = (IEnumerable<VisualMatrixRow>)r.Get(path.ElementAt(0));
-          foreach (VisualMatrixRow subRow in subRows) {
+          IEnumerable<MatrixRow> subRows = (IEnumerable<MatrixRow>)r.Get(path.ElementAt(0));
+          foreach (MatrixRow subRow in subRows) {
             if (subRow.Get(path.ElementAt(1)) != null) {
               xs.Add(Convert.ToDouble(subRow.Get(path.ElementAt(1))) + r.XJitter * xJitterFactor);
@@ -158 +162 @@
         } else if (matrix.MultiDimensionalCategoricalVariables.Contains(yDimension)) {
           var path = yDimension.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim());
-          IEnumerable<VisualMatrixRow> subRows = (IEnumerable<VisualMatrixRow>)r.Get(path.ElementAt(0));
-          foreach (VisualMatrixRow subRow in subRows) {
+          IEnumerable<MatrixRow> subRows = (IEnumerable<MatrixRow>)r.Get(path.ElementAt(0));
+          foreach (MatrixRow subRow in subRows) {
             if (subRow.Get(path.ElementAt(1)) != null) {
               ys.Add(matrix.IndexOfCategoricalValue(yDimension, subRow.Get(path.ElementAt(1))) + r.YJitter * yJitterFactor);
@@ -167 +171 @@
         } else if (matrix.MultiDimensionalOrdinalVariables.Contains(yDimension)) {
           var path = yDimension.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim());
-          IEnumerable<VisualMatrixRow> subRows = (IEnumerable<VisualMatrixRow>)r.Get(path.ElementAt(0));
-          foreach (VisualMatrixRow subRow in subRows) {
+          IEnumerable<MatrixRow> subRows = (IEnumerable<MatrixRow>)r.Get(path.ElementAt(0));
+          foreach (MatrixRow subRow in subRows) {
             if (subRow.Get(path.ElementAt(1)) != null) {
               ys.Add(Convert.ToDouble(subRow.Get(path.ElementAt(1))) + r.YJitter * yJitterFactor);

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

@@ -19 +19 @@
       InitializeComponent();
       bubbleChartControl.Chart = new ModelingBubbleChart(results, 0, 0, 100, 100);
-      xAxisComboBox.Items.AddRange(results.OrdinalVariables);
-      xAxisComboBox.Items.AddRange(results.CategoricalVariables);
-      xAxisComboBox.Items.AddRange(results.MultiDimensionalCategoricalVariables);
-      xAxisComboBox.Items.AddRange(results.MultiDimensionalOrdinalVariables);
-      yAxisComboBox.Items.AddRange(results.OrdinalVariables);
-      yAxisComboBox.Items.AddRange(results.CategoricalVariables);
-      yAxisComboBox.Items.AddRange(results.MultiDimensionalCategoricalVariables);
-      yAxisComboBox.Items.AddRange(results.MultiDimensionalOrdinalVariables);
+      xAxisComboBox.Items.AddRange(results.OrdinalVariables.ToArray());
+      xAxisComboBox.Items.AddRange(results.CategoricalVariables.ToArray());
+      xAxisComboBox.Items.AddRange(results.MultiDimensionalCategoricalVariables.ToArray());
+      xAxisComboBox.Items.AddRange(results.MultiDimensionalOrdinalVariables.ToArray());
+      yAxisComboBox.Items.AddRange(results.OrdinalVariables.ToArray());
+      yAxisComboBox.Items.AddRange(results.CategoricalVariables.ToArray());
+      yAxisComboBox.Items.AddRange(results.MultiDimensionalCategoricalVariables.ToArray());
+      yAxisComboBox.Items.AddRange(results.MultiDimensionalOrdinalVariables.ToArray());
       sizeComboBox.Items.Add(CONSTANT_SIZE);
-      sizeComboBox.Items.AddRange(results.OrdinalVariables);
+      sizeComboBox.Items.AddRange(results.OrdinalVariables.ToArray());
       sizeComboBox.SelectedItem = sizeComboBox.Items[0];
       yAxisComboBox.SelectedItem = yAxisComboBox.Items[0];

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

@@ -46 +46 @@
 
     public void matrix_Changed(object sender, EventArgs e) {
-      Repaint();
-      EnforceUpdate();
+      Refresh();
     }
 

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

@@ -11 +11 @@
     private Matrix matrix;
 
-    public VisualMatrix(Matrix matrix, string[] categoricalVariables, string[] ordinalVariables,
-      string[] multiDimensionalCategoricalVariables,string[] multiDimensionalOrdinalVariables) {
+    public VisualMatrix() {
+      this.rows = new List<VisualMatrixRow>();
+      this.categoricalVariables = new List<string>();
+      this.ordinalVariables = new List<string>();
+      this.multiDimensionalCategoricalVariables = new List<string>();
+      this.multiDimensionalOrdinalVariables = new List<string>();
+      this.categoricalValueIndices = new Dictionary<string, Dictionary<object, double>>();    }
+
+    public VisualMatrix(Matrix matrix, IEnumerable<string> categoricalVariables, IEnumerable<string> ordinalVariables,
+      IEnumerable<string> multiDimensionalCategoricalVariables, IEnumerable<string> multiDimensionalOrdinalVariables)
+      : this() {
       this.matrix = matrix;
-      this.rows = new List<VisualMatrixRow>();
-      foreach(MatrixRow row in matrix.GetRows())
+      this.matrix.Changed += new EventHandler(MatrixChanged);
+
+      foreach (MatrixRow row in matrix.GetRows())
         rows.Add(new VisualMatrixRow(row));
 
-      this.categoricalVariables = categoricalVariables;
-      this.ordinalVariables = ordinalVariables;
-      this.multiDimensionalOrdinalVariables = multiDimensionalOrdinalVariables;
-      this.multiDimensionalCategoricalVariables = multiDimensionalCategoricalVariables;
-      this.categoricalValueIndices = new Dictionary<string, Dictionary<object, double>>();
-
-      matrix.Changed += new EventHandler(MatrixChanged);
+      this.categoricalVariables.AddRange(categoricalVariables);
+      this.ordinalVariables.AddRange(ordinalVariables);
+      this.multiDimensionalCategoricalVariables.AddRange(multiDimensionalCategoricalVariables);
+      this.multiDimensionalOrdinalVariables.AddRange(multiDimensionalOrdinalVariables);
     }
 
@@ -34 +41 @@
     }
 
-    private string[] categoricalVariables;
-    public string[] CategoricalVariables {
+    public void AddRow(VisualMatrixRow row) {
+      this.rows.Add(row);
+    }
+
+    public void RemoveRow(VisualMatrixRow row) {
+      this.rows.Remove(row);
+    }
+
+    public void ClearAllRows(VisualMatrixRow row) {
+      this.rows.Clear();
+    }
+
+    private List<string> categoricalVariables;
+    public IEnumerable<string> CategoricalVariables {
       get { return categoricalVariables; }
     }
 
-    private string[] ordinalVariables;
-    public string[] OrdinalVariables {
+    public void AddCategoricalVariable(string name) {      
+      this.categoricalVariables.Add(name);
+    }
+
+    public void RemoveCategoricalVariable(string name) {
+      this.categoricalVariables.Remove(name);
+    }
+
+    public void ClearCategoricalVariables() {
+      this.categoricalVariables.Clear();
+    }
+
+    private List<string> ordinalVariables;
+    public IEnumerable<string> OrdinalVariables {
       get { return ordinalVariables; }
     }
 
-    private string[] multiDimensionalOrdinalVariables;
-    public string[] MultiDimensionalOrdinalVariables {
+    public void AddOrdinalVariable(string name) {
+      this.ordinalVariables.Add(name);
+    }
+
+    public void RemoveOrdinalVariable(string name) {
+      this.ordinalVariables.Remove(name);
+    }
+
+    public void ClearOrdinalVariables() {
+      this.ordinalVariables.Clear();
+    }
+
+    private List<string> multiDimensionalOrdinalVariables;
+    public IEnumerable<string> MultiDimensionalOrdinalVariables {
       get { return multiDimensionalOrdinalVariables; }
     }
 
-    private string[] multiDimensionalCategoricalVariables;
-    public string[] MultiDimensionalCategoricalVariables {
+    public void AddMultiDimensionalOrdinalVariable(string name) {
+      this.multiDimensionalOrdinalVariables.Add(name);
+    }
+
+    public void RemoveMultiDimensionalOrdinalVariable(string name) {
+      this.multiDimensionalOrdinalVariables.Remove(name);
+    }
+
+    public void ClearMultiDimensionalOrdinalVariables() {
+      this.multiDimensionalOrdinalVariables.Clear();
+    }
+
+    private List<string> multiDimensionalCategoricalVariables;
+    public IEnumerable<string> MultiDimensionalCategoricalVariables {
       get { return multiDimensionalCategoricalVariables; }
     }
-    
+
+    public void AddMultiDimensionalCategoricalVariable(string name) {
+      this.multiDimensionalCategoricalVariables.Add(name);
+    }
+
+    public void RemoveMultiDimensionalCategoricalVariable(string name) {
+      this.multiDimensionalCategoricalVariables.Remove(name);
+    }
+
+    public void ClearMultiDimensionalCategoricalVariables() {
+      this.multiDimensionalCategoricalVariables.Clear();
+    }
+
     public double IndexOfCategoricalValue(string variable, object value) {
       if (value == null) return double.NaN;
@@ -74 +141 @@
     }
 
-     public IEnumerable<string> Attributes {
-      get {return CategoricalVariables.Concat(OrdinalVariables);}
+    public IEnumerable<string> Attributes {
+      get { return CategoricalVariables.Concat(OrdinalVariables); }
     }
   }

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

@@ -7 +7 @@
 
 namespace HeuristicLab.CEDMA.Charting {
-  public class VisualMatrixRow {
-    private MatrixRow row;
+  public class VisualMatrixRow : ItemBase {
     private static Random random = new Random();
+    private Dictionary<string, object> dict;
 
-    public VisualMatrixRow(MatrixRow row) {
-      this.row = row;
+    public VisualMatrixRow() {
+      this.dict = new Dictionary<string, object>();
       this.visible = true;
       this.selected = false;
       this.xJitter = random.NextDouble() * 2.0 - 1.0;
       this.yJitter = random.NextDouble() * 2.0 - 1.0;
+    }
+
+    public VisualMatrixRow(MatrixRow row)
+      : this() {
+      foreach (KeyValuePair<string, object> value in row.Values)
+        dict[value.Key] = value.Value;
     }
 
@@ -42 +48 @@
 
     public object Get(string name) {
-      return row.Get(name);
+      if (!dict.ContainsKey(name))
+        return null;
+      return dict[name];
+    }
+
+    public void Set(string name, object value) {
+      this.dict[name] = value;
+    }
+
+    public IEnumerable<KeyValuePair<string, object>> Values {
+      get { return dict; }
     }
 
@@ -51 +67 @@
     public string GetToolTipText() {
       StringBuilder b = new StringBuilder();
-      foreach (KeyValuePair<string, object> v in row.Values) {
+      foreach (KeyValuePair<string, object> v in dict) {
         if (v.Value is string || v.Value is double || v.Value is int) {
           string val = v.Value.ToString();

trunk/sources/HeuristicLab.CEDMA.Core/3.3/Console.cs

@@ -94 +94 @@
         row.Set("TargetVariable", model.TargetVariable.Name);
         row.Set("Algorithm", model.Algorithm.Name);
-        Dictionary<HeuristicLab.Modeling.Database.IVariable, MatrixRow> inputVariableResultsEntries =
-          new Dictionary<HeuristicLab.Modeling.Database.IVariable, MatrixRow>();
-
-        foreach (IInputVariableResult inputVariableResult in db.GetInputVariableResults(model)) {
-          if (!inputVariableResultsEntries.ContainsKey(inputVariableResult.Variable)) {
-            inputVariableResultsEntries[inputVariableResult.Variable] = new MatrixRow();
-            inputVariableResultsEntries[inputVariableResult.Variable].Set("InputVariableName", inputVariableResult.Variable.Name);
-          }
-          inputVariableResultsEntries[inputVariableResult.Variable].Set(inputVariableResult.Result.Name, inputVariableResult.Value);
-        }
-        row.Set("VariableImpacts", inputVariableResultsEntries.Values);
+       
         matrix.AddRow(row);
       }
@@ -113 +103 @@
       DatabaseService db = new DatabaseService(sqlServerCompactConnectionString + database);
       db.Connect();
-      string[] multiDimensionalCategoricalVariables = new string[] { "VariableImpacts: InputVariableName" };
-      string[] multiDimensionalOrdinalVariables = db.GetAllResultsForInputVariables().Select(x => "VariableImpacts: " + x.Name).ToArray();
-      string[] ordinalVariables = db.GetAllResults().Select(r => r.Name).ToArray();
-      string[] categoricalVariables = new string[] { "TargetVariable", "Algorithm" };
+      IEnumerable<string> multiDimensionalCategoricalVariables = new List<string> { "VariableImpacts: InputVariableName" };
+      IEnumerable<string> multiDimensionalOrdinalVariables = db.GetAllResultsForInputVariables().Select(x => "VariableImpacts: " + x.Name);
+      IEnumerable<string> ordinalVariables = db.GetAllResults().Select(r => r.Name);
+      IEnumerable<string> categoricalVariables = new List<string> { "TargetVariable", "Algorithm" };
 
       db.Disconnect();