using System;

public class Test
{
	public static void Main()
	{
		.............
	  public static async Task<double[,]> GLCMall(Bitmap source)
        {
            
            await Task.Run(() => FinishSorceAsync = CreatGlcmMatrix(source));
            await Task.Run(() => GreyMatrixAsync = Test1(FinishSorceAsync));
            await Task.Run(() => GlcmAsync = TestMatrix());
            .......
            

            return GlcmAsync;
        }
        public static byte[,] CreatGlcmMatrix(Bitmap source)
        {
            // dwuwymiarowa tablica z progami jasności
            Byte[,] FinishSorce = new Byte[source.Width, source.Height];

            for (int i = 0; i < source.Width; i++)
            {
                for (int x = 0; x < source.Height; x++)
                {
                    int bmc = source.GetPixel(i, x);
                    var myCol = System.Drawing.Color.FromArgb(bmc);
                    FinishSorce[i, x] = myCol.R;
                }
            }

            return FinishSorce;
        }
        //public Task<byte[,]> CreatGlcmMatrixAsync2(Bitmap source)
        //{
        //    return Task<byte[,]>.Factory.StartNew(() => CreatGlcmMatrix(source));
        //}
        //public Task<double[,]> Test1Async(byte[,] FinishSorce)
        //{
        //    return Task<double[,]>.Factory.StartNew(() => Test1(FinishSorce));
        //}
        //public async void CreatGlcmMatrixAndTestAsync(Bitmap source)
        //{
        //    byte[,] FinishSorce = await CreatGlcmMatrixAsync2(source);
        //    double[,] matrix = await Test1Async(FinishSorce);


        //}
        public static int[,] Test1(byte[,] FinishSorce)
        {
            switch (MatrixSize)
            {
                case 4:
                    byte[] I4 = {  63,  127,  191, 255 };
                    int[,] GMatrix4 = new int[FinishSorce.GetLength(0), FinishSorce.GetLength(1)];

                    for (int i = 0; i < FinishSorce.GetLength(0); i++)
                    {
                        for (int j = 0; j < FinishSorce.GetLength(1); j++)
                        {
                           
                            if (Int32.Parse(FinishSorce.GetValue(i, j).ToString()) <= 63)
                            {
                                GMatrix4.SetValue(0, i, j);
                            }
                           
                            else if (Int32.Parse(FinishSorce.GetValue(i, j).ToString()) <= 127)
                            {
                                GMatrix4.SetValue(1, i, j);
                            }
                           
                            else if (Int32.Parse(FinishSorce.GetValue(i, j).ToString()) <= 191)
                            {
                                GMatrix4.SetValue(2, i, j);
                            }
                           
                            else if (Int32.Parse(FinishSorce.GetValue(i, j).ToString()) <= 255)
                            {
                                GMatrix4.SetValue(3, i, j);
                            }
                            else
                            {
                                System.Console.WriteLine("Błąd obliczenia pixela ");
                            }
                        }
                    }
                    GrayMatrix = GMatrix4;
                    break;	
                    .............
	}
}