Fastest RGB color detection C++ - c++

Question

Hi i have used getpixel method, bitblt or what its called (creating bitmap header) and then going though all the values. It is VERY slow. For exapmple if i had to detect something red or specific color it would take very long time. There has gotta be faster way right? I did try using desktop as HWND and then the window i need to find the colors, but desktop was somehow faster.. guesing because it had to look for the window i guess. I get HIGH cpu usage using both methods.
void Get_Color(int x,int y,int w,int h,int &red,int &green,int &blue,int action)
{
HDC hdc, hdcTemp;
RECT rect;
BYTE*bitPointer;
HWND Desktop = GetDesktopWindow();
hdc = GetDC(Desktop);
GetWindowRect(Desktop, &rect);
hdcTemp = CreateCompatibleDC(hdc);
BITMAPINFO bitmap;
bitmap.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bitmap.bmiHeader.biWidth = w;
bitmap.bmiHeader.biHeight = h;
bitmap.bmiHeader.biPlanes = 1;
bitmap.bmiHeader.biBitCount = 32;
bitmap.bmiHeader.biCompression = BI_RGB;
bitmap.bmiHeader.biSizeImage = 0;
bitmap.bmiHeader.biClrUsed = 0;
bitmap.bmiHeader.biClrImportant = 0;
HBITMAP hBitmap2 = CreateDIBSection(hdcTemp, &bitmap, DIB_RGB_COLORS, (void**)(&bitPointer), NULL, NULL);
HGDIOBJ save = SelectObject(hdcTemp, hBitmap2);
BitBlt(hdcTemp, 0, 0, w, h, hdc, x, y, SRCCOPY);
if(action==1)
{
for(int j=0;j<=w*h*4;j+=4)
{
red = bitPointer[j+2];
green = bitPointer[j+1];
blue = bitPointer[j];
if(red<30 && green>190 && blue>190)
{
break;
}
}
}
else
{
for(int j=0;j<=w*h*4;j+=4)
{
red = bitPointer[j+2];
green = bitPointer[j+1];
blue = bitPointer[j];
break;
}
}
///RELEASE
DeleteObject( SelectObject(hdcTemp, save) );
DeleteDC(hdcTemp);
DeleteDC(hdc);
ReleaseDC(NULL,hdc);
ReleaseDC(NULL,hdcTemp);
}

Answer 1

You may try to break your search. First search in the red channel and, when this succeed look for blue and green values:
for (int j=0; j<=w*h*4; j+=4){
red = bitPointer[j+2];
if (red<30) {
green = bitPointer[j+1];
blue = bitPointer[j];
if (green>190 && blue>190) {
do_something;
}
}
}
You can also try to accelerate via pointer arithmetic (but a good compiler will easily optimize the former):
for (BYTE *pRed=bitPointer+2; pRed<=bitPointer+w*h*4; pRed+=4){
if (pRed<30) {
green = pRed[-1];
blue = pRed[-2];
if (green>190 && blue>190) {
do_something;
}
}
}
If this is not sufficient, you may think about using threads to break the search into separate parallels smaller searches.

Answer 2

I suggest you create a table of RGB values from the bitmap. This would only need to be performed once.
struct RGB
{
unsigned int red;
unsigned int green;
unsigned int blue;
};
RGB rgb_pixels[MAX_ROWS][MAX_COLUMNS];
// ...
for (unsigned int row = 0; row < MAX_ROWS; ++row)
{
for (unsigned int column = 0; column < MAX_COLUMNS; ++column)
{
unsigned red = get_red_value(row, column);
unsigned green = get_green_value(row, column);
unsigned blue = get_blue_value(row, column);
RGB pixel;
pixel.red = red;
pixel.green = green;
pixel.blue = blue;
rgb_pixels[row][column] = pixel;
}
}
Whenever your program needs RGB info from the bitmap, index the array (rgb_pixels).
Accessing the RGB pixel array will be much faster than searching the bitmap and converting, for each pixel you are interested in.

Answer 3

Basically every time you call your method, it is creating an entirely new bitmap and copying it again. You could speed up your program the most by keeping the array of colors between calls to Get_Color(). You could put it in a class or a global variable. Thomas Matthews has a good idea for that. Once that's fixed, Jean-Baptiste Yunès has some good advice to look into.