Flood fill algorithm works slowly - opengl

Question

I've got code for flood fill algorithm.
void floodFill() {
float target[3] = { 1.0, 1.0, 0.0 };
float border[3] = { 1.0, 1.0, 1.0 };
float clearp[3] = { 0.0, 0.0, 0.0 };
std::stack<pixel*> colored;
if (!stack.empty()) // stack contains first pixel
colored.push(stack.top());
while(!colored.empty()) {
pixel *p = colored.top();
drawPixel(p->x, p->y, target);
colored.pop();
//up
float pix[3];
glReadPixels(p->x, p->y + KOEF, 1, 1, GL_RGB, GL_FLOAT, pix);
if (!compare(pix,border) && compare(pix,clearp)) {
pixel *pn = new pixel();
pn->x = p->x;
pn->y = p->y + KOEF;
colored.push(pn);
}
//down
glReadPixels(p->x, p->y - KOEF, 1, 1, GL_RGB, GL_FLOAT, pix);
if (!compare(pix,border) && compare(pix,clearp)) {
pixel *pn = new pixel();
pn->x = p->x;
pn->y = p->y - KOEF;
colored.push(pn);
}
//left
glReadPixels(p->x - KOEF, p->y, 1, 1, GL_RGB, GL_FLOAT, pix);
if (!compare(pix,border) && compare(pix,clearp)) {
pixel *pn = new pixel();
pn->x = p->x - KOEF;
pn->y = p->y;
colored.push(pn);
}
//right
glReadPixels(p->x + KOEF, p->y, 1, 1, GL_RGB, GL_FLOAT, pix);
if (!compare(pix,border) && compare(pix,clearp)) {
pixel *pn = new pixel();
pn->x = p->x + KOEF;
pn->y = p->y;
colored.push(pn);
}
}
}
I draw pixel using this method
void drawPixel(float x, float y, float *t) {
glRasterPos2i(x, y);
glDrawPixels(1, 1, GL_RGB, GL_FLOAT, t);
for(int i = 0; i < KOEF; i++) {
glRasterPos2i(x, y + i);
glDrawPixels(1, 1, GL_RGB, GL_FLOAT, t);
glRasterPos2i(x + i, y);
glDrawPixels(1, 1, GL_RGB, GL_FLOAT, t);
glRasterPos2i(x + i, y + i);
glDrawPixels(1, 1, GL_RGB, GL_FLOAT, t);
}
};
To fill some area I choose first pixel with mouse click and then call method floodFill.
void mouse(int button, int state, int x, int y) {
if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
pixel *p = new pixel();
p->x = x;
p->y = HEIGHT - y;
if (!stack.empty())
stack.pop();
stack.push(p); // first pixel
floodFill();
}
};
The result is (for example)
But it works very slow(several seconds. area on the picture - it was drawing it for 11 seconds. area around letter - 43 seconds). And I thought it slowly will draw pixel after pixel but it is waiting for several seconds and then I see the result.
my pc is
intel core 2 duo p8600 2.4 GHz
nvidia 9600m gt 512 mb
windows x86
ram 4 GB(3)`
Should it work so slow or there is a problem?

Answer 1

That's a terrible way to use OpenGL.
Do your flood-fill in host memory, upload the resulting bitmap to an OpenGL texture, and then render a quad with that texture.

Answer 2

Should it work so slow or there is a problem?
No, it should not. Because Photoshop can make it faster :-)
It looks like there are some efficiency-related issues.
You should not use OpenGL calls for single pixel operations. You should better make a buffered copy of the image, process (floodfill) it, then copy back.
Why are you using these strange float coordinates instead of normal integer pixel indices?
And what about not using floats for colors too? Floating point operations are slower than integer ones and float values needs further convesion to internal image format.
Your program seems to be too OOP-ish for its purpose. It is not good idea to use new and stack in the innermost loop of the image processing routine.