圖像處理------泛洪填充算法(Flood Fill Algorithm) 油漆桶功能 分類： 視頻圖像處理 2015-07-24 15:03 68人閱讀 評論(0) 收藏

時間  2019-12-07
標籤 圖像處理 填充 算法 flood algorithm 漆桶 功能 分類 視頻 閱讀 評論 收藏 简体版
原文   原文鏈接

泛洪填充算法(Flood Fill Algorithm)java

泛洪填充算法又稱洪水填充算法是在不少圖形繪製軟件中經常使用的填充算法，最熟悉不過就是算法

windows paint的油漆桶功能。算法的原理很簡單，就是從一個點開始附近像素點，填充成新windows

的顏色，直到封閉區域內的全部像素點都被填充新顏色爲止。泛紅填充實現最多見有四鄰域ide

像素填充法，八鄰域像素填充法，基於掃描線的像素填充方法。根據實現又能夠分爲遞歸與測試

非遞歸（基於棧）。this

 

在介紹算法的三種實現方式以前，首先來看一下測試該算法的UI實現。基本思路是選擇一url

張要填充的圖片，鼠標點擊待填充的區域內部，算法會自動填充該區域，而後UI刷新。完spa

整的UI代碼以下：.net

[java]  view plain copy
  1. package com.gloomyfish.paint.fill;  
  2.   
  3. import java.awt.Color;  
  4. import java.awt.Dimension;  
  5. import java.awt.Graphics;  
  6. import java.awt.Graphics2D;  
  7. import java.awt.MediaTracker;  
  8. import java.awt.event.MouseEvent;  
  9. import java.awt.event.MouseListener;  
  10. import java.awt.image.BufferedImage;  
  11. import java.io.File;  
  12. import java.io.IOException;  
  13.   
  14. import javax.imageio.ImageIO;  
  15. import javax.swing.JComponent;  
  16. import javax.swing.JFileChooser;  
  17. import javax.swing.JFrame;  
  18.   
  19. public class FloodFillUI extends JComponent implements MouseListener{  
  20.       
  21.     /** 
  22.      *  
  23.      */  
  24.     private static final long serialVersionUID = 1L;  
  25.     private BufferedImage rawImg;  
  26.     private MediaTracker tracker;  
  27.     private Dimension mySize;  
  28.     FloodFillAlgorithm ffa;  
  29.     public FloodFillUI(File f)  
  30.     {  
  31.         try {  
  32.             rawImg = ImageIO.read(f);  
  33.         } catch (IOException e1) {  
  34.             e1.printStackTrace();  
  35.         }  
  36.           
  37.         tracker = new MediaTracker(this);  
  38.         tracker.addImage(rawImg, 1);  
  39.           
  40.         // blocked 10 seconds to load the image data  
  41.         try {  
  42.             if (!tracker.waitForID(1, 10000)) {  
  43.                 System.out.println("Load error.");  
  44.                 System.exit(1);  
  45.             }// end if  
  46.         } catch (InterruptedException e) {  
  47.             e.printStackTrace();  
  48.             System.exit(1);  
  49.         }// end catch  
  50.           
  51.         mySize = new Dimension(300, 300);  
  52.         this.addMouseListener(this);  
  53.         ffa = new FloodFillAlgorithm(rawImg);  
  54.         JFrame imageFrame = new JFrame("Flood File Algorithm Demo - Gloomyfish");  
  55.         imageFrame.getContentPane().add(this);  
  56.         imageFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  57.         imageFrame.pack();  
  58.         imageFrame.setVisible(true);  
  59.     }  
  60.   
  61.     public void paint(Graphics g) {  
  62.         Graphics2D g2 = (Graphics2D) g;  
  63.         g2.drawImage(rawImg, 10, 10, rawImg.getWidth(), rawImg.getHeight(), null);  
  64.     }  
  65.     public Dimension getPreferredSize() {  
  66.         return mySize;  
  67.     }  
  68.       
  69.     public Dimension getMinimumSize() {  
  70.         return mySize;  
  71.     }  
  72.       
  73.     public Dimension getMaximumSize() {  
  74.         return mySize;  
  75.     }  
  76.       
  77.     public static void main(String[] args) {  
  78.         JFileChooser chooser = new JFileChooser();  
  79.         chooser.showOpenDialog(null);  
  80.         File f = chooser.getSelectedFile();  
  81.         new FloodFillUI(f);  
  82.     }  
  83.   
  84.     @Override  
  85.     public void mouseClicked(MouseEvent e) {  
  86.         System.out.println("Mouse Clicked Event!!");  
  87.         int x = (int)e.getPoint().getX();  
  88.         int y = (int)e.getPoint().getY();  
  89.         System.out.println("mouse location x = " + x); // column  
  90.         System.out.println("mouse location y = " + y); // row  
  91.         System.out.println();  
  92.         long startTime = System.nanoTime();  
  93.         // ffa.floodFill4(x, y, Color.GREEN.getRGB(), ffa.getColor(x, y));  
  94.         // ffa.floodFill8(x, y, Color.GREEN.getRGB(), ffa.getColor(x, y));  
  95.         // ffa.floodFillScanLine(x, y, Color.GREEN.getRGB(), ffa.getColor(x, y)); // 13439051  
  96.         ffa.floodFillScanLineWithStack(x, y, Color.GREEN.getRGB(), ffa.getColor(x, y)); // - 16660142  
  97.         long endTime = System.nanoTime() - startTime;  
  98.         System.out.println("run time = " + endTime);  
  99.         ffa.updateResult();  
  100.         this.repaint();  
  101.     }  
  102.   
  103.     @Override  
  104.     public void mousePressed(MouseEvent e) {  
  105.         // TODO Auto-generated method stub  
  106.           
  107.     }  
  108.   
  109.     @Override  
  110.     public void mouseReleased(MouseEvent e) {  
  111.         // TODO Auto-generated method stub  
  112.           
  113.     }  
  114.   
  115.     @Override  
  116.     public void mouseEntered(MouseEvent e) {  
  117.         // TODO Auto-generated method stub  
  118.           
  119.     }  
  120.   
  121.     @Override  
  122.     public void mouseExited(MouseEvent e) {  
  123.         // TODO Auto-generated method stub  
  124.           
  125.     }  
  126.   
  127. }  

首先介紹四鄰域的泛洪填充算法，尋找像素點p(x, y)的上下左右四個臨近像素點，若是沒有orm

被填充，則填充它們，而且繼續尋找它們的四鄰域像素，直到封閉區域徹底被新顏色填充。

藍色方格爲四個鄰域像素， p(x, y)爲當前像素點。

基於遞歸實現代碼很簡單：

[java]  view plain copy
  1. public void floodFill4(int x, int y, int newColor, int oldColor)  
  2. {  
  3.     if(x >= 0 && x < width && y >= 0 && y < height   
  4.             && getColor(x, y) == oldColor && getColor(x, y) != newColor)   
  5.     {   
  6.         setColor(x, y, newColor); //set color before starting recursion  
  7.         floodFill4(x + 1, y,     newColor, oldColor);  
  8.         floodFill4(x - 1, y,     newColor, oldColor);  
  9.         floodFill4(x,     y + 1, newColor, oldColor);  
  10.         floodFill4(x,     y - 1, newColor, oldColor);  
  11.     }     
  12. }  

八鄰域的填充算法，則是在四鄰域的基礎上增長了左上，左下，右上，右下四個相鄰像素。

並遞歸尋找它們的八鄰域像素填充，直到區域徹底被新顏色填充。


藍色方格爲四個鄰域像素，黃色爲左上，左下，右上，右下四個像素， p(x, y)爲當前像素點。

基於遞歸實現的代碼也很簡單：

[java]  view plain copy
  1. public void floodFill8(int x, int y, int newColor, int oldColor)  
  2. {  
  3.     if(x >= 0 && x < width && y >= 0 && y < height &&   
  4.             getColor(x, y) == oldColor && getColor(x, y) != newColor)   
  5.     {   
  6.         setColor(x, y, newColor); //set color before starting recursion  
  7.         floodFill8(x + 1, y,     newColor, oldColor);  
  8.         floodFill8(x - 1, y,     newColor, oldColor);  
  9.         floodFill8(x,     y + 1, newColor, oldColor);  
  10.         floodFill8(x,     y - 1, newColor, oldColor);  
  11.         floodFill8(x + 1, y + 1, newColor, oldColor);  
  12.         floodFill8(x - 1, y - 1, newColor, oldColor);  
  13.         floodFill8(x - 1, y + 1, newColor, oldColor);  
  14.         floodFill8(x + 1, y - 1, newColor, oldColor);  
  15.     }     
  16. }  

基於掃描線實現的泛洪填充算法的主要思想是根據當前輸入的點p(x, y)，沿y方向分別向上

與向下掃描填充，同時向左p(x-1, y)與向右p(x+1, y)遞歸尋找新的掃描線，直到遞歸結束。

代碼以下：

[java]  view plain copy
  1. public void floodFillScanLine(int x, int y, int newColor, int oldColor)  
  2. {  
  3.     if(oldColor == newColor) return;  
  4.     if(getColor(x, y) != oldColor) return;  
  5.         
  6.     int y1;  
  7.       
  8.     //draw current scanline from start position to the top  
  9.     y1 = y;  
  10.     while(y1 < height && getColor(x, y1) == oldColor)  
  11.     {  
  12.         setColor(x, y1, newColor);  
  13.         y1++;  
  14.     }      
  15.       
  16.     //draw current scanline from start position to the bottom  
  17.     y1 = y - 1;  
  18.     while(y1 >= 0 && getColor(x, y1) == oldColor)  
  19.     {  
  20.         setColor(x, y1, newColor);  
  21.         y1--;  
  22.     }  
  23.       
  24.     //test for new scanlines to the left  
  25.     y1 = y;  
  26.     while(y1 < height && getColor(x, y1) == newColor)  
  27.     {  
  28.         if(x > 0 && getColor(x - 1, y1) == oldColor)   
  29.         {  
  30.             floodFillScanLine(x - 1, y1, newColor, oldColor);  
  31.         }   
  32.         y1++;  
  33.     }  
  34.     y1 = y - 1;  
  35.     while(y1 >= 0 && getColor(x, y1) == newColor)  
  36.     {  
  37.         if(x > 0 && getColor(x - 1, y1) == oldColor)   
  38.         {  
  39.             floodFillScanLine(x - 1, y1, newColor, oldColor);  
  40.         }  
  41.         y1--;  
  42.     }   
  43.       
  44.     //test for new scanlines to the right   
  45.     y1 = y;  
  46.     while(y1 < height && getColor(x, y1) == newColor)  
  47.     {  
  48.         if(x < width - 1 && getColor(x + 1, y1) == oldColor)   
  49.         {             
  50.             floodFillScanLine(x + 1, y1, newColor, oldColor);  
  51.         }   
  52.         y1++;  
  53.     }  
  54.     y1 = y - 1;  
  55.     while(y1 >= 0 && getColor(x, y1) == newColor)  
  56.     {  
  57.         if(x < width - 1 && getColor(x + 1, y1) == oldColor)   
  58.         {  
  59.             floodFillScanLine(x + 1, y1, newColor, oldColor);  
  60.         }  
  61.         y1--;  
  62.     }  
  63. }  

基於遞歸實現的泛洪填充算法有個致命的缺點，就是對於大的區域填充時可能致使JAVA棧溢出

錯誤，對最後一種基於掃描線的算法，實現了一種非遞歸的泛洪填充算法。

[java]  view plain copy
  1. public void floodFillScanLineWithStack(int x, int y, int newColor, int oldColor)  
  2. {  
  3.     if(oldColor == newColor) {  
  4.         System.out.println("do nothing !!!, filled area!!");  
  5.         return;  
  6.     }  
  7.     emptyStack();  
  8.       
  9.     int y1;   
  10.     boolean spanLeft, spanRight;  
  11.     push(x, y);  
  12.       
  13.     while(true)  
  14.     {      
  15.         x = popx();  
  16.         if(x == -1) return;  
  17.         y = popy();  
  18.         y1 = y;  
  19.         while(y1 >= 0 && getColor(x, y1) == oldColor) y1--; // go to line top/bottom  
  20.         y1++; // start from line starting point pixel  
  21.         spanLeft = spanRight = false;  
  22.         while(y1 < height && getColor(x, y1) == oldColor)  
  23.         {  
  24.             setColor(x, y1, newColor);  
  25.             if(!spanLeft && x > 0 && getColor(x - 1, y1) == oldColor)// just keep left line once in the stack  
  26.             {  
  27.                 push(x - 1, y1);  
  28.                 spanLeft = true;  
  29.             }  
  30.             else if(spanLeft && x > 0 && getColor(x - 1, y1) != oldColor)  
  31.             {  
  32.                 spanLeft = false;  
  33.             }  
  34.             if(!spanRight && x < width - 1 && getColor(x + 1, y1) == oldColor) // just keep right line once in the stack  
  35.             {  
  36.                 push(x + 1, y1);  
  37.                 spanRight = true;  
  38.             }  
  39.             else if(spanRight && x < width - 1 && getColor(x + 1, y1) != oldColor)  
  40.             {  
  41.                 spanRight = false;  
  42.             }   
  43.             y1++;  
  44.         }  
  45.     }  
  46.       
  47. }  
運行效果：


算法類源代碼以下：

[java]  view plain copy
  1. package com.gloomyfish.paint.fill;  
  2.   
  3. import java.awt.image.BufferedImage;  
  4.   
  5. import com.gloomyfish.filter.study.AbstractBufferedImageOp;  
  6.   
  7. public class FloodFillAlgorithm extends AbstractBufferedImageOp {  
  8.   
  9.     private BufferedImage inputImage;  
  10.     private int[] inPixels;  
  11.     private int width;  
  12.     private int height;  
  13.       
  14.     //  stack data structure  
  15.     private int maxStackSize = 500; // will be increased as needed  
  16.     private int[] xstack = new int[maxStackSize];  
  17.     private int[] ystack = new int[maxStackSize];  
  18.     private int stackSize;  
  19.   
  20.     public FloodFillAlgorithm(BufferedImage rawImage) {  
  21.         this.inputImage = rawImage;  
  22.         width = rawImage.getWidth();  
  23.         height = rawImage.getHeight();  
  24.         inPixels = new int[width*height];  
  25.         getRGB(rawImage, 0, 0, width, height, inPixels );  
  26.     }  
  27.   
  28.     public BufferedImage getInputImage() {  
  29.         return inputImage;  
  30.     }  
  31.   
  32.     public void setInputImage(BufferedImage inputImage) {  
  33.         this.inputImage = inputImage;  
  34.     }  
  35.       
  36.     public int getColor(int x, int y)  
  37.     {  
  38.         int index = y * width + x;  
  39.         return inPixels[index];  
  40.     }  
  41.       
  42.     public void setColor(int x, int y, int newColor)  
  43.     {  
  44.         int index = y * width + x;  
  45.         inPixels[index] = newColor;  
  46.     }  
  47.       
  48.     public void updateResult()  
  49.     {  
  50.         setRGB( inputImage, 0, 0, width, height, inPixels );  
  51.     }  
  52.       
  53.     /** 
  54.      * it is very low calculation speed and cause the stack overflow issue when fill  
  55.      * some big area and irregular shape. performance is very bad. 
  56.      *  
  57.      * @param x 
  58.      * @param y 
  59.      * @param newColor 
  60.      * @param oldColor 
  61.      */  
  62.     public void floodFill4(int x, int y, int newColor, int oldColor)  
  63.     {  
  64.         if(x >= 0 && x < width && y >= 0 && y < height   
  65.                 && getColor(x, y) == oldColor && getColor(x, y) != newColor)   
  66.         {   
  67.             setColor(x, y, newColor); //set color before starting recursion  
  68.             floodFill4(x + 1, y,     newColor, oldColor);  
  69.             floodFill4(x - 1, y,     newColor, oldColor);  
  70.             floodFill4(x,     y + 1, newColor, oldColor);  
  71.             floodFill4(x,     y - 1, newColor, oldColor);  
  72.         }     
  73.     }  
  74.     /** 
  75.      *  
  76.      * @param x 
  77.      * @param y 
  78.      * @param newColor 
  79.      * @param oldColor 
  80.      */  
  81.     public void floodFill8(int x, int y, int newColor, int oldColor)  
  82.     {  
  83.         if(x >= 0 && x < width && y >= 0 && y < height &&   
  84.                 getColor(x, y) == oldColor && getColor(x, y) != newColor)   
  85.         {   
  86.             setColor(x, y, newColor); //set color before starting recursion  
  87.             floodFill8(x + 1, y,     newColor, oldColor);  
  88.             floodFill8(x - 1, y,     newColor, oldColor);  
  89.             floodFill8(x,     y + 1, newColor, oldColor);  
  90.             floodFill8(x,     y - 1, newColor, oldColor);  
  91.             floodFill8(x + 1, y + 1, newColor, oldColor);  
  92.             floodFill8(x - 1, y - 1, newColor, oldColor);  
  93.             floodFill8(x - 1, y + 1, newColor, oldColor);  
  94.             floodFill8(x + 1, y - 1, newColor, oldColor);  
  95.         }     
  96.     }  
  97.       
  98.     /** 
  99.      *  
  100.      * @param x 
  101.      * @param y 
  102.      * @param newColor 
  103.      * @param oldColor 
  104.      */  
  105.     public void floodFillScanLine(int x, int y, int newColor, int oldColor)  
  106.     {  
  107.         if(oldColor == newColor) return;  
  108.         if(getColor(x, y) != oldColor) return;  
  109.             
  110.         int y1;  
  111.           
  112.         //draw current scanline from start position to the top  
  113.         y1 = y;  
  114.         while(y1 < height && getColor(x, y1) == oldColor)  
  115.         {  
  116.             setColor(x, y1, newColor);  
  117.             y1++;  
  118.         }      
  119.           
  120.         //draw current scanline from start position to the bottom  
  121.         y1 = y - 1;  
  122.         while(y1 >= 0 && getColor(x, y1) == oldColor)  
  123.         {  
  124.             setColor(x, y1, newColor);  
  125.             y1--;  
  126.         }  
  127.           
  128.         //test for new scanlines to the left  
  129.         y1 = y;  
  130.         while(y1 < height && getColor(x, y1) == newColor)  
  131.         {  
  132.             if(x > 0 && getColor(x - 1, y1) == oldColor)   
  133.             {  
  134.                 floodFillScanLine(x - 1, y1, newColor, oldColor);  
  135.             }   
  136.             y1++;  
  137.         }  
  138.         y1 = y - 1;  
  139.         while(y1 >= 0 && getColor(x, y1) == newColor)  
  140.         {  
  141.             if(x > 0 && getColor(x - 1, y1) == oldColor)   
  142.             {  
  143.                 floodFillScanLine(x - 1, y1, newColor, oldColor);  
  144.             }  
  145.             y1--;  
  146.         }   
  147.           
  148.         //test for new scanlines to the right   
  149.         y1 = y;  
  150.         while(y1 < height && getColor(x, y1) == newColor)  
  151.         {  
  152.             if(x < width - 1 && getColor(x + 1, y1) == oldColor)   
  153.             {             
  154.                 floodFillScanLine(x + 1, y1, newColor, oldColor);  
  155.             }   
  156.             y1++;  
  157.         }  
  158.         y1 = y - 1;  
  159.         while(y1 >= 0 && getColor(x, y1) == newColor)  
  160.         {  
  161.             if(x < width - 1 && getColor(x + 1, y1) == oldColor)   
  162.             {  
  163.                 floodFillScanLine(x + 1, y1, newColor, oldColor);  
  164.             }  
  165.             y1--;  
  166.         }  
  167.     }  
  168.       
  169.     public void floodFillScanLineWithStack(int x, int y, int newColor, int oldColor)  
  170.     {  
  171.         if(oldColor == newColor) {  
  172.             System.out.println("do nothing !!!, filled area!!");  
  173.             return;  
  174.         }  
  175.         emptyStack();  
  176.           
  177.         int y1;   
  178.         boolean spanLeft, spanRight;  
  179.         push(x, y);  
  180.           
  181.         while(true)  
  182.         {      
  183.             x = popx();  
  184.             if(x == -1) return;  
  185.             y = popy();  
  186.             y1 = y;  
  187.             while(y1 >= 0 && getColor(x, y1) == oldColor) y1--; // go to line top/bottom  
  188.             y1++; // start from line starting point pixel  
  189.             spanLeft = spanRight = false;  
  190.             while(y1 < height && getColor(x, y1) == oldColor)  
  191.             {  
  192.                 setColor(x, y1, newColor);  
  193.                 if(!spanLeft && x > 0 && getColor(x - 1, y1) == oldColor)// just keep left line once in the stack  
  194.                 {  
  195.                     push(x - 1, y1);  
  196.                     spanLeft = true;  
  197.                 }  
  198.                 else if(spanLeft && x > 0 && getColor(x - 1, y1) != oldColor)  
  199.                 {  
  200.                     spanLeft = false;  
  201.                 }  
  202.                 if(!spanRight && x < width - 1 && getColor(x + 1, y1) == oldColor) // just keep right line once in the stack  
  203.                 {  
  204.                     push(x + 1, y1);  
  205.                     spanRight = true;  
  206.                 }  
  207.                 else if(spanRight && x < width - 1 && getColor(x + 1, y1) != oldColor)  
  208.                 {  
  209.                     spanRight = false;  
  210.                 }   
  211.                 y1++;  
  212.             }  
  213.         }  
  214.           
  215.     }  
  216.       
  217.     private void emptyStack() {  
  218.         while(popx() != - 1) {  
  219.             popy();  
  220.         }  
  221.         stackSize = 0;  
  222.     }  
  223.   
  224.     final void push(int x, int y) {  
  225.         stackSize++;  
  226.         if (stackSize==maxStackSize) {  
  227.             int[] newXStack = new int[maxStackSize*2];  
  228.             int[] newYStack = new int[maxStackSize*2];  
  229.             System.arraycopy(xstack, 0, newXStack, 0, maxStackSize);  
  230.             System.arraycopy(ystack, 0, newYStack, 0, maxStackSize);  
  231.             xstack = newXStack;  
  232.             ystack = newYStack;  
  233.             maxStackSize *= 2;  
  234.         }  
  235.         xstack[stackSize-1] = x;  
  236.         ystack[stackSize-1] = y;  
  237.     }  
  238.       
  239.     final int popx() {  
  240.         if (stackSize==0)  
  241.             return -1;  
  242.         else  
  243.             return xstack[stackSize-1];  
  244.     }  
  245.   
  246.     final int popy() {  
  247.         int value = ystack[stackSize-1];  
  248.         stackSize--;  
  249.         return value;  
  250.     }  
  251.   
  252.     @Override  
  253.     public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
  254.         // TODO Auto-generated method stub  
  255.         return null;  
  256.     }  
  257.   
  258. }  
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程