source: branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/VariableInteractionNetworkView.cs @ 12568

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using HeuristicLab.Common;
using HeuristicLab.Data;
using HeuristicLab.MainForm;
using HeuristicLab.MainForm.WindowsForms;
using HeuristicLab.Optimization;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DataAnalysis.Symbolic;
using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
using System.Collections;

namespace HeuristicLab.VariableInteractionNetworks.Views
{
    [View("Variable Interaction Network")]
    [Content(typeof(RunCollection), IsDefaultView = false)]

    public sealed partial class VariableInteractionNetworkView : AsynchronousContentView
    {
        private const string variableImpactResultName = "Variable impacts";
        private const string TrainingBestSolutionParameterName = "Best training solution";

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

        public VariableInteractionNetworkView()
        {
            InitializeComponent();
        }

        internal class NoFocusTrackBar : System.Windows.Forms.TrackBar
        {
            [System.Runtime.InteropServices.DllImport("user32.dll")]
            public extern static int SendMessage(IntPtr hWnd, uint msg, int wParam, int lParam);

            private static int MakeParam(int loWord, int hiWord)
            {
                return (hiWord << 16) | (loWord & 0xffff);
            }

            protected override void OnGotFocus(EventArgs e)
            {
                base.OnGotFocus(e);
                SendMessage(this.Handle, 0x0128, MakeParam(1, 0x1), 0);
            }
        }

        #region events

        //  #region Event Handlers (Content)
        protected override void OnContentChanged()
        {
            base.OnContentChanged();
            if (Content == null)
            {
                // TODO: Add code when content has been changed and is null
            }
            else
            {
                // TODO: Add code when content has been changed and is not null
                viewHost2.Content = CalculateNodeImportance(CalculateAdjacencyMatrix());
                var adjMatrix = CalculateAdjacencyMatrix();
                viewHost1.Content = adjMatrix;
                viewHost3.Content = (DoubleMatrix)adjMatrix.Clone();
                trackBar1.Minimum = (int)(1000 * GetMinNonNullElement(adjMatrix));
                trackBar1.Maximum = (int)(1000 * (adjMatrix.Max()));
            }
        }
        #endregion

        protected override void SetEnabledStateOfControls()
        {
            base.SetEnabledStateOfControls();
            // TODO: Enable or disable controls based on whether the content is null or the view is set readonly
        }

        #region Event Handlers (child controls)
        // TODO: Put event handlers of child controls here.
        #endregion

        private DoubleMatrix CalculateAdjacencyMatrix()
        {
            var runCollection = Content;
            var inputVariables = ((IRegressionProblemData)runCollection.First().Parameters["ProblemData"]).InputVariables.Select(x => x.Value).ToList();
            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).OrderBy(x => inputVariables.IndexOf(x.Key)).ToList();

            var allVariableImpacts = runCollection.Select(run => (DoubleMatrix)run.Results[variableImpactResultName]);
            var variableNames = (from variableImpact in allVariableImpacts
                                 from variableName in variableImpact.RowNames
                                 select variableName).Distinct().ToArray();
           
            var vars = new List<Tuple<int, string>>();
            
            var allowedInputs = ((IRegressionProblemData)groupRunCollection[0].First().Parameters["ProblemData"]).AllowedInputVariables.ToList();

            var adjMatrix = new DoubleMatrix(variableNames.Length, variableNames.Length);

            for (int i = 0; i < adjMatrix.Rows; ++i)
            {
                int inputIndex = allowedInputs.FindIndex(x => x == variableNames[i]);
                vars.Add(new Tuple<int, string>(inputIndex, variableNames[i]));
            }

            vars.Sort((a, b) => a.Item1.CompareTo(b.Item1));

            for (int i = 0; i < adjMatrix.Rows; ++i)
            {
                variableNames[i] = vars[i].Item2;
            }
            adjMatrix.RowNames = variableNames;
            adjMatrix.ColumnNames = adjMatrix.RowNames;

            for (int j = 0; j < groupRunCollection.Count; ++j)
            {
                var g = groupRunCollection[j];
                
                var matrix = CalculateAdjacencyRows(g);
                var variables = new List<double>();

                for (int i = 0; i < matrix.Columns; ++i)
                {
                    variables.Add(matrix[0, i]);
                }
                
                for (int i = 0; i < variables.Count; ++i)
                {
                    if (i == j)
                    {
                        adjMatrix[i, i] = 0;
                        variables.Insert(i, 0);
                    }
                    else
                        adjMatrix[j, i] = variables[i];
                }
            }
            return adjMatrix;
        }

        private DoubleMatrix CalculateAdjacencyRows(IEnumerable<IRun> runs)
        {
            var runNames = runs.Select(x => x.Name).ToArray();
            var runsArray = runs.ToArray();
            DoubleMatrix varImpactMatrix = CalculateVariableImpactMatrix(runsArray, runNames);
          
            var targetMatrix = new DoubleMatrix(1, varImpactMatrix.Rows);

            for (int i = 0; i < varImpactMatrix.Rows; ++i)
            {
                targetMatrix[0, i] = varImpactMatrix[i, runNames.Length];
            }

            targetMatrix.RowNames = new[] { "Impacts" };
            targetMatrix.ColumnNames = varImpactMatrix.RowNames;
            return targetMatrix;
        }

        private DoubleMatrix UpdateAdjacencyMatrixByThresholdAndTargetVariable(double threshold, string targetVariable, DoubleMatrix adjMatrix)
        {
            var originalMatrix = (DoubleMatrix)viewHost1.Content;
            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
            string[] targets = adjMatrix.RowNames.ToArray();
            var targetIndex = Array.IndexOf(targets, targetVariable);

            for (int j = 0; j < groupRunCollection.Count; ++j)
            {
                double originalValue = originalMatrix[targetIndex, j];
                adjMatrix[targetIndex, j] = (originalValue <= Math.Max(threshold, Double.Parse(genThreshold.Text))) ? 0 : originalValue;
            }
            return adjMatrix;
        }

        private DoubleMatrix UpdateAdjacencyMatrixByThreshold(double threshold, DoubleMatrix adjMatrix)
        {
            var originalMatrix = (DoubleMatrix)viewHost1.Content;
            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();

            for (int i = 0; i < adjMatrix.Rows; ++i)
            {
                for (int j = 0; j < adjMatrix.Columns; ++j)
                {
                    double originalValue = originalMatrix[i, j];
                    adjMatrix[i, j] = originalValue <= threshold ? 0 : originalValue;
                }
            }
            return adjMatrix;
        }

        private double GetMinNonNullElement(DoubleMatrix adjMatrix)
        {
            double min = adjMatrix.Max();
            for (int i = 0; i < adjMatrix.Rows; i++)
            {
                for (int j = 0; j < adjMatrix.Columns; j++)
                {                  
                    min = (min > adjMatrix[i, j] && adjMatrix[i, j] != 0) ? adjMatrix[i, j] : min;
                }
            }
            return min;
        }

        private double GetMaxFromRow(int rowIndex, DoubleMatrix adjMatrix)
        {
            double max = adjMatrix.Min();
            for (int j = 0; j < adjMatrix.Columns; ++j)
            {
                max = (max < adjMatrix[rowIndex, j] && adjMatrix[rowIndex, j] != 0) ? adjMatrix[rowIndex, j] : max;
            }
            return max;
        }

        private DoubleMatrix CalculateNodeImportance(DoubleMatrix adjMatrix)
        {
            DoubleMatrix nodeImportance = new DoubleMatrix(adjMatrix.Rows, 1);
            var variables = new List<Tuple<string, double>>();
            var rowNames = adjMatrix.RowNames.ToList();
            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
            double[] meanQuality = new double[groupRunCollection.Count];

            for (int j = 0; j < groupRunCollection.Count; ++j)
            {
                var g = groupRunCollection[j];
                meanQuality[j] = g.Average(x => ((IRegressionSolution)x.Results[TrainingBestSolutionParameterName]).TrainingRSquared);
            }

            for (int i = 0; i < adjMatrix.Columns; ++i)
            {
                for (int j = 0; j < adjMatrix.Rows; ++j)
                {
                    nodeImportance[i, 0] += adjMatrix[j, i] * meanQuality[j];
                }
                nodeImportance[i, 0] /= (adjMatrix.Rows - 1);
                variables.Add(new Tuple<string, double>(rowNames[i], nodeImportance[i, 0]));
            }

            variables.Sort((b, a) => a.Item2.CompareTo(b.Item2));

            for (int i = 0; i < nodeImportance.Rows; ++i)
            {
                nodeImportance[i, 0] = variables[i].Item2;
                rowNames[i] = variables[i].Item1;
            }

            nodeImportance.RowNames = rowNames;
            nodeImportance.ColumnNames = new[] { "Node Importance" };
            return nodeImportance;
        }

        //modified from RunCollectionVariableImpactView
        private DoubleMatrix CalculateVariableImpactMatrix(IRun[] runs, string[] runNames)
        {
            IEnumerable<DoubleMatrix> allVariableImpacts = (from run in runs
                                                            select run.Results[variableImpactResultName]).Cast<DoubleMatrix>();
            IEnumerable<string> variableNames = (from variableImpact in allVariableImpacts
                                                 from variableName in variableImpact.RowNames
                                                 select variableName).Distinct();

            // filter variableNames: only include names that have at least one non-zero value in a run
            List<string> variableNamesList = (from variableName in variableNames
                                              where GetVariableImpacts(variableName, allVariableImpacts).Any(x => !x.IsAlmost(0.0))
                                              select variableName).ToList();

            List<string> columnNames = new List<string>(runNames);
            columnNames.Add("Mean");

            int numberOfRuns = runs.Length;

            DoubleMatrix matrix = new DoubleMatrix(variableNamesList.Count, numberOfRuns + 1);
            matrix.SortableView = true;
            matrix.ColumnNames = columnNames;

            List<List<double>> variableImpactsOverRuns = (from variableName in variableNamesList
                                                          select GetVariableImpacts(variableName, allVariableImpacts).ToList()).ToList();

            for (int row = 0; row < variableImpactsOverRuns.Count; row++)
            {
                matrix[row, numberOfRuns] = Math.Round(variableImpactsOverRuns[row].Average(), 3);
            }

            // fill matrix with impacts from runs
            for (int i = 0; i < runs.Length; i++)
            {
                IRun run = runs[i];
                DoubleMatrix runVariableImpacts = (DoubleMatrix)run.Results[variableImpactResultName];
                for (int j = 0; j < runVariableImpacts.Rows; j++)
                {
                    int rowIndex = variableNamesList.FindIndex(s => s == runVariableImpacts.RowNames.ElementAt(j));
                    if (rowIndex > -1)
                    {
                        matrix[rowIndex, i] = Math.Round(runVariableImpacts[j, 0], 3);
                    }
                }
            }

            // sort by median
            var sortedMatrix = (DoubleMatrix)matrix.Clone();
            var sortedIndexes = from i in Enumerable.Range(0, sortedMatrix.Rows)
                                orderby matrix[i, numberOfRuns]
                                select i;

            int targetIndex = 0;
            foreach (var sourceIndex in sortedIndexes)
            {
                for (int c = 0; c < matrix.Columns; c++)
                    sortedMatrix[targetIndex, c] = matrix[sourceIndex, c];
                targetIndex++;
            }
            sortedMatrix.RowNames = sortedIndexes.Select(i => variableNamesList[i]);

            var vars = new List<Tuple<int, string, double>>();
            var rowNames = sortedMatrix.RowNames.ToList();

            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
            var inputs = ((IRegressionProblemData)groupRunCollection[0].First().Parameters["ProblemData"]).InputVariables.ToList();
            List<string> inp = (from input in inputs 
                                select (input.ToString())).ToList();

            for (int i = 0; i < sortedMatrix.Rows; ++i)
            {
                int inputIndex = inp.FindIndex(x => x == rowNames[i]);
                vars.Add(new Tuple<int, string, double>(inputIndex, rowNames[i], sortedMatrix[i, runNames.Length]));
            }

                vars.Sort((a, b) => a.Item1.CompareTo(b.Item1));
               
            for (int i = 0; i < sortedMatrix.Rows; ++i)
            {
                sortedMatrix[i, runNames.Length] = vars[i].Item3;
                rowNames[i] = vars[i].Item2;
            }
            sortedMatrix.RowNames = rowNames;

            return sortedMatrix;
        }

        //taken from RunCollectionVariableImpactView
        private IEnumerable<double> GetVariableImpacts(string variableName, IEnumerable<DoubleMatrix> allVariableImpacts)
        {
            foreach (DoubleMatrix runVariableImpacts in allVariableImpacts)
            {
                int row = 0;
                foreach (string rowName in runVariableImpacts.RowNames)
                {
                    if (rowName == variableName)
                        yield return runVariableImpacts[row, 0];
                    row++;
                }
            }
        }

        private void trackBar1_ValueChanged(object sender, EventArgs e)
        {
            genThreshold.Text = (0.001 * trackBar1.Value).ToString();
            textBox1.Text = (0.001 * trackBar1.Minimum).ToString();
            textBox2.Text = (0.001 * trackBar1.Maximum).ToString();
            viewHost3.Content = UpdateAdjacencyMatrixByThreshold(0.001 * trackBar1.Value, (DoubleMatrix)viewHost3.Content);
        }

        private void mouseDownEvent(TrackBar tb, MouseEventArgs e)
        {
                double percentage = (double)e.X / (double)(tb.Width - 6);
                double clickPos = percentage * (tb.Maximum - tb.Minimum);
                try
                {
                    tb.Value = (int)clickPos + tb.Minimum;
                }
                catch
                {
                    MessageBox.Show("Value outside range!");
                    return;
                }
        }

        private void trackBar1_MouseDown(object sender, MouseEventArgs e)
        {
            mouseDownEvent(trackBar1, e);
        }

        private void trackBar2_MouseDown(object sender, MouseEventArgs e)
        {
            if (targetVariablesCombo.SelectedIndex < 0)
            {
                return;
            }
            else
            {
                mouseDownEvent(trackBar2, e);
            }
        }

        private void trackBar2_ValueChanged(object sender, EventArgs e)
        {
            targetThreshold.Text = (0.001 * trackBar2.Value).ToString();

            if (targetVariablesCombo.SelectedIndex < 0)
            {
                MessageBox.Show("Please select target variable!");
                return;
            }
            else
            {
                string selectedItem = (string)targetVariablesCombo.Items[targetVariablesCombo.SelectedIndex];
                viewHost3.Content = UpdateAdjacencyMatrixByThresholdAndTargetVariable(0.001 * trackBar2.Value, selectedItem, (DoubleMatrix)viewHost3.Content);
            }
        }

        private void genThresholdEvent()
        {
            this.errorProvider.SetError(genThreshold, "");

            if (genThreshold.Text != "")
            {
                if (Double.Parse(genThreshold.Text) >= GetMinNonNullElement((DoubleMatrix)viewHost1.Content) && Double.Parse(genThreshold.Text) <= ((DoubleMatrix)viewHost1.Content).Max())
                {
                    genThreshold.Select(genThreshold.Text.Length, 0);
                    trackBar1.Value = (int)(1000 * Double.Parse(genThreshold.Text));
                    viewHost3.Content = UpdateAdjacencyMatrixByThreshold(Double.Parse(genThreshold.Text), (DoubleMatrix)viewHost3.Content);
                }
                else
                {
                    this.errorProvider.SetError(genThreshold, "Value out of range!");
                }
            }
            else
            {
                MessageBox.Show("Please select a threshold!");
                this.errorProvider.SetError(genThreshold, "");
                return;
            }
        }

        private void genThreshold_TextChanged(object sender, EventArgs e)
        {
            genThresholdEvent();
        }

        private void genThreshold_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
                genThresholdEvent();        
        }

        private void targetThresholdEvent()
        {
            this.errorProvider2.SetError(targetThreshold, "");

            if (targetVariablesCombo.SelectedIndex < 0)
            {
                return;
            }
            else
            {
                string selectedItem = (string)targetVariablesCombo.Items[targetVariablesCombo.SelectedIndex];
                if (Double.Parse(targetThreshold.Text) >= Double.Parse(textBox3.Text) && Double.Parse(targetThreshold.Text) <= Double.Parse(textBox4.Text))
                {
                    trackBar2.Value = (int)(1000 * Double.Parse(targetThreshold.Text));
                }
                else
                {
                    this.errorProvider2.SetError(targetThreshold, "Value out of range!");
                    return;
                }
            }
        }

        private void targetThreshold_TextChanged(object sender, EventArgs e)
        {
            targetThresholdEvent();
        }

        private void targetThreshold_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                targetThresholdEvent();
            }
        }

        private void targetVariablesCombo_Dropdown(object sender, System.EventArgs e)
        {
            targetVariablesCombo.Items.Clear();
            string[] targetVariables = ((DoubleMatrix)viewHost3.Content).RowNames.ToArray();
            targetVariablesCombo.Items.AddRange(targetVariables);
        }

        private void targetVariablesCombo_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            var targetIndex = targetVariablesCombo.SelectedIndex;
            string selectedItem = (string)targetVariablesCombo.Items[targetIndex];
            trackBar2.Minimum = 0;
            trackBar2.Maximum = (int)(1000 * GetMaxFromRow(targetIndex, (DoubleMatrix)viewHost1.Content));
            textBox3.Text = trackBar2.Minimum.ToString();
            textBox4.Text = (0.001 * trackBar2.Maximum).ToString();
            UpdateAdjacencyMatrixByThresholdAndTargetVariable(0.001 * trackBar2.Value, selectedItem, (DoubleMatrix)viewHost3.Content);
        }
    }
}