/**************************************************************************
 *                                                                        *
 *  Copyright:   (c) 2016-2017, Florin Leon                               *
 *  E-mail:      florin.leon@tuiasi.ro                                    *
 *  Website:     http://florinleon.byethost24.com/lab_ia.htm              *
 *  Description: Neural networks: decision regions                        *
 *               (Artificial Intelligence lab 12)                         *
 *                                                                        *
 *  This code and information is provided "as is" without warranty of     *
 *  any kind, either expressed or implied, including but not limited      *
 *  to the implied warranties of merchantability or fitness for a         *
 *  particular purpose. You are free to use this source code in your      *
 *  applications as long as the original copyright notice is included.    *
 *                                                                        *
 **************************************************************************/

using System;
using System.Drawing;
using System.Globalization;
using System.Windows.Forms;

namespace DecisionRegions
{
    public partial class MainForm : Form
    {
        /// <summary>
        /// Delegat care calculeaza iesirea retelei in functie de tipul ei: perceptron cu un singur strat sau perceptron multistrat
        /// </summary>
        private delegate double NetworkFunction(double x, double y);

        /// <summary>
        /// Delegat care reprezinta functia de activare a retelei: prag, semiliniara sau sigmoida unipolara
        /// </summary>
        private delegate double ActivationFunction(double x, double prag);

        private NetworkFunction networkFunction;
        private ActivationFunction activationFunction;

        public MainForm()
        {
            InitializeComponent();

            comboBoxType.SelectedIndex = 0;
            comboBoxActivation.SelectedIndex = 0;

            activationFunction = StepActivation; // functia de activare implicita este functia prag
            networkFunction = SLP; // reteaua implicita este perceptronul cu un singur strat
        }

        /// <summary>
        /// Functia de activare prag
        /// </summary>
        private double StepActivation(double x, double prag)
        {
            if (x < prag) return 0;
            return 1;
        }

        /// <summary>
        /// Functia de activare semiliniara
        /// </summary>
        private double SemiliniarActivation(double x, double prag)
        {
            if (x <= prag) return 0;
            if (x >= prag * 2) return 1;
            return x / prag - 1;
        }

        /// <summary>
        /// Functia de activare sigmoida unipolara
        /// </summary>
        private double SigmoidActivation(double x, double prag)
        {
            return 1 / (1 + Math.Exp(-x + prag));
        }

        private double w13, w23, w14, w24, t3, t4, w35, w45, t5; // ponderile si pragurile

        /// <summary>
        /// Citeste valorile ponderilor si pragurilor din interfata grafica
        /// </summary>
        private void ReadParametersFromGUI()
        {
            if (comboBoxType.SelectedIndex == 0) // SLP
            {
                w13 = ConvertToDouble(textBoxSw13.Text);
                w23 = ConvertToDouble(textBoxSw23.Text);
                t3 = ConvertToDouble(textBoxSt3.Text);
            }
            else if (comboBoxType.SelectedIndex == 1) // MLP
            {
                w13 = ConvertToDouble(textBoxMw13.Text);
                w23 = ConvertToDouble(textBoxMw23.Text);
                w14 = ConvertToDouble(textBoxMw14.Text);
                w24 = ConvertToDouble(textBoxMw24.Text);
                t3 = ConvertToDouble(textBoxMt3.Text);
                t4 = ConvertToDouble(textBoxMt4.Text);

                w35 = ConvertToDouble(textBoxMw35.Text);
                w45 = ConvertToDouble(textBoxMw45.Text);
                t5 = ConvertToDouble(textBoxMt5.Text);
            }
        }

        /// <summary>
        /// Converteste numerele citite ca text din interfata in valori reale
        /// </summary>
        private double ConvertToDouble(string s)
        {
            if (s.Contains(","))
                MessageBox.Show("Folositi punctul ca separator! (" + s + ")");

            try
            {
                CultureInfo ci = (CultureInfo)(CultureInfo.CurrentCulture.Clone());
                ci.NumberFormat.NumberDecimalSeparator = ".";
                return Convert.ToDouble(s, ci);
            }
            catch
            {
                MessageBox.Show("Numar invalid: " + s);
                return 0;
            }
        }

        /// <summary>
        /// Metoda care calculeaza iesirea perceptronului cu un singur strat pentru intrarile x si y
        /// </summary>
        private double SLP(double x1, double x2)
        {
            // double s = suma ponderata a intrarilor cu scaderea pragului, conform ecuatiei 1 din laborator
            // se folosesc ponderile w13, w23 si pragul t3
            // in functie de alegerea utilizatorului, activationFunction poate fi: StepActivation, SemiliniarActivation sau SigmoidActivation
            // functia de activare este setata in evenimentul comboBoxActivation_SelectedIndexChanged
            // in metoda curenta se lucreaza in mod generic doar cu "activationFunction": return activationFunction(s);

            if (t3 == 0) t3 = 1.5;

            return activationFunction(x1 * w13 + x2 * w23, t3);
        }

        /// <summary>
        /// Metoda care calculeaza iesirea perceptronului cu doi neuroni in stratul ascuns pentru intrarile x si y
        /// </summary>
        private double MLP(double x1, double x2)
        {
            double nod3 = activationFunction(x1 * w13 + x2 * w23, t3);
            double nod4 = activationFunction(x1 * w14 + x2 * w24, t4);
            return activationFunction(nod3 * w35 + nod4 * w45, t5);

            // pentru fiecare neuron, se calculeaza suma intrarilor ponderate, se scade pragul si se aplica functia de activare
            // neuronul 5 are ca intrari iesirile neuronilor 3 si 4
            // iesirea neuronului 5 este iesirea retelei
        }

        /// <summary>
        /// Selecteaza tipul de perceptron atunci cand utilizatorul il alege din combobox
        /// </summary>
        private void comboBoxType_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (comboBoxType.SelectedIndex == 0)
            {
                groupBoxSLP.Enabled = true;
                groupBoxMLP.Enabled = false;
                networkFunction = SLP;
            }
            else if (comboBoxType.SelectedIndex == 1)
            {
                groupBoxSLP.Enabled = false;
                groupBoxMLP.Enabled = true;
                networkFunction = MLP;
            }
        }

        /// <summary>
        /// Selecteaza functia de activare atunci cand utilizatorul o alege din combobox
        /// </summary>
        private void comboBoxActivation_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (comboBoxActivation.SelectedIndex == 0)
                activationFunction = StepActivation;
            else if (comboBoxActivation.SelectedIndex == 1)
                activationFunction = SemiliniarActivation;
            else if (comboBoxActivation.SelectedIndex == 2)
                activationFunction = SigmoidActivation;
        }

        /// <summary>
        /// Calculeaza si afiseaza iesirile retelei pentru combinatiile de intrari (0,0), (0,1), (1,0) si (1,1)
        /// </summary>
        private void ComputeResults()
        {
            textBoxResults.Clear();
            for (int x1 = 0; x1 <= 1; x1++)
                for (int x2 = 0; x2 <= 1; x2++)
                {
                    double y = networkFunction(x1, x2);
                    textBoxResults.AppendText(string.Format("{0}   {1}   {2:F3}\r\n", x1, x2, y));
                }
        }

        /// <summary>
        /// Evenimentul de click al butonului "Calculeaza"
        /// </summary>
        private void buttonCompute_Click(object sender, EventArgs e)
        {
            ReadParametersFromGUI();
            ComputeResults();
            pictureBoxRegions.Refresh();
        }

        /// <summary>
        /// Desenarea regiunilor de decizie pentru retea in picturebox. Intrarile retelei sunt aici numere reale din intervalul [0,1].
        /// </summary>
        private void pictureBoxRegions_Paint(object sender, PaintEventArgs e)
        {
            int size = pictureBoxRegions.Width; // desenul este un patrat
            Bitmap b = new Bitmap(size, size);
            Graphics g = Graphics.FromImage(b);
            g.Clear(Color.White);

            for (int i = 0; i < size; i++)
                for (int j = 0; j < size - 1; j++)
                {
                    double x1 = (double)j / (double)size;
                    double x2 = (double)i / (double)size;
                    double y = networkFunction(x1, x2);
                    int gray = (int)(y * 255);
                    Color c = Color.FromArgb(gray, gray, gray);
                    g.DrawLine(new Pen(c), i, size - j, i, size - j + 1);
                    Application.DoEvents();
                }

            e.Graphics.DrawImage(b, 0, 0);
        }
    }
}