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

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

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace WindowsFormsApp10
{
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Bitmap bmp = new Bitmap(@"xxx.jpg");
            GetBrightnes(bmp);
            GetBrightnesUnsafe(bmp);
 
            TimeSpan total = TimeSpan.FromSeconds(0);
            Stopwatch sw = new Stopwatch();
            Console.WriteLine("GetBrightnes");
            for (int i = 0; i < 100; i++)
            {
                sw.Restart();
                var result = GetBrightnes(bmp);
                sw.Stop();
                total += sw.Elapsed;
                Console.WriteLine($"{sw.Elapsed} {result.BrightnesCounts.Length} {result.BrightnesCounts[0]} {result.BrightnesCounts[result.BrightnesCounts.Length - 1]} {result.BrightnesCounts.Sum(x => x.count)} {result.BrightnesCounts.Sum(x => x.brightne)}");
            }
            Console.WriteLine(TimeSpan.FromMilliseconds(total.TotalMilliseconds / 100));
 
            total = TimeSpan.FromSeconds(0);
            Console.WriteLine("GetBrightnesUnsafe");
            for (int i = 0; i < 100; i++)
            {
                sw.Restart();
                var result = GetBrightnesUnsafe(bmp);
                sw.Stop();
                total += sw.Elapsed;
                Console.WriteLine($"{sw.Elapsed} {result.BrightnesCounts.Length} {result.BrightnesCounts[0]} {result.BrightnesCounts[result.BrightnesCounts.Length - 1]} {result.BrightnesCounts.Sum(x => x.count)} {result.BrightnesCounts.Sum(x => x.brightne)}");
            }
            Console.WriteLine(TimeSpan.FromMilliseconds(total.TotalMilliseconds / 100));
 
            total = TimeSpan.FromSeconds(0);
            Console.WriteLine("GetBrightnesV3");
            for (int i = 0; i < 100; i++)
            {
                sw.Restart();
                var result = GetBrightnesV3(bmp);
                sw.Stop();
                total += sw.Elapsed;
                Console.WriteLine($"{sw.Elapsed} {result.BrightnesCounts.Length} {result.BrightnesCounts[0]} {result.BrightnesCounts[result.BrightnesCounts.Length - 1]} {result.BrightnesCounts.Sum(x => x.count)} {result.BrightnesCounts.Sum(x => x.brightne)}");
            }
            Console.WriteLine(TimeSpan.FromMilliseconds(total.TotalMilliseconds / 100));
 
            total = TimeSpan.FromSeconds(0);
            Console.WriteLine("GetBrightnesST");
            for (int i = 0; i < 5; i++)
            {
                sw.Restart();
                var result = GetBrightnesST(bmp);
                sw.Stop();
                total += sw.Elapsed;
                Console.WriteLine($"{sw.Elapsed} {result.BrightnesCounts.Length} {result.BrightnesCounts[0]} {result.BrightnesCounts[result.BrightnesCounts.Length - 1]} {result.BrightnesCounts.Sum(x => x.count)} {result.BrightnesCounts.Sum(x => x.brightne)}");
            }
            Console.WriteLine(TimeSpan.FromMilliseconds(total.TotalMilliseconds / 5));
 
            Console.ReadLine();
        }
 
        /// <summary>Преобразует пиксельное цветное изображение в массив in[,] яркостей.</summary>
        /// <param name="bmp">Цветное изображение в формате bmp.</param>
        /// <param name="dev">Коэффициент приведения процентов. Для реальной яркости должен быть равен 100.</param>
        /// <returns>Массив int[,] яркостей пикселей.
        /// Значения яркостей в процентах по отношению к цвету (1, 1, 1) делённое на dev.</returns>
        public static BrightnesData GetBrightnesUnsafe(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];
            //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);
            //}
 
            //Parallel.For(0, height, (i) => rowCalk(i, width, bmpData.Scan0, brightnesCounts, brightnes, dev));
 
            ReaderWriterLockSlim syncLock = new ReaderWriterLockSlim();
 
            Parallel.For(0, height, () => new LoopData { data = brightnes, countsLocal = new int[256], countsTotal = brightnesCounts, syncLock = syncLock }, (a, b, c) => { rowCalk(a, width, bmpData.Scan0, c.countsLocal, c.data, dev); return c; }, LocalFinally);
 
            //Task.WaitAll(tasks);
 
            bmp.UnlockBits(bmpData);
 
            //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);
 
            // Локальный метод для расчёта яркостей одной строки
            static void rowCalk(int row, int width, IntPtr scan0, int[] brightnesCounts, int[,] brightnes, int dev)
            {
                int brightne;
                int k = row * width * 4;
 
                const int r = 30, g = 59, b = 11;
 
                unsafe
                {
                    byte* pixelsPtr = (byte*)scan0;
                    for (int col = 0; col < width; col++)
                    {
                        brightne = (r * pixelsPtr[k] + g * pixelsPtr[k + 1] + b * pixelsPtr[k + 2]) / dev;
 
                        brightnes[row, col] = brightne;
                        brightnesCounts[brightne]++;
                        k += 4;
                    }
                }
            }
 
            static void LocalFinally(LoopData data)
            {
                data.syncLock.EnterWriteLock();
                for (int i = 0; i < 256; i++)
                {
                    data.countsTotal[i] += data.countsLocal[i];
                }
                data.syncLock.ExitWriteLock();
            }
        }
 
        /// <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];
            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);
            //}
 
            //Parallel.For(0, height, (i) => rowCalk(i, width, bmpBytes, brightnesCounts, dev));
 
            ReaderWriterLockSlim syncLock = new ReaderWriterLockSlim();
 
            Parallel.For(0, height, () => new LoopData { data = brightnes, countsLocal = new int[256], countsTotal = brightnesCounts, syncLock = syncLock }, (a, b, c) => { rowCalk(a, width, bmpBytes, c.countsLocal, c.data, dev); return c; }, LocalFinally);
 
            //Task.WaitAll(tasks);
 
            bmp.UnlockBits(bmpData);
 
            //long timeBrightnes = stopwatch.ElapsedMilliseconds;
 
            int numPix = height * width;
            int x = brightnesCounts.Sum();
 
            (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);
 
            // Локальный метод для расчёта яркостей одной строки
            static void rowCalk(int row, int width, byte[] bmpBytes, int[] brightnesCounts, int[,] brightnes, int dev)
            {
                int brightne;
                int k = row * width * 4;
 
                const int r = 30, g = 59, b = 11;
 
                for (int col = 0; col < width; col++)
                {
                    brightne = (r * bmpBytes[k] + g * bmpBytes[k + 1] + b * bmpBytes[k + 2]) / dev;
 
                    brightnes[row, col] = brightne;
                    brightnesCounts[brightne]++;
                    k += 4;
                }
            }
 
            static void LocalFinally(LoopData data)
            {
                data.syncLock.EnterWriteLock();
                for (int i = 0; i < 256; i++)
                {
                    data.countsTotal[i] += data.countsLocal[i];
                }
                data.syncLock.ExitWriteLock();
            }
        }
 
        // 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;
        }
 
        /// <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 GetBrightnesV3(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);
        }
 
        // 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 + 1] + B * data.bmpBytes[k + 2]) / data.dev;
                    data.brightnes[row, col] = brightne;
                    data.brightnesCounts[brightne]++;
                    k += 4;
                }
            }
        }
 
        /// <summary>Преобразует пиксельное цветное изображение в массив in[,] яркостей.</summary>
        /// <param name="bmp">Цветное изображение в формате bmp.</param>
        /// <param name="dev">Коэффициент приведения процентов. Для реальной яркости должен быть равен 100.</param>
        /// <returns>Массив int[,] яркостей пикселей.
        /// Значения яркостей в процентах по отношению к цвету (1, 1, 1) делённое на dev.</returns>
        public static BrightnesData GetBrightnesST(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];
            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 brightne;
            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++)
                {
                    brightne = (r * bmpBytes[k] + g * bmpBytes[k + 1] + b * bmpBytes[k + 2]) / dev;
                    brightnes[row, col] = brightne;
                    brightnesCounts[brightne]++;
                    k += 4;
                }
            }
 
            (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);
        }
    }
 
    public class LoopData
    {
        public int[,] data { get; set; }
        public int[] countsLocal { get; set; }
        public int[] countsTotal { get; set; }
        public ReaderWriterLockSlim syncLock { get; set; }
    }
 
    /// <summary>Контейнер для связанных данных по яркости изображения.</summary>
    public class BrightnesData
    {
        /// <summary>Массив Яркостей.</summary>
        public int[,] Brightnes { get; }
        /// <summary>Массив кортежей яркостей и количества точек с такой яркостью.</summary>
        public (int brightne, int count)[] BrightnesCounts { get; }
 
        public BrightnesData(int[,] brightnes, (int brightne, int count)[] brightnesCounts)
        {
            Brightnes = brightnes;
            BrightnesCounts = brightnesCounts;
        }
    }
}

           if (mod-- > 0)

            internal static Bitmap Process2(Bitmap bmp)
            {
                var result = new Bitmap(bmp.Width, bmp.Height);
                var ditheringMatrix = Resources.Dithering64x64;
                var source = GetBrightnes(bmp);
                using (var res = new ImageWrapper(result))
                using (var dith = new ImageWrapper(ditheringMatrix))
                {
                    Point p = new Point();
                    for(int w = 0; w < bmp.Width; w++)
                        for(int h = 0; h < bmp.Height; h++)
                        {
                            var dithPixel = dith[w % dith.Width, h % dith.Height].GetBrightness();
                            float pixel = source.Brightnes[h, w] / 100.0F;
                            p.X = w;
                            p.Y = h;
                            if (pixel >= dithPixel)
                                res.SetPixel(p, 255, 255, 255);
                            else
                                res.SetPixel(p, 0, 0, 0);
                        }
                }
                return result;
            }

        public float GetBrightness() {
            float r = (float)R / 255.0f;
            float g = (float)G / 255.0f;
            float b = (float)B / 255.0f;
 
            float max, min;
 
            max = r; min = r;
 
            if (g > max) max = g;
            if (b > max) max = b;
 
            if (g < min) min = g;
            if (b < min) min = b;
 
            return(max + min) / 2;
        }

        public static float GetBrightness(int R, int G, int B)
        {
            float r = (float)R / 255.0f;
            float g = (float)G / 255.0f;
            float b = (float)B / 255.0f;
 
            float max, min;
 
            max = r; min = r;
 
            if (g > max) max = g;
            if (b > max) max = b;
 
            if (g < min) min = g;
            if (b < min) min = b;
 
            return (max + min) / 2;
        }
        static void Main(string[] args)
        {
            Random rnd = new Random();
            for (int i = 0; i < 20; i++)
            {
                int r = rnd.Next(255);
                int g = rnd.Next(255);
                int b = rnd.Next(255);
  
                Color c = Color.FromArgb(r, g, b);
 
                var br = c.GetBrightness();
                var brg = GetBrightness(r, g, b);
 
                Console.WriteLine($"{br} {brg}");
            }

        /// <summary>Контейнер для связанных данных по яркости изображения.</summary>
        public class BrightnesData
        {
            /// <summary>Массив Яркостей.</summary>
            public int[,] Brightnes { get; }
            /// <summary>Массив кортежей яркостей и количества точек с такой яркостью.</summary>
            public (int brightne, int count)[] BrightnesCounts { get; }
 
            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"/> в 510 раз.<br/>
        /// и <see cref="BrightnesData.BrightnesCounts"/> - Отсортированный массив<br/>
        /// имеющихся различных яркостей и количества точек с такой яркостю.</returns>
        public static BrightnesData GetBrightnes(Bitmap bmp, int tasksCount = 10)
        {
 
            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[511];
 
            int height = bmp.Height;
            int width = bmp.Width;
            Task[] tasks = new Task[tasksCount];
            rowCalkData data = new rowCalkData()
            {
                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);
 
        }
        struct rowCalkData
        {
            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++)
                {
                    int r = data.bmpBytes[k++];
                    int g = data.bmpBytes[k++];
                    int b = data.bmpBytes[k++];
                    int min = r, 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;
                    data.brightnesCounts[data.brightnes[row, col] = brightne]++;
                    k++;
                }
            }
 
        }
        static void Main(string[] args)
        {
 
            Stopwatch stopwatch = new Stopwatch();
 
            Bitmap bmp = (Bitmap)Image.FromFile(@"C:\Users\EldHa\OneDrive\Изображения\FlatEarthMap.bmp");
 
            stopwatch.Start();
            var brightnes = GetBrightnes(bmp, 8);
            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));

        internal static Bitmap Process2(Bitmap bmp)
        {
            var result = new Bitmap(bmp.Width, bmp.Height);
            var source = GetBrightnes(bmp);
            using (var res = new ImageWrapper(result))
            {
                Point p = new Point();
                for (int w = 0; w < bmp.Width; w++)
                    for (int h = 0; h < bmp.Height; h++)
                    {
                        byte brightne = (byte)(source.Brightnes[h, w] / 2);
                        p.X = w;
                        p.Y = h;
                        res.SetPixel(p, brightne, brightne, brightne);
                    }
            }
            return result;
        }

            internal static Bitmap Process2(Bitmap bmp)
            {
                var result = new Bitmap(bmp.Width, bmp.Height);
                var dith = GetBrightnes(Resources.Dithering64x64);
                var source = GetBrightnes(bmp);
                using (var res = new ImageWrapper(result))
                {
                    Point p = new Point();
                    for(int w = 0; w < bmp.Width; w++)
                        for(int h = 0; h < bmp.Height; h++)
                        {
                            float dithPixel = dith.Brightnes[w % Resources.Dithering64x64.Width, h % Resources.Dithering64x64.Height] / 2.0F;
                            float     pixel = source.Brightnes[h, w] / 2.0F;
                            p.X = w;
                            p.Y = h;
                            if (pixel >= dithPixel)
                                res.SetPixel(p, 255, 255, 255);
                            else
                                res.SetPixel(p, 0, 0, 0);
                        }
                }
                return result;
            }

            internal static Bitmap Process3(Bitmap bmp)
            {
                var result = new Bitmap(bmp.Width, bmp.Height);
                var source = GetBrightnes(bmp);
                using (var res = new ImageWrapper(result))
                {
                    Point p = new Point();
                    for (int w = 0; w < bmp.Width; w++)
                        for (int h = 0; h < bmp.Height; h++)
                        {
                            byte brightne = (byte)(source.Brightnes[h, w] / 2);
                            p.X = w;
                            p.Y = h;
                            res.SetPixel(p, brightne, brightne, brightne);
                        }
                }
                return result;
            }

            internal static Bitmap Process2(Bitmap bmp)
            {
                var result = new Bitmap(bmp.Width, bmp.Height);
                var dith = GetBrightnes(Resources.Dithering64x64);
                var source = GetBrightnes(bmp);
                using (var res = new ImageWrapper(result))
                {
                    Point p = new Point();
                    for(int w = 0; w < bmp.Width; w++)
                        for(int h = 0; h < bmp.Height; h++)
                        {
                            byte dithPixel = (byte) (dith.Brightnes[w % Resources.Dithering64x64.Width, h % Resources.Dithering64x64.Height] / 2);
                            byte     pixel = (byte) (source.Brightnes[h, w] / 2);
                            p.X = w;
                            p.Y = h;
                            if (pixel >= dithPixel)
                                res.SetPixel(p, 255, 255, 255);
                            else
                                res.SetPixel(p, 0, 0, 0);
                        }
                }
                return result;
            }

int     dw = Resources.Dithering64x64.Width;
int     dh = Resources.Dithering64x64.Height;
using (var res = new ImageWrapper(result))
...
byte dithPixel = (byte) (dith.Brightnes[h % dh, w % dw] / 2);