C# - 查找图像的边界（而不是大小）

Question

我正在开发一个应用程序来平均分割图像网格并将图像居中（基于图像的相似性）。到目前为止，我可以设法修复小尺寸的图像网格，但每当我尝试更大的“精灵”尺寸（例如 100x100）时，我都会收到堆栈溢出错误。

是的，我正在使用递归，但每当检查一个像素时，我都会设置一个布尔值来停用它，将其复制到列表中并继续检查其他像素（在所有方向上），直到列表填满来自网格。我不确定这是否是最好的方法，因为对于每次调用，我都会调用相同的方法 7 次（假设有 7 个相邻像素尚未检查）...直到没有任何像素可供检查，并且我可以继续查看网格中的下一个图像。

我尝试追踪错误开始发生的位置，是在检查了大约 1600 个像素并将它们添加到列表中之后。 MyPixel 是一个包含 4 个变量的类：x(int)、y(int)、color (Color) 和checked (bool)

    public void processSprite(int i, int j)
    {
        //OOO
        //OXO
        //OOO
        pixeltemp.Add(new MyPixel(imap.pixels[i, j].x, imap.pixels[i, j].y, imap.pixels[i, j].color));
        imap.pixels[i, j].read = true;
        //OOO
        //OOX
        //OOO
        try
        {
            if (!imap.pixels[i + 1, j].read)
            {
                if (imap.pixels[i + 1, j].color.A == 0) //Found a Border
                {
                    imap.pixels[i + 1, j].read = true;
                }
                else
                {
                    processSprite(i + 1, j);
                }
            }
        }
        //... (code goes on)
    }

• 。pixeltemp 是保存图像的像素临时列表(List)< /code>
• imap 包含整个图像 (List)

我想这不是内存问题，因为我的应用程序只占用大约 16mb 的顶部。

我的问题是，如果不是无限递归，为什么会出现“堆栈溢出”错误？有没有更简单的方法来做到这一点？我确实认为我的代码看起来很丑，我只是不知道如何让它变得更好。

提前致谢 ！

Answer 1

堆栈溢出不是由无限递归引起的，而是由超出进程处理能力的递归（或者更确切地说，调用堆栈）引起的。在您的情况下，对 processSprite 的每次递归调用都会对 processSprite 执行相同数量的递归调用。因此，在最坏的情况下，即 1600 像素而找不到边界，您的调用树将如下所示：

  processSprite(0, j)
    processSprite(1, j)
      processSprite(2, j)
        ...
          processSprite(1599, j) <-- That's 1600 call frames,
                                     enough for an overflow.

您将需要将算法重新组织为一个执行深度优先搜索的线性循环，也许以螺旋模式，如果您想要找到最接近起点的像素。我确信其他人已经开发了其他出色的算法来解决这个问题。

编辑：

我想我现在更好地理解了您要解决的问题。听起来您的图像可能包含由 0-alpha 像素包围的多个图像图块，并且您希望找到每个图块的边界矩形。这看起来是一个需要解决的有趣问题，所以我实现了它：

IEnumerable<Rectangle> FindImageTiles(Bitmap compositeImage)
{
    var result = new List<Rectangle>();

    // Scan for a non-empty region that hasn't already been "captured"
    for (var x = 0; x < compositeImage.Width; x++)
    {
        for (var y = 0; y < compositeImage.Height; y++)
        {
            // Only process the pixel if we don't have a rectangle that
            // already contains this and if it's not empty
            if (!result.Any(r => r.Contains(x, y)) 
                && compositeImage.GetPixel(x, y).A != 0)
            {
                // Now that we've found a point, create a rectangle
                // surrounding that point, then expand outward until
                // we have a bounding rectangle that doesn't intersect
                // with the tile
                var rect = new Rectangle(x - 1, y - 1, 2, 2);
                bool foundBounds = false;
                while (!foundBounds)
                {
                    var xRange = Enumerable.Range(rect.Left, rect.Right)
                        .Where(px => px >= 0 && px < compositeImage.Width);
                    var yRange = Enumerable.Range(rect.Top, rect.Bottom)
                        .Where(py => py >= 0 && py < compositeImage.Height);

                    // Adjust the top
                    if (rect.Top >= 0 
                        && xRange
                            .Select(bx => compositeImage.GetPixel(bx, rect.Top))
                            .Any(p => p.A != 0))
                    {
                        rect.Y--;
                        rect.Height++;
                    }
                    else if (rect.Bottom < compositeImage.Height
                        && xRange
                            .Select(bx => compositeImage.GetPixel(bx, rect.Bottom))
                            .Any(p => p.A != 0))
                    {
                        rect.Height++;
                    }
                    else if (rect.Left >= 0
                        && yRange
                            .Select(by => compositeImage.GetPixel(rect.Left, by))
                            .Any(p => p.A != 0))
                    {
                        rect.X--;
                        rect.Width++;
                    }
                    else if (rect.Right < compositeImage.Width
                        && yRange
                            .Select(by => compositeImage.GetPixel(rect.Right, by))
                            .Any(p => p.A != 0))
                    {
                        rect.Width++;
                    }
                    else
                    {
                        foundBounds = true;
                    }
                }
                result.Add(rect);
            }
        }
    }

    return result;
}