Explication du remplissage d'inondation

Question

Je travaille avec mon projet avec des fonctions paiting/coloring. Est-ce que quelqu'un peut expliquer cet algorithme de remplissage d'inondation et comment cela fonctionne? Cette file d'attente est-elle remplie? et que signifie la file d'attente (dans cet algorithme)?

public class FloodFill { 
    public void floodFill(Bitmap image, Point node, int targetColor, 
          int replacementColor) { 
     int width = image.getWidth(); 
     int height = image.getHeight(); 
     int target = targetColor; 
     int replacement = replacementColor; 
     if (target != replacement) { 
      Queue<Point> queue = new LinkedList<Point>(); 
      do { 

       int x = node.x; 
       int y = node.y; 
       while (x > 0 && image.getPixel(x - 1, y) == target) { 
        x--; 

       } 
       boolean spanUp = false; 
       boolean spanDown = false; 
       while (x < width && image.getPixel(x, y) == target) { 
        image.setPixel(x, y, replacement); 
        if (!spanUp && y > 0 
          && image.getPixel(x, y - 1) == target) { 
         queue.add(new Point(x, y - 1)); 
         spanUp = true; 
        } else if (spanUp && y > 0 
          && image.getPixel(x, y - 1) != target) { 
         spanUp = false; 
        } 
        if (!spanDown && y < height - 1 
          && image.getPixel(x, y + 1) == target) { 
         queue.add(new Point(x, y + 1)); 
         spanDown = true; 
        } else if (spanDown && y < height - 1 
          && image.getPixel(x, y + 1) != target) { 
         spanDown = false; 
        } 
        x++; 
       } 
      } while ((node = queue.poll()) != null); 
     } 
    } 
} 

Answer 1

Il n'y a pas un nom spécifique pour cet algorithme, mais au moment de remplir de grandes surfaces, je recommanderais QueueLinear Flood Fill algorith ce qui est beaucoup plus rapide que ce qui précède.

Voici un lien vers la mise en œuvre:

http://www.codeproject.com/Articles/16405/Queue-Linear-Flood-Fill-A-Fast-Flood-Fill-Algorith