source: branches/2913_MatlabScriptProblemInstanceProvider/HeuristicLab.Problems.Instances.DataAnalysis.Views/3.3/Regression/Matlab/RegressionMatlabImportDialog.cs @ 15926

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.Windows.Forms;
using HeuristicLab.Common;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.Instances.DataAnalysis.Regression.Matlab;
using HeuristicLab.Problems.Instances.DataAnalysis.Regression.Matlab.Api;
using HeuristicLab.Problems.Instances.DataAnalysis.Regression.Matlab.Api.Types;

namespace HeuristicLab.Problems.Instances.DataAnalysis.Views.Regression.Matlab {
  public partial class RegressionMatlabImportDialog : Form {
    private const int TAB_INDEX_TIMESERIES = 0;
    private const int TAB_INDEX_DOUBLE_ARRAYS = 1;

    private IMatlabConnector _mlConnector;

    private IMLVariablesLoader _variablesLoader;
    private IMLVariablesLoader _timeseriesLoader;
    private IMLVariablesLoader _doubleArraysLoader;

    private CancellationTokenSource _cts = new CancellationTokenSource();

    public event EventHandler<EventArgs<string>> StatusChangedEvent;
    public event EventHandler<EventArgs<string>> ErrorOccuredEvent;

    /// <summary>
    /// Path to the Matlab file
    /// </summary>
    public string Path {
      get { return ProblemTextBox.Text; }
    }

    /// <summary>
    /// As loading the data can take much time, loaded values will be stored.
    /// So they have not have to be loaded a secound time.
    /// </summary>
    private Dataset _values;

    public RegressionMatlabImportType ImportType {
      get {
        return new RegressionMatlabImportType() {
          Shuffle = false,
          TrainingPercentage = TrainingTestTrackBar.Value,
          TargetVariable = (String)TargetVariableComboBox.SelectedValue,
          Values = _values
        };
      }
    }

    private IList<MLVariableInfo> _selectedTimeseries;
    private IList<MLVariableInfo> _selectedDoubleArrays;

    public IEnumerable<MLVariableInfo> SelectedVariables {
      get {
        return _variablesLoader.SelectedVariables;
      }
    }

    public RegressionMatlabImportDialog() {
      InitializeComponent();

      _selectedTimeseries = new List<MLVariableInfo>();
      _selectedDoubleArrays = new List<MLVariableInfo>();
      _values = new Dataset();

      this.FormClosed += (s, e) => DisposeMatlabConnector();
      OpenFileButton.Click += OpenFileButtonClick;

      DatatypeSelectorTabControl.SelectedIndexChanged += (s, e) => BeginInvoke((MethodInvoker)(() => DatatypeSelectorTabControlTabIndexChanged(s, e)));

      LoadValuesButton.Click += LoadValuesButtonClick;
      TrainingTestTrackBar.ValueChanged += TrainingTestTrackBarValueChanged;

      StatusChangedEvent += (s, e) => BeginInvoke((MethodInvoker)(() => StatusLabel.Text = e.Value));
      ErrorOccuredEvent += (s, e) => BeginInvoke((MethodInvoker)(() => {
        OkButton.Enabled = false;
        ErrorTextBox.Text = e.Value;
        ErrorTextBox.Visible = true;
      }));

      _timeseriesLoader = new MLTimeseriesLoader(this, TimeseriesListBox);
      _timeseriesLoader.NumberOfSelectedVariablesChanged += NumberOfSelectedVariablesChanged;
      _doubleArraysLoader = new MLDoubleArrayLoader(this, DoubleArraysListBox);
      _doubleArraysLoader.NumberOfSelectedVariablesChanged += NumberOfSelectedVariablesChanged;

      _variablesLoader = _timeseriesLoader;

    }

    #region Methods for Events

    private void NumberOfSelectedVariablesChanged(object s, EventArgs<int> e) {
      LoadValuesButton.Enabled = e.Value > 0;
    }

    private void DatatypeSelectorTabControlTabIndexChanged(object s, EventArgs e) {
      switch (DatatypeSelectorTabControl.SelectedIndex) {
        case TAB_INDEX_TIMESERIES:
          _variablesLoader = _timeseriesLoader;
          break;
        case TAB_INDEX_DOUBLE_ARRAYS:
          _variablesLoader = _doubleArraysLoader;
          break;
      }

      LoadValuesButton.Enabled = _variablesLoader.SelectedVariables.Count() > 0;
    }

    private void LoadValuesButtonClick(object sender, EventArgs e) {
      _cts.Cancel();
      _cts = new CancellationTokenSource();
      LoadValuesAsync();
    }

    private void OpenFileButtonClick(object sender, EventArgs e) {
      if (openFileDialog.ShowDialog(this) != DialogResult.OK) {
        return;
      }
      GetVariableNamesAsync();
      ErrorTextBox.Visible = false;
    }

    private void TrainingTestTrackBarValueChanged(object sender, System.EventArgs e) {
      TrainingLabel.Text = "Training: " + TrainingTestTrackBar.Value + " %";
      TestLabel.Text = "Test: " + (TrainingTestTrackBar.Maximum - TrainingTestTrackBar.Value) + " %";
    }
    #endregion

    /// <summary>
    /// Fires the ErrorOccuredEvent with the given text message.
    /// </summary>
    /// <param name="message"></param>
    private void ErrorOccured(string message) {
      ErrorOccuredEvent?.Invoke(this, new EventArgs<string>(message));
    }

    /// <summary>
    /// Fires the StatusChangedEvent.
    /// </summary>
    /// <param name="text"></param>
    private void UpdateStatus(string text) {
      StatusChangedEvent?.Invoke(this, new EventArgs<string>(text));
    }

    #region Opening and disposing of the Matlab connector
    private void OpenMatlabConnector() {
      if (_mlConnector == null) {
        _mlConnector = MatlabApiFactory.CreateMatlabConnector();
        _mlConnector.ErrorOccuredEvent += ErrorOccured;
      }
    }

    private async void DisposeMatlabConnector() {
      UpdateStatus("Closing Matlab");
      await Task.Run(() => {
        if (_mlConnector != null) {
          _mlConnector.Dispose();
        }
      });
    }
    #endregion


    /// <summary>
    /// This method reads all available variables form the selected matlab scirpt and puts them into the list view.
    /// </summary>
    private async void GetVariableNamesAsync() {
      UpdateStatus("Opening Matlab");
      var path = openFileDialog.FileName;
      ProblemTextBox.Text = path;
      var variables = await Task.Run(() => {
        OpenMatlabConnector();
        return _mlConnector.GetVariablesFromScript(path);
      });

      UpdateStatus("Loading variable names");
      _timeseriesLoader.DisplayVariables(variables);
      _doubleArraysLoader.DisplayVariables(variables);
      UpdateStatus("Done");
    }

    private async void LoadValuesAsync() {
      UpdateStatus("Loading values from Matlab");
      try {
        // As there can be a huge amount of data, it should be freed before reallocating it.
        OkButton.Enabled = false;
        _values = new Dataset();
        PreviewDatasetMatrix.Content = _values;
        TargetVariableComboBox.DataSource = new List<string>();
        TargetVariableComboBox.SelectedText = "";
        GC.Collect();
        var token = _cts.Token;
        var ds = await Task.Run<Dataset>(() => _variablesLoader.GetPreviewDataset(_mlConnector, token), token);
        GC.Collect();

        if (ds != null) {
          _values = ds;
          PreviewDatasetMatrix.Content = _values;
          TargetVariableComboBox.DataSource = _values.VariableNames;

          ErrorTextBox.Text = String.Empty;
          ErrorTextBox.Visible = false;
          OkButton.Enabled = true;
        }        
      } catch (Exception ex) {
        if (ex is IOException || ex is InvalidOperationException || ex is ArgumentException) {
          ErrorOccured(ex.Message);
        } else if (ex is OutOfMemoryException) {
          ErrorOccured(ex.Message + " Amount of the given data is too big.");
        } else {
          throw;
        }
      }
      UpdateStatus("Done");
    }
  }
}