如何定义重叠的矩形？

Question

我有一个带有边框的图像，如下所示：

我想合并重叠的边界框。

我尝试过：cv::groupRectangles(detected, 1, 0.8)

我的期望是每个群集都有一个盒子。

但是我明白了：

如您所见，问题是，在中间的飞镖和右边的飞镖没有框。

我该如何解决？我最好使用OpenCV api，而不是编写自己的合并算法。

我看到它消除了仅由一个框界定的区域。我希望它不这样做。

我尝试随机调整参数，但结果却差得多。我希望朝着正确的方向提供一些指导。

Answer 1

如何定义重叠的矩形？

我们需要一种方法来定义两个矩形何时重叠。我们可以使用|交集运算符来细化两个矩形的交集，并检查它是否不为空：

bool overlap(const cv::Rect& lhs, const cv::Rect& rhs) {
    return (lhs & rhs).area() > 0;
}

如果要忽略小的交叉路口，可以在交叉路口区域使用阈值：

bool overlap(const cv::Rect& lhs, const cv::Rect& rhs, int th) {
    return (lhs & rhs).area() > th;
}

但是现在阈值取决于矩形的尺寸。我们可以使用范围为[0，1]的"Intersection over Union"度量标准（IoU），并在该间隔内应用阈值。

bool overlap(const cv::Rect& lhs, const cv::Rect& rhs, double th) {
    double i = static_cast<double>((lhs & rhs).area());
    double u = static_cast<double>((lhs | rhs).area());
    double iou = i / u;
    return iou > th;
}

通常来说效果很好，但是如果两个矩形的大小不同，可能会显示意外结果。另一种方法可能是检查第一个矩形的大部分区域是否与第二个矩形相交，反之亦然：

bool overlap(const cv::Rect& lhs, const cv::Rect& rhs, double th) {
    double i = static_cast<double>((lhs & rhs).area());
    double ratio_intersection_over_lhs_area = i / static_cast<double>(lhs.area());
    double ratio_intersection_over_rhs_area = i / static_cast<double>(rhs.area());
    return (ratio_intersection_over_lhs_area > th) || (ratio_intersection_over_rhs_area > th);        
}

好，现在我们有几种方法来定义两个矩形何时重叠。选择一个。

如何查找重叠的矩形？

我们可以用谓词将cv::partition的矩形聚类，从而将重叠的矩形放在同一聚类中。即使两个彼此不直接重叠但由一个或多个重叠矩形链接的矩形，也将放置在同一群集中。此函数的输出是簇的向量，其中每个簇都包含一个矩形向量：

std::vector<std::vector<cv::Rect>> cluster_rects(const std::vector<cv::Rect>& rects, const double th)
{
    std::vector<int> labels;
    int n_labels = cv::partition(rects, labels, [th](const cv::Rect& lhs, const cv::Rect& rhs) {
        double i = static_cast<double>((lhs & rhs).area());
        double ratio_intersection_over_lhs_area = i / static_cast<double>(lhs.area());
        double ratio_intersection_over_rhs_area = i / static_cast<double>(rhs.area());
        return (ratio_intersection_over_lhs_area > th) || (ratio_intersection_over_rhs_area > th);
    });

    std::vector<std::vector<cv::Rect>> clusters(n_labels);
    for (size_t i = 0; i < rects.size(); ++i) {
        clusters[labels[i]].push_back(rects[i]);
    }

    return clusters;
}

例如，从该图像的矩形中：

我们获得了这些簇（阈值为0.2）。请注意：

在左上方的群集中，三个矩形不重叠
右上角的矩形位于其自己的簇上，因为它与其他矩形的相交不够。

如何找到一个代表簇的矩形？

嗯，这确实取决于应用程序。它可以是所有矩形的并集：

cv::Rect union_of_rects(const std::vector<cv::Rect>& cluster)
{
    cv::Rect one;
    if (!cluster.empty())
    {
        one = cluster[0];
        for (const auto& r : cluster) { one |= r; }
    }
    return one;
}

也可以是最大内接矩形（下面的代码）：

或其他。例如，如果您有与每个矩形相关的得分（例如，这是一个充满信心的检测结果），则可以按分数对每个聚类进行排序，并且仅获取第一个。这是一个非最大抑制（NMA）的示例，您只为每个群集保留最高得分的矩形（此答案中未显示）。

选择一个。

下面是我用来创建这些图像的工作代码。请玩：）

#include <opencv2/opencv.hpp>

std::vector<cv::Rect> create_some_rects()
{
    std::vector<cv::Rect> rects
    {
    {20, 20, 20, 40},
    {30, 40, 40, 40},
    {50, 46, 30, 40},
    {100, 120, 30, 40},
    {110, 130, 36, 20},
    {104, 124, 50, 30},
    {200, 80, 40, 50},
    {220, 90, 50, 30},
    {240, 84, 30, 70},
    {260, 60, 20, 30},
    };
    return rects;
}

void draw_rects(cv::Mat3b& img, const std::vector<cv::Rect>& rects)
{
    for (const auto& r : rects) {
        cv::Scalar random_color(rand() & 255, rand() & 255, rand() & 255);
        cv::rectangle(img, r, random_color);
    }
}

void draw_rects(cv::Mat3b& img, const std::vector<cv::Rect>& rects, const cv::Scalar& color)
{
    for (const auto& r : rects) {
        cv::rectangle(img, r, color);
    }
}

void draw_clusters(cv::Mat3b& img, const std::vector<std::vector<cv::Rect>>& clusters)
{
    for (const auto& cluster : clusters) {
        cv::Scalar random_color(rand() & 255, rand() & 255, rand() & 255);
        draw_rects(img, cluster, random_color);
    }
}

std::vector<std::vector<cv::Rect>> cluster_rects(const std::vector<cv::Rect>& rects, const double th)
{
    std::vector<int> labels;
    int n_labels = cv::partition(rects, labels, [th](const cv::Rect& lhs, const cv::Rect& rhs) {
        double i = static_cast<double>((lhs & rhs).area());
        double ratio_intersection_over_lhs_area = i / static_cast<double>(lhs.area());
        double ratio_intersection_over_rhs_area = i / static_cast<double>(rhs.area());
        return (ratio_intersection_over_lhs_area > th) || (ratio_intersection_over_rhs_area > th);
    });

    std::vector<std::vector<cv::Rect>> clusters(n_labels);
    for (size_t i = 0; i < rects.size(); ++i) {
        clusters[labels[i]].push_back(rects[i]);
    }

    return clusters;
}

cv::Rect union_of_rects(const std::vector<cv::Rect>& cluster)
{
    cv::Rect one;
    if (!cluster.empty())
    {
        one = cluster[0];
        for (const auto& r : cluster) { one |= r; }
    }
    return one;
}


// https://stackoverflow.com/a/30418912/5008845
// https://stackoverflow.com/a/34905215/5008845
cv::Rect findMaxRect(const cv::Mat1b& src)
{
    cv::Mat1f W(src.rows, src.cols, float(0));
    cv::Mat1f H(src.rows, src.cols, float(0));

    cv::Rect maxRect(0, 0, 0, 0);
    float maxArea = 0.f;

    for (int r = 0; r < src.rows; ++r)
    {
        for (int c = 0; c < src.cols; ++c)
        {
            if (src(r, c) == 0)
            {
                H(r, c) = 1.f + ((r > 0) ? H(r - 1, c) : 0);
                W(r, c) = 1.f + ((c > 0) ? W(r, c - 1) : 0);
            }

            float minw = W(r, c);
            for (int h = 0; h < H(r, c); ++h)
            {
                minw = std::min(minw, W(r - h, c));
                float area = (h + 1) * minw;
                if (area > maxArea)
                {
                    maxArea = area;
                    maxRect = cv::Rect(cv::Point(c - minw + 1, r - h), cv::Point(c + 1, r + 1));
                }
            }
        }
    }
    return maxRect;
}

cv::Rect largest_inscribed_of_rects(const std::vector<cv::Rect>& cluster)
{
    cv::Rect roi = union_of_rects(cluster);

    cv::Mat1b mask(roi.height, roi.width, uchar(255));
    for (const auto& r : cluster) {
        cv::rectangle(mask, r - roi.tl(), cv::Scalar(0), cv::FILLED);
    }

    cv::Rect largest_rect = findMaxRect(mask);
    largest_rect += roi.tl();

    return largest_rect;
}



std::vector<cv::Rect> find_one_for_cluster(const std::vector<std::vector<cv::Rect>>& clusters)
{
    std::vector<cv::Rect> one_for_cluster;
    for (const auto& cluster : clusters) {
        //cv::Rect one = union_of_rects(cluster);
        cv::Rect one = largest_inscribed_of_rects(cluster);
        one_for_cluster.push_back(one);
    }
    return one_for_cluster;
}


int main()
{
    cv::Mat3b img(200, 300, cv::Vec3b(0, 0, 0));

    std::vector<cv::Rect> rects = create_some_rects();

    cv::Mat3b initial_rects_img = img.clone();
    draw_rects(initial_rects_img, rects, cv::Scalar(127, 127, 127));

    std::vector<std::vector<cv::Rect>> clusters = cluster_rects(rects, 0.2);

    cv::Mat3b clustered_rects_img = initial_rects_img.clone();
    draw_clusters(clustered_rects_img, clusters);

    std::vector<cv::Rect> single_rects = find_one_for_cluster(clusters);

    cv::Mat3b single_rects_img = initial_rects_img.clone();
    draw_rects(single_rects_img, single_rects);

    return 0;
}

Answer 2

很遗憾，您无法微调groupRectangles()。您的示例的第二个参数应该为0。对于1，所有奇异矩形必须都可以合并到某处。

如果要更好地聚集小矩形，可以先增大小矩形并保留一个保守的阈值参数。不过，这不是最佳解决方案。

如果要基于重叠条件进行聚类，我建议为此编写自己的简单算法。 groupRectangles()根本不这样做。它找到大小和位置相似的矩形；它不会累积形成群集的矩形。

您可以用矩形填充遮罩cv::Mat1b mask(image.size(), uchar(0));，然后使用cv::connectedComponents()查找合并的区域。请注意，填充很简单，请在所有矩形上循环并调用mask(rect).setTo(255);。如果重叠并非始终可靠，则可以在连接组件步骤之前使用cv::dilate()在遮罩中增大矩形。
您可以测试所有矩形是否重叠，并相应地关联它们。对于大量矩形，我建议使用不交集/联合查找数据结构以提高效率。

如何将边界框与groupRectangle合并？

2 个答案:

如何定义重叠的矩形？

如何查找重叠的矩形？

如何找到一个代表簇的矩形？