source: branches/DataPreprocessing/HeuristicLab.DataPreprocessing.Views/3.4/DataCompletenessView.cs @ 10925

using System;
using System.Windows.Forms;
using HeuristicLab.Analysis;
using HeuristicLab.MainForm;
using HeuristicLab.Core.Views;
using System.Collections.Generic;
using HeuristicLab.DataPreprocessing.Implementations;
using System.Drawing;

namespace HeuristicLab.DataPreprocessing.Views {

  [View("Histogram View")]
  [Content(typeof(DataCompletenessChartContent), true)]
  public partial class DataCompletenessView : ItemView
  {

    protected DataRowVisualProperties.DataRowChartType chartType;
    protected string chartTitle;

    private const string DEFAULT_CHART_TITLE = "DataCompletenessChart";

    //list of columns, bool indicates wether the cell is a missing value or not
    private List<List<bool>> matrix = new List<List<bool>>();

    public new DataCompletenessChartContent Content
    {
      get { return (DataCompletenessChartContent)base.Content; }
      set { base.Content = value; }
    }


    public DataCompletenessView()
    {
      InitializeComponent();
      chartType = DataRowVisualProperties.DataRowChartType.Bars;
      chartTitle = DEFAULT_CHART_TITLE;
    }

    protected override void OnContentChanged()
    {
      base.OnContentChanged();
      if (Content != null)
      {
        InitData();
      }
    }

    private void InitData()
    {
      IDictionary<int, IList<int>> missingValueIndices = Content.SearchLogic.GetMissingValueIndices();
      for (int i = 0; i < Content.DataGridLogic.Columns; i++)
      {
        //append column
        List<bool> column = new List<bool>();
        for (int j=0; j < Content.DataGridLogic.Rows; j++) {
          column.Add(missingValueIndices[i].Contains(j));
        }
        matrix.Add(column);
      }
      List<List<int>> yValuesPerColumn = ProcessMatrixForCharting(matrix, missingValueIndices);
      createSeries(yValuesPerColumn);
      //CreateChart();
    }

    private void createSeries(List<List<int>> yValuesPerColumn)
    {
      //prepare series
      int seriesCount = determineSeriesCount(yValuesPerColumn);
      for (int i = 0; i < seriesCount; i++)
      {
        chart.Series.Add("series"+i);
        chart.Series["series"+i].ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.StackedColumn;
        if (i % 2 == 0)
          chart.Series["series" + i].Color = Color.Blue;
        else
          chart.Series["series" + i].Color = Color.White;
      }
      //fill series
      for (int i = 0; i < yValuesPerColumn.Count; i++)
      {
        List<int> column = yValuesPerColumn[i];
        for (int j = 0; j < seriesCount; j++) {
          if (column.Count - 1 < j) {
            chart.Series["series"+j].Points.AddY(0);
          } else {
            chart.Series["series" + j].Points.AddY(column[j]);
          }
        }
      }
    }

    private int determineSeriesCount(List<List<int>> yValuesPerColumn)
    {
      int highest = 0;
      foreach (List<int> values in yValuesPerColumn) {
        highest = Math.Max(values.Count, highest);
      }
      return highest;
    }

    private List<List<int>> ProcessMatrixForCharting(List<List<bool>> matrix, IDictionary<int, IList<int>> missingValueIndices)
    {
      List<List<int>> columnsYValues = new List<List<int>>();
      for (int i=0; i < matrix.Count; i++) //column
      {
        List<int> yValues = new List<int>();
        List<bool> column = matrix[i];
        bool missingState = false;
        int valueCount = 0;
        for (int j = 0; j < column.Count; j++ ) {
          if (missingState == missingValueIndices[i].Contains(j))
          {
            valueCount++;
          }
          else
          {
            yValues.Add(valueCount);
            valueCount = 1;
            missingState = !missingState;
          }
        }
        yValues.Add(valueCount);
            /*
        List<int> yValues = new List<int>();
        bool missingChanged = true;
        while ()
             * */
        columnsYValues.Add(yValues);
      }
      return columnsYValues;
    }

    const String missingValue = "Red";
    const String existingValue = "DarkBlue";


    private void CreateChart()
    {
      object[] temp = new[] { "1", "50" };
      object[] temp2 = new[] { "50", "1000" };
      chart.Series.Add(missingValue);
      chart.Series.Add(existingValue);

      for(int i=0; i < matrix.Count; i++) {
        List<bool> column = matrix[i];
        for (int j = 0; j < column.Count; j++ )
        {
          chart.Series[missingValue].Points.AddXY(i, temp);
          chart.Series[existingValue].Points.AddXY(i, temp2);
          chart.Series[missingValue].ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.StackedBar;
          chart.Series[existingValue].ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.StackedBar;
        }
      }
    }

    /*
    private DataRow columnToDataRow(List<bool> column, int i)
    {
      DataRow row = new DataRow("row"+i);
      foreach (bool missing in column) {
        row.Values.Add(missing? 1 : 0);
      }
      return row;
    }*/

  }
}