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

                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;
                }

        internal static BrightnesData Equalization(BrightnesData data)
        {
            int height = data.Brightnes.GetLength(1);
            int width = data.Brightnes.GetLength(0);
            int k = 255; // k = 255;
            float[] h = new float[k + 1]; // h: array [0 .. k] of double;
            for (int i = 0; i <= k; i++) // for i := 0 to k do
                h[i] = 0; //h[i] := 0;
            for (int j = 0; j < width; j++) // for i := 0 to self.Height - 1 do
                for (int i = 0; i < height; i++) // for j := 0 to self.Width - 1 do
                {
                    int index = (int)(k * data.Brightnes[j, i] / 510);
                    h[index] = h[index] + 1;// h[round(k * self.Pixels[i, j])] := h[round(k * self.Pixels[i, j])] + 1;
                }
            for (int i = 0; i <= k; i++) // for i := 0 to k do
                h[i] = h[i] / (height * width); // h[i] := h[i] / (self.Height * self.Width);
            for (int i = 1; i <= k; i++) // for i := 1 to k do
                h[i] = h[i - 1] + h[i]; // h[i] := h[i - 1] + h[i];
            for (int j = 0; j < width; j++) // for i := 0 to self.Height - 1 do
                for (int i = 0; i < height; i++) // for j := 0 to self.Width - 1 do
                    data.Brightnes[j, i] = (int)(h[(int)(k * data.Brightnes[j, i] / 510)] * 510); // self.Pixels[i, j] := h[round(k * self.Pixels[i, j])];
 
            return data;
        }

        internal static BrightnesData Equalization(BrightnesData data)
        {
            int height = data.Brightnes.GetLength(1);
            int width = data.Brightnes.GetLength(0);
            int k = 510;
            float[] h = new float[k + 1];
            for (int i = 0; i <= k; i++)
                h[i] = 0;
            for (int j = 0; j < width; j++)
                for (int i = 0; i < height; i++)
                {
                    int index = (int)(data.Brightnes[j, i]);
                    h[index] = h[index] + 1;
                }
            int hw = height * width;
            for (int i = 0; i <= k; i++)
                h[i] = h[i] / hw;
            for (int i = 1; i <= k; i++)
                h[i] = h[i - 1] + h[i];
            for (int j = 0; j < width; j++)
                for (int i = 0; i < height; i++)
                    data.Brightnes[j, i] = (int)(h[(int)(data.Brightnes[j, i])] * k);
            return data;
        }

            float[] h = new float[k + 1];
            for (int i = 0; i <= k; i++)
                h[i] = 0;
            for (int j = 0; j < width; j++)
                for (int i = 0; i < height; i++)
                {
                    int index = (int)(data.Brightnes[j, i]);
                    h[index] = h[index] + 1;
                }
            int hw = height * width;
            for (int i = 0; i <= k; i++)
                h[i] = h[i] / hw;
            for (int i = 1; i <= k; i++)
                h[i] = h[i - 1] + h[i];

            float[] h = new float[k + 1];
            for (int i = 0; i <= k; i++)
                h[i] = 0;

using System;
using System.Data;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace Forms2009
{
    public partial class Form1 : Form
    {
        //private const int BrightnessRange = 2 * 255 + 1;
        private const int BrightnessRange = 3 * 255 + 1;
 
        Bitmap ImageSource,
               ImageResult25, ImageResult50, ImageResult75;
 
        PictureBox pictureBox0 = new PictureBox(),
            pictureBox1 = new PictureBox(),
            pictureBox2 = new PictureBox(),
            pictureBox3 = new PictureBox();
        public Form1()
        {
            InitializeComponent();
 
            // Установка параметров рисунков
            pictureBox0.SizeMode = pictureBox1.SizeMode = pictureBox2.SizeMode = pictureBox3.SizeMode = PictureBoxSizeMode.Zoom;
            pictureBox0.Parent = pictureBox1.Parent = pictureBox2.Parent = pictureBox3.Parent = this;
 
            // Подключение прослушки к изменению размера Формы
            SizeChanged += FormSizeChanged;
 
            // Разворачивание Формы
            WindowState = FormWindowState.Maximized;
 
            // Чтение рисунка, его сохранение в поле и вывод на форму.
            pictureBox0.Image = ImageSource = (Bitmap)Image.FromFile(@"C:\Users\EldHa\OneDrive\Изображения\ashim-d-silva-WeYamle9fDM-unsplash.jpg");
            //pictureBox1.Image = ImageSource = (Bitmap)Image.FromFile(@"C:\Users\EldHa\OneDrive\Изображения\Ярлыки\HardForum — копия.gif");
 
            // Получение матрицы яркости в истинных единицах и массива статистики яркостей
            BrightnesData brightnes = GetBrightnes(ImageSource);
 
            // Получение чёрно-белых рисунков из матрицы яркостей с разной долей отсечки точек
            pictureBox1.Image = ImageResult25 = BlackWhiteImage(brightnes, 0.25);
            pictureBox2.Image = ImageResult50 = BlackWhiteImage(brightnes, 0.5);
            pictureBox3.Image = ImageResult75 = BlackWhiteImage(brightnes, 0.75);
        }
 
        /// <summary>Метод адаптации размеров рисунков под изменение размеров Формы.</summary>
        private void FormSizeChanged(object sender, EventArgs e)
        {
            int width = Width / 2 - 5;
            int height = Height / 2 - 5;
 
            pictureBox0.Width = pictureBox1.Width = pictureBox2.Width = pictureBox3.Width = width;
            pictureBox0.Height = pictureBox1.Height = pictureBox2.Height = pictureBox3.Height = height;
 
            pictureBox0.Left = 0;
            pictureBox0.Top = 0;
 
            pictureBox1.Left = width + 10;
            pictureBox1.Top = 0;
 
            pictureBox2.Left = 0;
            pictureBox2.Top = height + 10;
 
            pictureBox3.Left = width + 10;
            pictureBox3.Top = height + 10;
 
        }
 
        /// <summary>Контейнер для возврата из метода связанных данных по яркости изображения.</summary>
        public class BrightnesData
        {
            /// <summary>Массив Яркостей.</summary>
            public int[,] Brightnes { get; }
            /// <summary>Массив кортежей яркостей и количества точек с такой яркостью.</summary>
            public (int brightne, int count)[] BrightnesCounts { get; }
            /// <summary>Создание экземпляра типа.</summary>
            /// <param name="brightnes">Массив Яркостей.</param>
            /// <param name="brightnesCounts">Массив кортежей яркостей и количества точек с такой яркостью.</param>
            public BrightnesData(int[,] brightnes, (int brightne, int count)[] brightnesCounts)
            {
                Brightnes = brightnes;
                BrightnesCounts = brightnesCounts;
            }
        }
 
        /// <summary>Преобразует пиксельное цветное изображение в массив in[,] яркостей.</summary>
        /// <param name="bmp">Цветное изображение в формате bmp.</param>
        /// <param name="tasksCount">Количество потоков для расчёта. По умолчанию - 10 потоков.</param>
        /// <returns>Контейнер <see cref="BrightnesData"/> с двумя свойствами:<br/>
        /// <see cref="BrightnesData.Brightnes"/> - Матрица int[,] полной яркостей пикселей.<br/>
        /// Значения полных яркостей в истинных целых единицах.<br/>
        /// Отличаются от значений <see cref="Color.GetBrightness"/> примерно в 765 раз.<br/>
        /// и <see cref="BrightnesData.BrightnesCounts"/> - Отсортированный массив<br/>
        /// имеющихся различных яркостей и количества точек с такой яркостю.</returns>
        public static BrightnesData GetBrightnes(Bitmap bmp, int tasksCount = 10)
        {
            // Получение байтового массива рисунка. Байты получаются в последовательности Format32bppArgb
            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[BrightnessRange];
 
            // Инициализация локальных переменных и структуры для передачи данных в задачи
            int height = bmp.Height;
            int width = bmp.Width;
            Task<int[]>[] tasks = new Task<int[]>[tasksCount];
            RowCalkData data = new RowCalkData()
            {
                length = height / tasksCount,
                bmpBytes = bmpBytes,
                brightnes = brightnes
            };
 
            // Если количество строк не кратно количеству потоков, то определятся сколь "лишних строк"
            int mod = height % tasksCount;
 
            // Количество переданных в обработку строк
            int counRow = 0;
 
            // Цикл для создания и запуска задач
            for (int num = 0; num < tasksCount; num++)
            {
                // Копирование контейнера с данными для передачи в задачу.
                RowCalkData _data = data;
 
                // Задание начальной строки для работы задачи
                _data.rowBegin = counRow;
 
                // Если не все "лишние строки" посланы в обработку, то добавление одной в создаваемую задачу.
                if (mod-- > 0)
                    _data.length++;
                counRow += _data.length;
 
                // Создание, запуск задачи и запоминание её в массиве
                tasks[num] = Task<int[]>.Factory.StartNew(RowCalk, _data);
            }
 
            // Цикл ожидания завершения каждой задачи.
            while ((tasks = tasks.Where(t => t != null).ToArray()).Length > 0)
            {
                // Обработка возвращённых задачей данных и удаление задачи из массива
                int num = Task.WaitAny(tasks);
                for (int i = 0; i < BrightnessRange; i++)
                    brightnesCounts[i] += tasks[num].Result[i];
                tasks[num] = null;
            }
 
            // LINQ создающий массив кортежей со статистикой по матрице яркостей.
            (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);
        }
 
        /// <summary>Структура для передачи данных в задачу.</summary>
        struct RowCalkData
        {
            /// <summary>Начальная строка для обработка.</summary>
            public int rowBegin;
            /// <summary>Длина диапазона обрабатываемых строк.</summary>
            public int length;
            /// <summary>Байтовый массив изображения.</summary>
            public byte[] bmpBytes;
            /// <summary>Матрица яркостей.</summary>
            public int[,] brightnes;
        }
 
        // Mетод для расчёта яркостей диапазона строк
        static int[] RowCalk(object obj)
        {
            // Получение структуры данных из нетипизированного параметра
            RowCalkData data = (RowCalkData)obj;
 
            // Ширина изображения
            int width = data.brightnes.GetLength(1);
 
            // Смещение в байтовом массиве
            int k = data.rowBegin * width * 4;
 
            // Строка следующего диапазона - она не должна обрабатываться
            int rowEnd = data.rowBegin + data.length;
 
            // Создание массива статистики по диапазону обрабатываемому в задаче
            int[] brightnesCounts = new int[BrightnessRange];
 
            // Локальные переменные для промежуточного хранения данных в цикле.
            //int brightne, r, g, b, min, max;
            int brightne;
 
            // Циклы по строкам диапазона и по всем колонкам
            for (int row = data.rowBegin; row < rowEnd; row++)
            {
                for (int col = 0; col < width; col++)
                {
                    //// Подсчёт яркости по алгоритму MS
                    //r = data.bmpBytes[k++];
                    //g = data.bmpBytes[k++];
                    //b = data.bmpBytes[k++];
                    //min = max = r;
                    //if (g > max) max = g;
                    //if (b > max) max = b;
 
                    //if (g < min) min = g;
                    //if (b < min) min = b;
 
                    //brightne = min + max;
 
                    // Подсчёт полной яркости
                    brightne = data.bmpBytes[k++] + data.bmpBytes[k++] + data.bmpBytes[k++];
 
                    // Запоминание яркости и корректировка статистики
                    brightnesCounts[data.brightnes[row, col] = brightne]++;
 
                    k++;
                }
            }
            return brightnesCounts;
        }
 
        /// <summary>Конвертация Матрицы яркости в чёрно белое изображение.</summary>
        /// <param name="data">Матрица яркости и массив статистики.</param>
        /// <param name="part">Доля срезаемых точек от общего их количества.</param>
        /// <returns>Чёрно белое изображение.</returns>
        internal static Bitmap BlackWhiteImage(BrightnesData data, double part)
        {
            // Размеры матрицы
            int height = data.Brightnes.GetLength(0);
            int width = data.Brightnes.GetLength(1);
 
            // Создание байтового массива для изображения
            byte[] argb = new byte[data.Brightnes.Length * 4];
 
            // Уровень срезаемой яркости
            int avbr = 0;
            // Количество срезаемых точек
            double countPixels = 0;
 
            // Цикл по массиву статистики отсортированному по возрастанию яркости
            foreach (var item in data.BrightnesCounts.OrderBy(x => x.brightne))
            {
                // Запоминание яркости
                avbr = item.brightne;
                // Добавление количества точек с этой яркостью
                countPixels += item.count;
 
                // Если количество срезаемых точек превышает заданную долю, то выход из цикла
                if (countPixels / data.Brightnes.Length > part)
                    break;
            }
 
            // Смещение в байтовом массиве
            int k = 0;
 
            // Цикл по всем точкам в массиве яркостей
            foreach (int brightne in data.Brightnes)
            {
                // Если у точки яркость выше определённой, то точка белая
                if (brightne > avbr)
                {
                    argb[k++] = 255;
                    argb[k++] = 255;
                    argb[k++] = 255;
                }
                // Иначе - чёрная
                else
                {
                    argb[k++] = 0;
                    argb[k++] = 0;
                    argb[k++] = 0;
                }
                // Задание байта прозрачности
                argb[k++] = 255;
            }
 
            // Создание нового рисунка с нужным размером и запись в него полученного байтового массива
            var result = new Bitmap(width, height);
            BitmapData bmpData = result.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
            int stride = bmpData.Stride;
            System.Runtime.InteropServices.Marshal.Copy(argb, 0, bmpData.Scan0, argb.Length);
            result.UnlockBits(bmpData);
 
            return result;
        }
 
    }
}

            for (int row = data.rowBegin; row < rowEnd; row++)
            {
                for (int col = 0; col < width; col++)
                {
                    //// Подсчёт яркости по алгоритму MS
                    //r = data.bmpBytes[k++];
                    //g = data.bmpBytes[k++];
                    //b = data.bmpBytes[k++];
                    //min = max = r;
                    //if (g > max) max = g;
                    //if (b > max) max = b;
 
                    //if (g < min) min = g;
                    //if (b < min) min = b;
 
                    //brightne = min + max;
 
                    // Подсчёт полной яркости
                    brightne = data.bmpBytes[k++] + data.bmpBytes[k++] + data.bmpBytes[k++];
 
                    // Запоминание яркости и корректировка статистики
                    brightnesCounts[data.brightnes[row, col] = brightne]++;
 
                    k++;
                }
            }
            return brightnesCounts;

        //private const int BrightnessRange = 2 * 255 + 1;
        private const int BrightnessRange = 3 * 255 + 1;

        private void FormSizeChanged(object sender, EventArgs e)
        {
            int width = Width / 2 - 20;
            int height = Height / 2 - 20;