Получить яркость пикселя в 8-битном изображении

 public class MarshalBitmap
    {
        public Bitmap ImageSource { get; set; }
        IntPtr Iptr = IntPtr.Zero;
        BitmapData bitmapData = null;
 
        public byte[] Pixels { get; set; }
        public int Depth { get; private set; }
        public int Width { get; private set; }
        public int Height { get; private set; }
 
        public MarshalBitmap(Bitmap ImageSource)
        {
            this.ImageSource = ImageSource;
        }
 
        public void LockBits()
        {
            try
            {
                // Получаем высоту и ширину bitmap
                Width = ImageSource.Width;
                Height = ImageSource.Height;
 
                // Получаем общее число пикселей
                int PixelCount = Width * Height;
 
                // Создаем прямоугольную область по размеру изображения
                Rectangle rect = new Rectangle(0, 0, Width, Height);
 
                //Получаем глубину изображения
                Depth = Image.GetPixelFormatSize(ImageSource.PixelFormat);
 
                // Проверка по глубине
                if (Depth != 8 && Depth != 24 && Depth != 32)
                {
                    throw new ArgumentException("Only 8, 24 and 32 bpp images are supported.");
                }
 
                // Блокируем bitmap и возвращаем bitmap data
                bitmapData = ImageSource.LockBits(rect, ImageLockMode.ReadWrite,
                                             ImageSource.PixelFormat);
 
                // Создаем пустой массив байтов
                int step = Depth / 8;
                Pixels = new byte[PixelCount * step];
                Iptr = bitmapData.Scan0;
 
                // Копируем данные с указателя в массив байтов
                Marshal.Copy(Iptr, Pixels, 0, Pixels.Length);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
 
        public void UnlockBits()
        {
            try
            {
                // Копируем данные с массива байтов на указатель
                Marshal.Copy(Pixels, 0, Iptr, Pixels.Length);
 
                // Разблокируем bitmap data
                ImageSource.UnlockBits(bitmapData);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
 
public double GetPixelBright(int x, int y)
        {
            Color clr = Color.Empty;
            double bright = 0;
 
            // Получаем число цветовых компонентов на один пиксель
            int cCount = Depth / 8;
 
            // Определяем стартовую позицию
            int i = ((y * Width) + x) * cCount;
 
            if (i > Pixels.Length - cCount)
                throw new IndexOutOfRangeException();
 
            if (Depth == 32) // Для 32 бит get Red, Green, Blue и Alpha
            {
                byte b = Pixels[i];
                byte g = Pixels[i + 1];
                byte r = Pixels[i + 2];
                byte a = Pixels[i + 3]; // a
                clr = Color.FromArgb(a, r, g, b);
            }
            if (Depth == 24) // Для 24 бит get Red, Green и Blue
            {
                byte b = Pixels[i];
                byte g = Pixels[i + 1];
                byte r = Pixels[i + 2];
                clr = Color.FromArgb(r, g, b);
            }
            if (Depth == 8)
            // Для 8 бит (Red, Green and Blue - одинаковые???)
            {
                byte c = Pixels[i];
                clr = Color.FromArgb(c, c, c);
            }
            bright = 0.2126 * clr.R + 0.7152 * clr.G + 0.0722 * clr.B;
            return bright;
        }