在图像中查找白色矩形

Question

我试图在图像中查找白色矩形。矩形大小是固定的。这是我想出作为尚未：

BufferedImage bImage = bufferedImage; 
int height = bufferedImage.getHeight(); //~1100px 
int width = bufferedImage.getWidth(); //~1600px 
int neededWidth = width/2; 
int neededHeight = 150; 
int x = 0; 
int y = 0; 
boolean breaker = false; 
boolean found = false; 
int rgb = 0xFF00FF00; 
int fx, fy; 

fx = fy = 0; 
JavaLogger.log.info("width, height: " + w + ", " + h); 
while ((x != (width/2) || y != (height - neededHeight)) && found == false) { 
for (int i = y; i - y < neededHeight + 1; i++) { 
    for (int j = x; j - x < neededWidth + 1; j++) { //Vareetu buut, ka +1 vajadziigs 
     //JavaLogger.log.info("x,y: " + j + ", " + i); 
     long pixel = bImage.getRGB(j, i); 
     if (pixel != colorWhite && pixel != -1) { 
      //bImage.setRGB(j, i, rgb); 
      //JavaLogger.log.info("x,y: " + (j+x) + ", " + (i+y)); 
      breaker = true; 
      break; 

     } else { 
      //bImage.setRGB(j, i, 0xFFFFFF00); 
     } 
     //printPixelARGB(pixel); 
     if ((i - y == neededHeight-10) && j - x == neededWidth-10) { 
      JavaLogger.log.info("width, height: " + x + ", " + y + "," + j + ", " + i); 
      fx = j; 
      fy = i; 
      found = true; 
      breaker = true; 
      break; 
     } 
    } 
    if (breaker) { 
     breaker = false; 
     break; 
    } 

} 

if (x < (width/2)) { 
    x++; 
} else { 
    if (y < (height - neededHeight)) { 
     y++; 
     x = 0; 
    } else { 
     break; 
    } 
    } 
//JavaLogger.log.info("width, height: " + x + ", " + y); 
} 

if (found == true) { 

    for (int i = y; i < fy; i++) { 
     for (int j = x; j < fx; j++) { 
      bImage.setRGB(j, i, 0xFF00FF3F); 
     } 

    } 

} 
JavaLogger.log.info("width, height: " + w + ", " + h); 

该工程确定，如果我需要的矩形接近(0;0)开始时，但因为它得到更远，性能下降相当严重。我想知道，如果有什么可以做的？

例如，该搜索了近8秒，这是相当多的。 我在想，这可以更有效地完成。也许一些blob发现？阅读它，但我不知道如何应用它。

而且，我是新来的Java和图像处理，所以任何帮助表示赞赏。

Answer 1

这是很粗糙的，但成功地找到图像中所有白色像素，更多的检查可以做，以确保它是你想要的大小，一切都在那里，但基本是有。 PS：我没有测试过你的图片。 r和this.rc是图片的大小和p和this.px是内部矩形大小

public static void main(String[] args) { 
    JFrame frame = new JFrame(); 
    final int r = 100; 
    final int p = 10; 

    NewJPanel pan = new NewJPanel(r, p, new A() { 
     @Override 
     public void doImage(BufferedImage i) { 
      int o = 0; 

      for (int j = 0; j < i.getWidth() - p; j++) { 
       for (int k = 0; k < i.getHeight() - p; k++) { 

        PixelGrabber pix2 = new PixelGrabber(
          i, j, k, p, p, false); 
        try { 
         pix2.grabPixels(); 
        } catch (InterruptedException ex) {} 

        int pixelColor = pix2.getColorModel() 
          .getRGB(pix2.getPixels()); 

        Color c = new Color(pixelColor); 
        if (c.equals(Color.WHITE)) { 
         System.out.println("Found at : x:" + j + ",y:" + k); 
        } 

       } 
      } 
     } 
    }); 

    frame.getContentPane().add(pan); 
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
    frame.setSize(500, 500); 
    frame.setLocationRelativeTo(null); 
    frame.setVisible(true); 
} 

private interface A { 
    void doImage(BufferedImage i); 
} 

private static class NewJPanel extends JPanel { 
    private static final long serialVersionUID = -5348356640373105209L; 

    private BufferedImage image = null; 
    private int px; 
    private int rc; 
    private A a; 

    public NewJPanel(int r, int p, A a) { 
     this.px = p; 
     this.rc = r; 
     this.a = a; 
    } 

    public BufferedImage getImage() { 
     return image; 
    } 

    @Override public void paint(Graphics g) { 
     super.paint(g); 

     image = new BufferedImage(this.rc, this.rc, 
       BufferedImage.TYPE_INT_ARGB); 
     java.awt.Graphics2D g2 = image.createGraphics(); 

     g2.setColor(Color.BLACK); 
     g2.fillRect(0, 0, this.rc, this.rc); 
     g2.setColor(Color.WHITE); 
     g2.fillRect(
       new Random().nextInt(this.rc - this.px), 
       new Random().nextInt(this.rc - this.px), 
       this.px, this.px); 

     g.drawImage(image, this.rc, this.rc, this); 
     this.a.doImage(this.image); 
    } 
} 

Answer 2

我不是专家，但我不认为代码的问题 - 你需要改变你的算法。我想通过在2D平面递归地寻找一个白色像素开始，像这样：

findWhitePixel（广场）{ 看像素在“广场”的中间 - 如果它是白色的回报，否则： findWhitePixel （'正方形'的右上角） findWhitePixel（左上角的'正方形'） findWhitePixel（右下角的'正方形'） findWhitePixel（正方形的左下角四分之一） }

找到白色像素后，尝试向上，向下，向左和向右拖动以找到您的形状边框。如果这是给定的，只能有矩形 - 你完成了。如果可能有其他形状（三角形，圆形等），则需要在此处进行验证。

Answer 3

你所要求可以被称为“糜烂”的操作来解决。该侵蚀用该位置（左上角）中请求大小的矩形中最暗的所有像素替换每个像素。在这里，最黑暗的意思是非白色取代白色。

侵蚀的输出是与W-1列和H-1的行少的图像。其中的任何白色像素对应于一个解决方案。

在矩形形状的幸运情况下，侵蚀是可分离的操作。这意味着您可以首先使用水平线段形状进行腐蚀，然后使用第一次侵蚀输出中的垂直线段形状。对于W x H的重调尺寸，这将W * H操作替换为W + H，这是一项重大的节省。

在二进制图像（非白色或白色）的也幸运的情况下，侵蚀由段能够极其高效地进行：在每一行中独立地，发现白色像素的所有连续运行，并打开W-1最右边的非白色。对所有列执行相同的操作，缩短H-1像素的白色运行。

实施例：找到所有3x2的矩形：

####....#### 
##.....#..## 
#..######... 
.....###.... 

3X1侵蚀后：

####..#### 
##...##### 
#########. 
...#####.. 

1x2的侵蚀后：

####.##### 
########## 
#########. 

该算法需要每像素恒定时间（不考虑矩形大小）。正确实施，应该花几个毫秒。