Добавить к коду подсчет яркостей

                foreach (var p in source)
                {
                    //get pixel from dithering matrix
                    var dithPixel = dith[p.X % dith.Width, p.Y % dith.Height].GetBrightness();
                    //get pixel from source image
                    var pixel = source[p].GetBrightness();
                    //compare
                    res[p] = pixel >= dithPixel ? Color.White : Color.Black;
                }

        /// <summary>Преобразует пиксельное цветное изображение в массив in[,] яркостей.</summary>
        /// <param name="bmp">Цветное изображение в формате bmp.</param>
        /// <param name="dev">Коэффициент приведения процентов. Для реальной яркости должен быть равен 100.</param>
        /// <returns>Массив int[,] яркостей пикселей.
        /// Значения яркостей в процентах по отношению к цвету (1, 1, 1) делённое на dev.</returns>
        public static BrightnesData GetBrightnes(Bitmap bmp, int dev = 100)
        {
 
            BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
            int stride = bmpData.Stride;
            byte[] bmpBytes = new byte[stride * bmp.Height];
            System.Runtime.InteropServices.Marshal.Copy(bmpData.Scan0, bmpBytes, 0, bmpBytes.Length);
            bmp.UnlockBits(bmpData);
 
            int[,] brightnes = new int[bmp.Height, bmp.Width];
 
            // Y=0.3*R+0.59*G+0.11*B
            int r = 30, g = 59, b = 11;
            int k = 0;
            int[] brightnesCounts = new int[256 * 100 / dev];
            for (int row = 0; row < bmp.Height; row++)
            {
                for (int col = 0; col < bmp.Width; col++)
                {
                    brightnes[row, col] = r * bmpBytes[k] + g * bmpBytes[k + 1] + b * bmpBytes[k + 2];
                    brightnes[row, col] /= dev;
                    brightnesCounts[brightnes[row, col]]++;
                    k++;
                }
            }
 
            (int brightne, int count)[] brightnesCountsSort = brightnesCounts
                .Select((cnt, br) => (brightne: br, count: cnt))
                .Where(pr => pr.count > 0)
                .OrderBy(pr => pr.count)
                .ToArray();
 
            return new BrightnesData(brightnes, brightnesCountsSort);
        }

            stopwatch.Start();
            var brightnes = GetBrightnes(bmp, 25);
            stopwatch.Stop();

            int brightne;
            for (int row = 0; row < bmp.Height; row++)
            {
                for (int col = 0; col < bmp.Width; col++)
                {
                    brightne = (r * bmpBytes[k] + g * bmpBytes[k + 1] + b * bmpBytes[k + 2]) / dev;
                    brightnesCounts[brightnes[row, col] = brightne]++;
                    k++;
                }
            }

        /// <summary>Преобразует пиксельное цветное изображение в массив in[,] яркостей.</summary>
        /// <param name="bmp">Цветное изображение в формате bmp.</param>
        /// <param name="dev">Коэффициент приведения процентов. Для реальной яркости должен быть равен 100.</param>
        /// <returns>Массив int[,] яркостей пикселей.
        /// Значения яркостей в процентах по отношению к цвету (1, 1, 1) делённое на dev.</returns>
        public static BrightnesData GetBrightnes(Bitmap bmp, int dev = 100)
        {
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
 
            BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
            int stride = bmpData.Stride;
            byte[] bmpBytes = new byte[stride * bmp.Height];
            System.Runtime.InteropServices.Marshal.Copy(bmpData.Scan0, bmpBytes, 0, bmpBytes.Length);
            bmp.UnlockBits(bmpData);
 
            long timeBytes = stopwatch.ElapsedMilliseconds;
 
            int[,] brightnes = new int[bmp.Height, bmp.Width];
 
            // Y=0.3*R+0.59*G+0.11*B
            int r = 30, g = 59, b = 11;
            int k = 0;
            int[] brightnesCounts = new int[256 * 100 / dev];
 
            int height = bmp.Height;
            int width = bmp.Width;
            Task[] tasks = new Task[height];
            for (int row = 0; row < height; row++)
            {
                int _row = row;
                tasks[row] = Task.Factory.StartNew(rowCalk, _row);
            }
 
            Task.WaitAll(tasks);
 
            long timeBrightnes = stopwatch.ElapsedMilliseconds;
 
 
            (int brightne, int count)[] brightnesCountsSort = brightnesCounts
                .Select((cnt, br) => (brightne: br, count: cnt))
                .Where(pr => pr.count > 0)
                .OrderBy(pr => pr.count)
                .ToArray();
 
            long timeBrightnesSort = stopwatch.ElapsedMilliseconds;
            return new BrightnesData(brightnes, brightnesCountsSort);
 
            // Локальный метод для расчёта яркостей одной строки
            void rowCalk(object obj)
            {
                int brightne;
                int row = (int)obj;
                k = row * width;
                for (int col = 0; col < width; col++)
                {
                    brightne = (r * bmpBytes[k++] + g * bmpBytes[k++] + b * bmpBytes[k++]) / dev;
                    brightnesCounts[brightnes[row, col] = brightne]++;
                    //k++;
                }
 
            }
        }

k = row * width * <байт на пиксель>;

            // Локальный метод для расчёта яркостей одной строки
            void rowCalk(object obj)
            {
                int brightne;
                int row = (int)obj;
                k = row * width * 4;
                for (int col = 0; col < width; col++)
                {
                    brightne = (r * bmpBytes[k++] + g * bmpBytes[k++] + b * bmpBytes[k++]) / dev;
                    brightnesCounts[brightnes[row, col] = brightne]++;
                    k++;
                }
 
            }

            Parallel.For(0, height, rowCalk);

            Task[] tasks = new Task[height];
            for (int row = 0; row < height; row++)
            {
                int _row = row;
                tasks[row] = Task.Factory.StartNew(rowCalk, _row);
            }
 
            Task.WaitAll(tasks);

        /// <summary>Преобразует пиксельное цветное изображение в массив in[,] яркостей.</summary>
        /// <param name="bmp">Цветное изображение в формате bmp.</param>
        /// <param name="tasksCount">Количество потоков для расчёта.</param>
        /// <param name="dev">Коэффициент приведения процентов. Для реальной яркости должен быть равен 100.</param>
        /// <returns>Массив int[,] яркостей пикселей.
        /// Значения яркостей в процентах по отношению к цвету (1, 1, 1) делённое на dev.</returns>
        public static BrightnesData GetBrightnes(Bitmap bmp, int tasksCount = 10, int dev = 100)
        {
 
            BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
            int stride = bmpData.Stride;
            byte[] bmpBytes = new byte[stride * bmp.Height];
            System.Runtime.InteropServices.Marshal.Copy(bmpData.Scan0, bmpBytes, 0, bmpBytes.Length);
            bmp.UnlockBits(bmpData);
 
            int[,] brightnes = new int[bmp.Height, bmp.Width];
 
            int[] brightnesCounts = new int[256 * 100 / dev];
 
            int height = bmp.Height;
            int width = bmp.Width;
            Task[] tasks = new Task[tasksCount];
            rowCalkData data = new rowCalkData()
            {
                dev = dev,
                length = height / tasksCount,
                bmpBytes = bmpBytes,
                brightnes = brightnes,
                brightnesCounts = brightnesCounts
            };
 
            int mod = height % tasksCount;
            int counRow = 0;
 
            for (int num = 0; num < tasksCount; num++)
            {
                rowCalkData _data = data;
                _data.rowBegin = counRow + data.length;
                if (mod-- > 0)
                    _data.rowBegin++;
 
                counRow += _data.rowBegin;
 
                tasks[num] = Task.Factory.StartNew(RowCalk, data);
            }
 
            Task.WaitAll(tasks);
 
            (int brightne, int count)[] brightnesCountsSort = brightnesCounts
                .Select((cnt, br) => (brightne: br, count: cnt))
                .Where(pr => pr.count > 0)
                .OrderBy(pr => pr.count)
                .ToArray();
 
            return new BrightnesData(brightnes, brightnesCountsSort);
 
        }

        // Y=0.3*R+0.59*G+0.11*B
        const int R = 30, G = 59, B = 11;
        struct rowCalkData
        {
            public int dev;
            public int rowBegin;
            public int length;
            public byte[] bmpBytes;
            public int[,] brightnes;
            public int[] brightnesCounts;
        }
        // Mетод для расчёта яркостей диапазона строк
        static void RowCalk(object obj)
        {
            rowCalkData data = (rowCalkData)obj;
 
            int width = data.brightnes.GetLength(1);
            int brightne;
            int k = data.rowBegin * width * 4;
            int rowEnd = data.rowBegin + data.length;
 
            for (int row = 0; row < rowEnd; row++)
            {
 
                for (int col = 0; col < width; col++)
                {
                    brightne = (R * data.bmpBytes[k++] + G * data.bmpBytes[k++] + B * data.bmpBytes[k++]) / data.dev;
                    data.brightnesCounts[data.brightnes[row, col] = brightne]++;
                    k++;
                }
            }
 
        }

            Stopwatch stopwatch = new Stopwatch();
 
            Bitmap bmp = (Bitmap)Image.FromFile(@"C:\Users\EldHa\OneDrive\Изображения\FlatEarthMap.bmp");
 
            stopwatch.Start();
            var brightnes = GetBrightnes(bmp, 8, 25);
            stopwatch.Stop();
 
            Console.WriteLine($"Минимальное количество точек с одной яркостью: {brightnes.BrightnesCounts[0]}");
            Console.WriteLine($"Максимальное количество точек с одной яркостью: {brightnes.BrightnesCounts[brightnes.BrightnesCounts.Length - 1]}");
            Console.WriteLine($"Количество различных яркостей: {brightnes.BrightnesCounts.Length}");
            Console.WriteLine("Список яркостей яркостей в порядке возрастания их количества");
            Console.WriteLine(string.Join(Environment.NewLine, brightnes.BrightnesCounts));