Form1.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;

namespace Clusterization_algorithms
{
    public partial class Form1 : Form
    {
        private GraphicsController _graphicsController;
        private Graphics _graphics;
        private Forel _forel;
        private K_means _k_means;
        private RouteBuilder _routeBuilder;
        private EnergyCalculator _energyCalculator;
        private Dictionary<Point, int> _allPoints;
        private Dictionary<Point, int> _allPointsClustered;
        private List<Point> _clusterCenters = new List<Point> { };
        private int _forelRadius;
        private ClusterizationType _clusterizationType;

#region Default values

        private int _defaultPointsCount = 100; // count nodes generated on map
        private int _defaultClusterRadius = 100; // round forel cluster radius
        private int _defaultSeedCount = 2; // count of centroids in k-means
        
        private int _fppwrDefaultNetRows = 6;
        private int _fppwrDefaultNetCols = 6;

#endregion

#region Counters

        int loop_count = 0; // times was data collected from map by station
        double map_usedE = 0; // used energy in current loop
        double map_last_usedE = 0; // used energy in last loop

#endregion

        public Form1()
        {
            InitializeComponent();

            _graphics = pictBoxArea.CreateGraphics();
            _graphicsController = new GraphicsController(_graphics);

            _forel = new Forel(_graphicsController);
            _k_means = new K_means(_graphicsController);
            _routeBuilder = new RouteBuilder();
        }

        private void btnGenPoints_Click(object sender, EventArgs e)
        {
            DisableAll();
            EnableClusterization();
            Labels_ClearText();
            buttonReloadMap.Enabled = true;
            buttonEnergyModel.Enabled = true;

            if (checkBoxAllowGeneratePoints.Checked == true)
            {
                if (Int32.TryParse(textBoxSetPointsCount.Text, out int pointsCount))
                {
                    _allPoints = Calculator.GeneratePoints(pointsCount, pictBoxArea.Width, pictBoxArea.Height);
                }
                else
                {
                    _allPoints = Calculator.GeneratePoints(_defaultPointsCount, pictBoxArea.Width, pictBoxArea.Height);
                }
            }

            _allPointsClustered = _allPoints;
            _routeBuilder.RouteList = new List<Point> { };
            _energyCalculator = new EnergyCalculator(_graphicsController, _allPoints);

            ClearFields();
        }

        public void ClearFields()
        {
            _graphics.Clear(Color.White);
            textBoxInfo.Clear();
            _graphicsController.DrawPointDictionary(_allPoints);
            PrintToTextBoxInfo(_allPoints);
            _clusterCenters.Clear();
        }

        private void btnKMeans_Click(object sender, EventArgs e)
        {
            _clusterizationType = ClusterizationType.K_means;
            Labels_ClearText();
            ClearFields();
            EnableRouteCalculating();
            DisallowSelectClusterAndCalculateEnergy();

            SeedGenerator seedGenerator = new SeedGenerator();
            seedGenerator.SetPoints(_allPoints);
            seedGenerator._seedCount = _defaultSeedCount;

            if (Int32.TryParse(textBoxSetSeedsCount.Text, out int seedCount))
            {
                seedGenerator._seedCount = seedCount;
            }

            List<Point> seeds = seedGenerator.GetSeeds();

            _k_means.SetPoints(_allPoints);
            _k_means.Seeds = seeds;
            _k_means.StartK_means();

            _clusterCenters = _k_means.Seeds;

            PrintToTextBoxInfo(_k_means.GetPoints());
            _allPointsClustered = _k_means.GetPoints();
        }

        private void btnForel_Click(object sender, EventArgs e)
        {
            _clusterizationType = ClusterizationType.Forel;
            Labels_ClearText();
            ClearFields();
            EnableRouteCalculating();
            DisallowSelectClusterAndCalculateEnergy();

            _forel.SetPoints(_allPoints);
            _forel.Radius = _defaultClusterRadius;

            if (Int32.TryParse(textBoxSetRadius.Text, out int r))
            {
                _forel.Radius = r;
            }

            _forelRadius = _forel.Radius;
            _forel.StartForel();
            _clusterCenters = _forel.ListOfClastersCenter;

            PrintToTextBoxInfo(_forel.GetPoints());
            _allPointsClustered = _forel.GetPoints();
        }

        private void btnClustersRoute_Click(object sender, EventArgs e)
        {
            AllowSelectClusterAndCalculateEnergy();

            if (_clusterCenters.Count == 0)
            {
                _routeBuilder.SetPoints(Calculator.DictionaryToList(_allPoints));
            }
            else
            {
                _routeBuilder.SetPoints(_clusterCenters);
            }

            _routeBuilder.CalculateRouteByConvexHullInsertion();
            _graphicsController.DrawRoute(_routeBuilder.RouteList, Color.Yellow);
            labelRoute.Text = "Route _length: " + Math.Round(Calculator.CalcRouteLength(_routeBuilder.RouteList), 3);

            PrintToTextBoxInfo(_allPointsClustered);
        }

        private void btnSpiralRoute_Click(object sender, EventArgs e)
        {
            AllowSelectClusterAndCalculateEnergy();
            btnConvexHull.Enabled = false;

            if (_clusterCenters.Count > 0)
            {
                _routeBuilder.SetPoints(_clusterCenters);
            }
            else
            {
                _routeBuilder.SetPoints(Calculator.DictionaryToList(_allPoints));
            }

            _routeBuilder.JarvisMarch(true);
            _graphicsController.DrawRoute(_routeBuilder.Convex_hull, Color.Aqua);
            labelRoute.Text = "Route _length: " + Math.Round(Calculator.CalcRouteLength(_routeBuilder.Convex_hull), 3);
        }

        private void btnGenPoints_MouseMove(object sender, MouseEventArgs e)
        {
            btnGenPoints.BackColor = Color.LightGreen;
        }

        private void btnGenPoints_MouseLeave(object sender, EventArgs e)
        {
            btnGenPoints.BackColor = Color.DarkGray;
        }

        private void btnBruteForce_Click(object sender, EventArgs e)
        {
            AllowSelectClusterAndCalculateEnergy();
            List<Point> route = new List<Point> { };

            if (_clusterCenters.Count > 0)
            {
                route = _routeBuilder.CalculateRouteBruteForce(_clusterCenters);
            }
            else
            {
                route = _routeBuilder.CalculateRouteBruteForce(Calculator.DictionaryToList(_allPoints));
            }
                
            _graphicsController.DrawRoute(route, Color.Blue);
            labelRoute.Text = "Route _length: " + Math.Round(Calculator.CalcRouteLength(route), 3);
            PrintToTextBoxInfo(_allPointsClustered);
        }

        private void btn1ClusterOn_Click(object sender, EventArgs e)
        {
            DisableAll();
            btnDeselectCluster.Enabled = true;
            _graphics.Clear(Color.White);
            int clusterNum = 1;

            if (Int32.TryParse(textBoxSetClusterNum.Text, out int num)) // get cluster number
            {
                clusterNum = num;
            }

            List<Point> cluster = Calculator.GetClusterList(clusterNum, _allPointsClustered);
            PrintToTextBoxInfo(Calculator.GetClusterDictionary(clusterNum, _allPointsClustered));

            Point center = Calculator.FindCentroid(cluster);    // find cluster center
            List<Point> routeFragment = Calculator.GetRouteFragment(center, _routeBuilder.RouteList); // find part route go throught cluster

            //< Move all points to the start coordinate
            Point vector = new Point(center.X - _forelRadius, center.Y - _forelRadius);
            center = new Point(_forelRadius, _forelRadius);
            Calculator.MovePointList(cluster, vector);
            Calculator.MovePointList(routeFragment, vector);
            //>

            //< Calculate zoom coefficient. 
            int size = pictBoxArea.Height;
            if (pictBoxArea.Width < size)
            {
                size = pictBoxArea.Width;
            }

            double zoom = size / (_forelRadius * 2.0); // proportion between cluster zone size and field size
            //>

            //< Calculate new points position, radius with zooming
            int newRadius = (int)Math.Round(_forelRadius * zoom);
            Point newCenter = new Point((int)Math.Round(center.X * zoom), (int)Math.Round(center.Y * zoom));
            Calculator.ZoomPointList(cluster, zoom);
            Calculator.ZoomPointList(routeFragment, zoom);

            _graphicsController.DrawPoint(newCenter, Brushes.Red);
            _graphicsController.DrawCircle(newCenter, newRadius, Color.Black, 0);
            _graphicsController.DrawPointList(cluster);
            _graphicsController.DrawRoute(routeFragment, Color.Orange);
            //>
        }

        private void DrawAllSavedObjects()
        {
            _graphics.Clear(Color.White);
            textBoxInfo.Clear();
            PrintToTextBoxInfo(_allPointsClustered);

            if (_allPoints.Count != 0)
            {
                _graphicsController.DrawPointDictionary(_allPoints);
            }

            if (_clusterCenters.Count != 0)
            {
                for (int i = 0; i < _clusterCenters.Count; i++)
                {
                    _graphicsController.DrawPoint(_clusterCenters[i], Brushes.Red, 6);

                    if (_clusterizationType == ClusterizationType.Forel)
                    {
                        _graphicsController.DrawCircle(_clusterCenters[i], _forelRadius, Color.Black, 0);
                    }
                }
            }

            if (_routeBuilder.RouteList.Count != 0)
            {
                _graphicsController.DrawRoute(_routeBuilder.RouteList, Color.Orange, 0);
                labelRoute.Text = "Route _length: " + Math.Round(Calculator.CalcRouteLength(_routeBuilder.RouteList), 3);
            }
        }

        private void btnCalcEnergy_Click(object sender, EventArgs e)
        {
            DrawAllSavedObjects();
            buttonStatistic.Enabled = true;
            loop_count++;
            map_last_usedE = map_usedE;

            DataTransmittionType connectionType = DataTransmittionType.DT_to_Center; // default connection

            switch (comboBoxConnectionType.SelectedIndex)
            {
                case 1:
                    connectionType = DataTransmittionType.DT_to_Route;
                    break;

                case 2:
                    connectionType = DataTransmittionType.PP_to_Center;
                    break;
                
                case 3:
                    connectionType = DataTransmittionType.PP_to_Route;
                    break;
            }

            _energyCalculator.CalculteAllNodesEnergy(connectionType, _allPointsClustered, _routeBuilder.RouteList, ReadStationHeighth());
            PrintToTextBoxInfo(_allPointsClustered);

            labelCharge.Visible = true;
            labelUsedEnergy.Visible = true;
            map_usedE = _energyCalculator.GetMapUsedEnergy();
            labelCharge.Text = "Total charge: " + String.Format("{0:0.000}", _energyCalculator.GetMapCurrentChargeInPercents()) + "%";
            labelUsedEnergy.Text = "Used energy: " + String.Format("{0:0.000}", map_usedE) + " (J)";
            if (labelInfo.Enabled) ReloadStatistic();
        }

        private int ReadStationHeighth()
        {
            int station_height = 0;

            if (int.TryParse(textBoxSetHeight.Text, out int height))
                station_height = height;

            return station_height;
        }

        private void PrintToTextBoxInfo(Dictionary<Point, int> dictionary)
        {
            textBoxInfo.Text = Calculator.PrintNodesAndCharge(dictionary, _energyCalculator.GetNodesChargeDictionary());
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            DrawScale();
        }

        private void DrawScale() // draw scale in panel related to picturebox
        {
            int step = 25;

            // Set panel size to all window 
            panel.Size = new Size(this.Size.Width, this.Size.Height);
            panel.Location = new Point(0, 0);

            Graphics graphicsVector = panel.CreateGraphics();

            Pen pen = new Pen(Color.Black, 2);
            Point zeroPosition = new Point(pictBoxArea.Location.X - 25, pictBoxArea.Location.Y - 25);
            int X = zeroPosition.X;
            int Y = zeroPosition.Y;

            graphicsVector.DrawLine(pen, new Point(X, Y), new Point(pictBoxArea.Location.X + pictBoxArea.Width, Y));
            graphicsVector.DrawLine(pen, new Point(X, Y), new Point(X, pictBoxArea.Location.Y + pictBoxArea.Height));

            int distanceX = pictBoxArea.Width + 10;

            int number = 0;

            for (int i = step; i <= distanceX;)
            {
                graphicsVector.DrawLine(pen, new Point(X + i, Y - 3), new Point(X + i, Y + 3));

                if (i % (2 * step) != 0)
                {
                    if (number == 0)
                    {
                        Label lb = new Label
                        {
                            Location = new Point(X + i - 6, Y - 15),
                            Text = $"{number}",
                            AutoSize = true
                        };
                        panel.Controls.Add(lb);
                    }
                    else
                    {
                        Label label = new Label
                        {
                            Location = new Point(X + i - 10, Y - 15),
                            Text = $"{number}",
                            AutoSize = true
                        };
                        panel.Controls.Add(label);
                    }
                }

                i += 25;
                number += 25;
            }

            number = 0;

            int distanceY = pictBoxArea.Height + 25;

            for (int i = 25; i < distanceY;)
            {
                graphicsVector.DrawLine(pen, new Point(X - 3, Y + i), new Point(X + 3, Y + i));
                if (i % 50 != 0)
                {
                    if (number == 0)
                    {
                        Label lb = new Label
                        {
                            Location = new Point(X - 15, Y + i - 7),
                            Text = $"{number}",
                            AutoSize = true

                        };
                        panel.Controls.Add(lb);
                    }
                    else if (number == 50)
                    {
                        Label lb = new Label
                        {
                            Location = new Point(X - 23, Y + i - 7),
                            Text = $"{number}",
                            AutoSize = true

                        };
                        panel.Controls.Add(lb);
                    }
                    else
                    {
                        Label lb = new Label
                        {
                            Location = new Point(X - 27, Y + i - 7),
                            Text = $"{number}",
                            AutoSize = true

                        };
                        panel.Controls.Add(lb);
                    }

                }

                i += 25;
                number += 25;
            }
        }

        private void btnNearestNeighbour_Click(object sender, EventArgs e)
        {
            AllowSelectClusterAndCalculateEnergy();
            btnConvexHull.Enabled = true;
            List<Point> route = new List<Point> { };

            if (_clusterCenters.Count > 0)
            {
                route = _routeBuilder.CalculateRouteByNearestNeighbour(_clusterCenters);
            }
            else
            {
                route = _routeBuilder.CalculateRouteByNearestNeighbour(Calculator.DictionaryToList(_allPoints));
            }

            _graphicsController.DrawRoute(route, Color.Salmon);
            labelRoute.Text = "Route _length: " + Math.Round(Calculator.CalcRouteLength(route), 3);
            PrintToTextBoxInfo(_allPointsClustered);
        }

        private void btnFPPWR_Click(object sender, EventArgs e)
        {
            AllowSelectClusterAndCalculateEnergy();
            btnConvexHull.Enabled = true;
            List<Point> route = new List<Point> { };

            //< draw net on pictBoxArea
            // divide field on cells; cells count:
            int x_count = _fppwrDefaultNetCols;
            int y_count = _fppwrDefaultNetRows;
            _graphicsController.DrawNet(x_count, y_count, pictBoxArea.Width, pictBoxArea.Height);

            if (_clusterCenters.Count > 0)
            {
                route = _routeBuilder.CalculateRouteByFPPWR(_clusterCenters, x_count, y_count, pictBoxArea.Width, pictBoxArea.Height);
            }
            else
            {
                route = _routeBuilder.CalculateRouteByFPPWR(Calculator.DictionaryToList(_allPoints), x_count, y_count, pictBoxArea.Width, pictBoxArea.Height);
            }

            _graphicsController.DrawRoute(route, Color.Purple);
            labelRoute.Text = "Route _length: " + Math.Round(Calculator.CalcRouteLength(route), 3);
            PrintToTextBoxInfo(_allPointsClustered);
        }

        private void btnHelp_Click(object sender, EventArgs e)
        {
            labelInfo.Text = 
                "black points - nodes\n" +
                "big red points - mass centers of clusters\n" +
                "red points - nodes with 0 % charge\n" +
                "black circles - clusters\n" +
                "gray circles - clusters iterations\n" +
                "green line - transmittion model for close distance (< 87, 7m)\n" +
                "red line - transmittion model for long distance (> 87, 7m) (with using amplifier)\n" +
                "route colors -different for each route-building algorithm, allow to see difference";

            CheckLabelInfo();
        }

        private void Labels_ClearText() {
            labelRoute.Text = "";
            labelCharge.Text = " ";
            labelUsedEnergy.Text = " ";
        }

#region User input control

        private void EnableClusterization() { 
            btnKMeans.Enabled = true;
            btnForel.Enabled = true;
        }
        private void DisableClusterization()
        {
            btnKMeans.Enabled = false;
            btnForel.Enabled = false;
        }

        private void EnableRouteCalculating()
        {
            btnNearestNeighbour.Enabled = true;
            btnConvexHull.Enabled = true;
            btnBruteForce.Enabled = true;
            btnSpiralRoute.Enabled = true;
            btnFPPWR.Enabled = true;
        }

        private void DisableRouteCalculating()
        {
            btnNearestNeighbour.Enabled = false;
            btnConvexHull.Enabled = false;
            btnBruteForce.Enabled = false;
            btnSpiralRoute.Enabled = false;
            btnFPPWR.Enabled = false;
        }

        private void DisableAll() { 
            DisableClusterization();
            DisableRouteCalculating();
            btnSelectCluster.Enabled = false;
            btnCalcEnergy.Enabled = false;
            buttonStatistic.Enabled = false;
        }

        private void AllowSelectClusterAndCalculateEnergy() { 
            btnSelectCluster.Enabled = true;
            btnCalcEnergy.Enabled = true;
            buttonStatistic.Enabled = false;
        }

        private void DisallowSelectClusterAndCalculateEnergy()
        {
            btnSelectCluster.Enabled = false;
            btnCalcEnergy.Enabled = false;
            buttonStatistic.Enabled = false;
            loop_count = 0;
            map_usedE = 0;
            map_last_usedE = 0;
        }

#endregion

        private void btnDeselectCluster_Click(object sender, EventArgs e)
        {
            DrawAllSavedObjects();
            btnDeselectCluster.Enabled = false;
            btnSelectCluster.Enabled = true;
            btnCalcEnergy.Enabled = true;
            EnableClusterization();
            EnableRouteCalculating();
        }

        private void buttonStatistic_Click(object sender, EventArgs e)
        {
            ReloadStatistic();
            CheckLabelInfo();
        }

        private void ReloadStatistic()
        {
            double map_capacity = _energyCalculator.GetNodesCapacity(_allPoints.Count);
            double map_charge = _energyCalculator.GetMapCurrentCharge();
            double map_charge_percents = _energyCalculator.GetMapCurrentChargeInPercents();
            int nodes_available = GetCountOfAvailableNodes();

            labelInfo.Text =
                "Total nodes charge: " + map_charge_percents + "% (" + map_charge + " / " + map_capacity + " J)\n" +
                "Available nodes: " + nodes_available + " / " + _allPointsClustered.Count + "\n" +
                "Clusters count: " + _forel.clusterNum + "\n" +
                "Loops: " + loop_count + "\n" +
                "Average E, per loop: " + String.Format("{0:0.000}", (map_capacity - map_charge) / loop_count) + " J\n" +
                "Last loop used E: " + String.Format("{0:0.000}", map_usedE - map_last_usedE) + " J";
        }

        private void buttonReloadMap_Click(object sender, EventArgs e)
        {
            DrawAllSavedObjects();
        }

        private void CheckLabelInfo()
        {
            if (labelInfo.Visible)
            {
                labelInfo.Visible = false;
            }
            else
            {
                labelInfo.Visible = true;
            }
        }

        private int GetCountOfAvailableNodes() {
            
            int count = 0;
            var nodes_charge = _energyCalculator.GetNodesChargeDictionary();

            foreach (var node in nodes_charge)
            {
                if (node.Value != 0)
                {
                    count++;
                }
            }
            return count;
        }

        private void buttonEnergyModel_Click(object sender, EventArgs e)
        {
            CheckLabelInfo();

            labelInfo.Text =
                "Field size: " + pictBoxArea.Width + " x " + pictBoxArea.Height + " m" +
                "\nAmplifier energy:" +
                "\n     Free space model " + "(<= " + _energyCalculator.d0 + " m):  " + _energyCalculator.E_fs + " nJ" +
                "\n     Multipath fading model " + "(> " + _energyCalculator.d0 + " m):  " + _energyCalculator.E_mp * 1000000 + " mJ" +
                "\nInitial node energy: " + _energyCalculator.node_E / 1000000000.000 + " J" +
                "\nEnergy for signal transmittion / recieve: " + _energyCalculator.E_elec + " nJ/bit" +
                "\nPackage size (20 - 65535): " + _energyCalculator.package + " bit" +
                "\nThreshold for swapping amplification models: " + _energyCalculator.d0 + " m";
        }

        private void btnLink_Click(object sender, EventArgs e)
        {
            //System.Diagnostics.Process.Start("http://www.facebook.com");
        }
    }
}