algoritmo de relleno de inundación

Question

im trabajando en una biblioteca simple gráfica en C ++ con Turbo C porque im el desarrollo de una versión muy primitiva de un programa de estilo de pintura, everyting funciona bien, pero no puedo conseguir el algoritmo de relleno de inundación para trabajar. Im usando el algoritmo de relleno hasta 4 vías, en primer lugar he intentado con la versión recursiva pero sólo trabajo con áreas pequeñas, llenando grandes superficies hacen accidente; lectura me encontré con que poner en práctica una versión pila explícita de que resolver el problema, pero yo realmente No te veo.

he desarrollado una pila de esta manera:

struct node
{
    int x, y;
    struct node *next;
};

int push(struct node **top, int x, int y)
{
    struct node *newNode;
    newNode = (struct node *)malloc(sizeof(struct node));
    if(newNode == NULL) //If there is no more memory
        return 0;
    newNode->x = x;
    newNode->y = y;
    newNode->next = *top;
    *top = newNode;
    return 1; //If we push the element correctly
}

int pop(struct node **top, int &x, int &y)
{
    if(*top == NULL) //If the stack is empty
        return 0;
    struct node *temporal;
    temporal = *top;
    x = (*top)->x;
    y = (*top)->y;
    *top = (*top)->next;
    free(temporal);
    return 1; //If we pop an element 
}

Y este es el código que tengo hacen a la función de relleno de inundación:

void floodFill(int x, int y, int color_to_replace, int color_to_fill)
{
    if(color_to_replace == color_to_fill)
  return;
 struct node *stack = NULL;
 if(push(&stack, x, y) == 0) //If we can´t push the pixel
            return;
    while(pop(&stack, x, y) == 1) //While are pixels in the stack
    {
        pixel(x, y, color_to_fill);
        if(x+1 < 640 && read_pixel(x+1, y) == color_to_replace)
            if(push(&stack, x+1, y) == 0)
                return;
        if(x-1 >= 0 && read_pixel(x-1, y) == color_to_replace)
            if(push(&stack, x-1, y) == 0)
                return;
        if(y+1 < 480 && read_pixel(x, y+1) == color_to_replace)
            if(push(&stack, x, y+1) == 0)
                return;
        if(y-1 >= 0 && read_pixel(x, y-1) == color_to_replace)
            if(push(&stack, x, y-1) == 0)
                return;
    }
}

Sin embargo, todavía no trabajamos, cuando estoy triying para llenar grandes áreas que parar y porque estoy trabajando con una resolución de 640 X 480 en mi programa eso es realmente un problema; cualquier idea por qué no funcionan?

Answer 1

En lugar de empujar cada píxel en la pila, tratar de llenar la mayor cantidad de píxeles en horizontal como sea posible antes de empujar una nueva posición en la pila. Vea la artículo de Wikipedia para una discusión.

Answer 2

No veo ninguna boundschecking en cualquier lugar ...

¿Estás seguro de que el X e Y los valores no salen de la imagen?

EDIT:

Ideas extra por qué no podría funcionar:

• Las funciones de píxeles de lectura y escritura tienen un error
• El valor de color a recuperar se escala hasta 32 bits (por ejemplo, porque la imagen es de 16 bits) y el color que usted está tratando de escribir y leer de nuevo, no coincidirá exactamente. (Por ejemplo, se escribe el color: 0xFF00FF pero que vuelvas: 0xf800f8 porque el color consiguió ampliarse de 16 bits) y esto se traducirá en el relleno de inundación pasando por siempre
.