Яркость пикселей

//---------------------------------------------------------------------------
bool wj_BMP_to_BRIGHT_BlackAndWhite_byte(Graphics::TBitmap *bmp, BYTE level)
{
    int bmp_width = bmp->Width;
    int bmp_height = bmp->Height;
 
    bmp->PixelFormat = pf24bit;
 
    BYTE *col;
    BYTE bright;
    BYTE r, g, b;
 
    // v2
    for(int y = 0; y < bmp_height; y++)
    {
        col = (BYTE *)bmp->ScanLine[y]; // RGB -> BGR
        for(int x = 0; x < bmp_width * 3; x += 3)
        {
            b = col[x+0]; // B
            g = col[x+1]; // G
            r = col[x+2]; // R
 
            bright = (((r * 77) + (g * 151) + (b * 28)) >> 8); // вот так яркость пиксела получить можно
 
            // то что ниже можно не использовать, это для моей реализации
            if(bright >= level)
            {
                bright = 255;
                col[x+0] = bright; //b
                col[x+1] = bright; //g
                col[x+2] = bright; //r
            }
            else
            {
                bright = 0;
                col[x+0] = bright; //b
                col[x+1] = bright; //g
                col[x+2] = bright; //r
            }
        }
    }
    return 1;
}
//---------------------------------------------------------------------------

    int Color= ColorToRGB(clRed);
    BYTE r= GetRValue(Color);
    BYTE g= GetGValue(Color);
    BYTE b= GetBValue(Color);
 
   TColor Color2= TColor(RGB(r,g,b));

bright = 0.299*r + 0.587*g + 0.114*b;

bright = (r * 77 + g * 151 + b * 28) >> 8;

        int r = 10, g = 56, b = 17, bright;
 
        bright = 0.299*r + 0.587*g + 0.114*b; // начальная формула
        ShowMessage(bright);
 
        int to4nost = 8; // по умолчанию точность 8, из-за этого и сдвиг на 8 бит
        int rk = RoundTo(0.299 * pow(2, to4nost), 0);
        int gk = RoundTo(0.587 * pow(2, to4nost), 0);
        int bk = RoundTo(0.114 * pow(2, to4nost), 0);
 
        bright = (rk*r + gk*g +bk*b) >> to4nost;
        ShowMessage(bright);

Graphics::TBitmap *LoadedBmp = new Graphics::TBitmap;
char *col, y, u, v, sum=0, r, g, b;
int  bmp_height, bmp_width;
LoadedBmp->LoadFromFile("q.bmp");             // Загруженное изображение
Image1->Picture->Bitmap=LoadedBmp;
bmp_height=Image1->Picture->Bitmap->Height;   // Высота картинки
bmp_width=Image1->Picture->Bitmap->Width;     // Ширина картинки
LoadedBmp->PixelFormat=pf24bit;
for (int k=0;k<bmp_height;k++)
        {
        col=(char*)LoadedBmp->ScanLine[k];
        for (int i=0;i<bmp_width3;i+=3)
                {
                r=col[i];
                g=col[i+1];
                b=col[i+2];
                y=0.299*r+0.587*g+0.114*b;
                u=-0.14713*r-0.28886*g+0.436*b+128;
                v=0.615*r-0.51499*g-0.10001*b+128;

for (int a=i-1;a<i+1;a++)
                        {
                        for (int b=k-1;a<k+1;b++)
                                {
                                sum=sum+y;
                                }
                        }
y=sum/9;

r=y+1.13983*(v-128);
g=y-0.39465*(u-128)-0.58060*(v-128);
b=y+2.03211*(u-128);

LoadedBmp->Canvas->Pixels[i/3][k]=(RGB(r,g,b));

BYTE sum;
BYTE Y = 123;
sum = 123 + 123 + 123
// sum будет равен 113

//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
#include <Graphics.hpp>
#include <Jpeg.hpp>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
 
void MyFilter(Graphics::TBitmap *source, Graphics::TBitmap *dest);
 
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
        // исходное изображение
        TPicture *pic = new TPicture;
        pic->LoadFromFile("1.jpg");
 
        // src_bmp
        Graphics::TBitmap *src_bmp = new Graphics::TBitmap;
        src_bmp->Assign(pic->Graphic); // если в pic загружено jpeg, то здесь это изображение будет в bitmap формате
 
        // dest_bmp
        Graphics::TBitmap *dest_bmp = new Graphics::TBitmap;
        dest_bmp->Width = src_bmp->Width;
        dest_bmp->Height = src_bmp->Height;
 
        // применяем фильтр
        MyFilter(src_bmp, dest_bmp);
 
        // сохраняем результирующий bitmap
        dest_bmp->SaveToFile("2.bmp");
}
//---------------------------------------------------------------------------
 
 
void MyFilter(Graphics::TBitmap *source, Graphics::TBitmap *dest)
{
        int iWidth = source->Width;
        int iHeight = source->Height;
 
    // выделяем память под DIB (в нашем случае под оригинальную картинку)
    HANDLE hDIBSource = GlobalAlloc(0, 4*iWidth*iHeight);
    byte *pSource = (byte*)GlobalLock(hDIBSource);
 
        // BITMAPINFOHEADER
    BITMAPINFOHEADER   bi;
        bi.biSize = sizeof(BITMAPINFOHEADER);
    bi.biWidth = iWidth;
    bi.biHeight = iHeight;
    bi.biPlanes = 1;
    bi.biBitCount = 32;
    bi.biCompression = BI_RGB;
    bi.biSizeImage = 0;
    bi.biXPelsPerMeter = 0;
    bi.biYPelsPerMeter = 0;
    bi.biClrUsed = 0;
    bi.biClrImportant = 0;
        // копирует пиксели оригинальной картинки в DIB
    GetDIBits(source->Canvas->Handle, source->Handle, 0, iHeight, pSource, (BITMAPINFO*)&bi, DIB_RGB_COLORS);
 
        
    // выделяем память под Dest DIB
        HANDLE hDIBDest = GlobalAlloc(0, 4*iWidth*iHeight);
    byte *pDest = (byte*)GlobalLock(hDIBDest);
 
        // к исходному изображению применяем фильтр и сохраняем в результирующем изображении
    for ( int k = 0; k < iHeight; k++ ) // проходим каждую строку изображения
    {
            for ( int x = 0; x < iWidth; x++ ) // проходим каждый пиксель в текущей строке изображения
                {
                        // сглаживающий однородный усредняющий фильтр с шириной окна 3
                        int sum_r = 0, sum_g = 0, sum_b = 0, count_rgb = 0;
                        for ( int b = k-1; b <= k+1; b++ )
                        {
                                if (b < 0 || b >= iHeight) continue;
 
                                for ( int a = x-1; a <= x+1; a++ )
                                {
                                        if (a < 0 || a >= iWidth) continue;
 
                                        byte *pixel = pSource + 4*(b*iWidth + a);
 
                                        sum_r += pixel[2];
                                        sum_g += pixel[1];
                                        sum_b += pixel[0];
 
                                        count_rgb++;
                                }
                        }
 
                        sum_r /= count_rgb;
                        sum_g /= count_rgb;
                        sum_b /= count_rgb;
 
                        byte *pDestPixel = pDest + 4*(k*iWidth + x);
                        pDestPixel[2] = sum_r;
                        pDestPixel[1] = sum_g;
                        pDestPixel[0] = sum_b;
        }
    }
 
        // копируем биты на результирующий битмап
        SetDIBitsToDevice(dest->Canvas->Handle, 0, 0, iWidth, iHeight, 0, 0, 0, iHeight, pDest, (BITMAPINFO *)&bi, DIB_RGB_COLORS);
 
        // освобождаем память, выделенную под DIB'ы
        GlobalUnlock(hDIBDest);
        GlobalUnlock(hDIBSource);
        GlobalFree(hDIBDest);
        GlobalFree(hDIBSource);
}