java - Java 中的迭代数组

Question

我有包含黑白像素的数据 BufferedImage，它以二维数组表示，如下所示

 protected int[][] arr = {{1,1,1,1,1,0,0},
                          {1,0,0,0,1,0,0},
                          {1,0,0,0,1,0,0},
                          {1,1,1,1,1,0,0},
                          {0,0,0,0,0,0,0}};

数组值为 1 表示像素为白色，0 表示黑色像素。

我想创建一个程序，值得跟踪数组 1 和已跟踪转换为 0 的数组，如下所示:

第一次迭代:

0111100
1000100
1000100
1111100
0000000

第二次迭代:

0011100
1000100
1000100
1111100
0000000

第三:

0001100
1000100
1000100
1111100
0000000

第四:

0000100
1000100
1000100
1111100
0000000

第五:

0000000
1000100
1000100
1111100
0000000

第六:

0000000
1000000
1000100
1111100
0000000

直到最后一次迭代，所有数组值都将为 0。

我做了一个这样的程序:

public void cekNearby()
{
   /* for(int y=0;y<arr.length;y++)
    {
        for(int x=0;x<arr[0].length;x++)
        {
           */
            int x=0,y=0;
            if(arr2[y][x] ==1)
            {
                startPointX = x;
                startPointY = y;
                int moveNextX=x,tempX = arr.length;
                int moveNextY=y,tempY = arr[0].length;
                arr2[y][x]=0;
                while(startPointX!= tempX || startPointY != tempY)
                {
                    System.out.println("MoveNextX->"+moveNextX+"moveNextY->"+moveNextY+"tempX ->"+tempX+ " tempY ->" +tempY + " StartpointX->"+startPointX +" startPointY ->"+startPointY );

                    int moveY = max(0,moveNextY-1) ;
                    ketemu = false;
                    System.out.println("Atas "+moveNextX + " "+moveNextY);
                    while(moveY <= min(arr2.length-1,moveNextY+1) && ketemu == false)
                    {
                        System.out.println("ASD "+moveY);
                        int moveX = max(0,moveNextX-1);
                       while(moveX <=min(arr2[0].length-1,moveNextX+1) && ketemu == false)
                            {
                                System.out.print(" Y :" + moveY);
                                System.out.print(" X : "+moveX);
                                if(arr2[moveY][moveX]==1)
                                {
                                    arr2[moveY][moveX]=0;
                                    tempX = moveX;
                                    tempY = moveY;
                                    moveNextX = moveX;
                                    moveNextY = moveY;
                                    ketemu = true;
                                    System.out.print("Ketemu");
                                }else
                                {
                                    ketemu = false;
                                }
                                moveX++;
                            }


                        moveY++;
                        System.out.println();
                    }
                    print_array(arr2);
                }
            }
        }

但是，当迭代完成时，这些位置上会出现白色像素。

0000000
0000000
0000000
1000100
0000000

我的逻辑有什么问题吗？
任何建议将不胜感激。

Answer 1

看一下你的输出，你似乎使用了 8 个单元格的邻域；您似乎只想删除一个“运行”的 1 像素，因此这是正确的:

11100  01100  00100  00000  00000  00000  00000
10101  10101  10101  10101  10001  10001  00001
11101  11101  11101  11101  11101  10101  10101

在底部像素之前检查左下像素，在左侧像素之前检查左上角像素。如果您只想走直角，则需要使用四个邻域。在每种情况下，右侧断开的连接都会保留。

如果你想同时拥有直角和对角，你必须优先选择其中一个角度；按此(或类似)顺序检查周围像素:

516
2 3
748

如果您打算删除所有相邻单元，而不仅仅是单个连接运行中的单元，您可能需要 floodfill算法。