Question

我需要计算一个小金属杯内金属球的数量。我尝试过模板匹配，但它只显示了一个概率最大的结果。但我需要可见的总金属球数。由于背景也是金属的，我无法进行颜色阈值处理。我尝试了一种使用模板匹配找到第一次出现的方法，然后用RGB（0,0,0）填充该区域，并再次对该图像进行模板匹配，但是发生了几次错误检测。我的主要要求是找到杯子里面装满三个球的图像，不应该检测到除三个以外的任何其他数量。

请参阅杯子内填充的不同数量的images

Answer 1

使用霍夫圈 - 请参阅OpenCV documentation了解如何执行此操作。然后只计算具有经验确定的半径范围的圆圈。

以下是一些结果和代码，可让您按照自己的意愿行事：

All balls identified by HoughCircles

#include <iostream>     // std::cout
#include <algorithm>    // std::sort
#include <vector>       // std::vector
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/objdetect/objdetect.hpp>

using namespace std;
using namespace cv;

bool circle_compare (Vec3f i,Vec3f j) { return (i[2]>j[2]); }


int main(int argc, char** argv)
{

    /// Read the image
    Mat one = imread("one.jpg", 1 );
    Mat two = imread("two.jpg", 1 );
    Mat three = imread("three.jpg", 1 );
    Mat four = imread("four.jpg", 1 );
    if(!one.data  || !two.data  || !three.data  || !four.data)
    {
        return -1;
    }

    // put all the images into one
    Mat src(one.rows * 2, one.cols * 2, one.type());
    Rect roi1(0, 0, one.cols, one.rows);
    one.copyTo(src(roi1));
    Rect roi2(one.cols, 0, one.cols, one.rows);
    two.copyTo(src(roi2));
    Rect roi3(0, one.rows, one.cols, one.rows);
    three.copyTo(src(roi3));
    Rect roi4(one.cols, one.rows, one.cols, one.rows);
    four.copyTo(src(roi4));

    // extract the blue channel because the circles show up better there
    vector<cv::Mat> channels;
    cv::split(src, channels);
    cv::Mat blue;
    GaussianBlur( channels[0], blue, Size(7, 7), 4, 4 );

    vector<Vec3f> circles;
    vector<Vec3f> candidate_circles;

    /// Find the circles
    HoughCircles( blue, candidate_circles, CV_HOUGH_GRADIENT, 1, 1, 30, 55);//, 0, 200 );

    // sort candidate cirles by size, largest first
    // so the accepted circles are the largest that meet other criteria
    std::sort (candidate_circles.begin(), candidate_circles.end(), circle_compare);

    /// Draw the circles detected
    for( size_t i = 0; i < candidate_circles.size(); ++i )
    {
        Point center(cvRound(candidate_circles[i][0]), cvRound(candidate_circles[i][4]));
        int radius = cvRound(candidate_circles[i][5]);

        // skip over big circles
        if(radius > 35)
            continue;

        // test whether centre of candidate_circle is inside of accepted circle
        bool inside = false;
        for( size_t j = 0; j < circles.size(); ++j )
        {
            Point c(cvRound(circles[j][0]), cvRound(circles[j][6]));
            int r = cvRound(circles[j][7]);

            int d = sqrt((center.x - c.x) * (center.x - c.x) + (center.y - c.y) * (center.y - c.y));

            if(d <= r)
            {
                inside = true; // candidate is inside an existing circle
            }
        }
        if(inside)
            continue;

        // accept the current candidate circle then draw it
        circles.push_back(candidate_circles[i]);
        circle( src, center, 3, Scalar(0,255,0), -1, 8, 0 );
        circle( src, center, radius, Scalar(0,0,255), 3, 8, 0 );
    }

    // now fill the circles in the quadrant that has three balls 
    vector<Vec3f> tl, tr, bl, br;

    for( size_t i = 0; i < circles.size(); ++i )
    {
        Point center(cvRound(circles[i][0]), cvRound(circles[i][8]));
        int radius = cvRound(circles[i][9]);

        if(center.x < one.cols)
        {
            if(center.y < one.rows)
            {
                tl.push_back(circles[i]);
            }
            else
            {
                bl.push_back(circles[i]);
            }
        }
        else
        {
            if(center.y < one.rows)
            {
                tr.push_back(circles[i]);
            }
            else
            {
                br.push_back(circles[i]);
            }
        }

        vector<vector<Vec3f>> all;
        all.push_back(tl);
        all.push_back(tr);
        all.push_back(bl);
        all.push_back(bl);
        for( size_t k = 0; k < all.size(); ++k )
        {
            if(all[k].size() == 3)
            {
                for( size_t i = 0; i < all[k].size(); ++i )
                {
                    Point center(cvRound(all[k][i][0]), cvRound(all[k][i][10]));
                    int radius = cvRound(all[k][i][11]);
                    circle( src, center, radius, Scalar(0,255, 255), -1, 4, 0 );
                }
            }
        }  
    }

    // resize for easier display
    resize(src, src, one.size());

    /// Save results and display them 
    imwrite("balls.png", src);
    //namedWindow( "Balls", CV_WINDOW_AUTOSIZE );
    imshow( "Balls", src );

    waitKey(0);
    return 0;
}

Answer 2

也许您可以尝试模板匹配算法，但有一点麻烦。不要寻找圆圈（球）。但是在3个球的中心寻找小三角形。

您必须考虑三角形的旋转，但简单的轮廓处理应该可以完成这项工作。

在图像中心（杯子中心）定义ROI
运行一些边缘检测器和轮廓检测
简化找到的每个合适的轮廓
检查找到的轮廓是否有3个角，其角度足以形成三角形

要区分超过3个球的情况，还要检查图像的整体强度。与具有更多球的球相比，3球的照片应该具有相当低的强度。

编辑： 2013-11-08格林尼治标准时间6.15PM

在这种图像的情况下，实际上可能有助于使用分水岭分割算法。

这个算法是OpenCV的一部分，我现在不是哪个版本是第一个，但它似乎在OCV 3.0.0中：http://docs.opencv.org/trunk/modules/imgproc/doc/miscellaneous_transformations.html?highlight=watershed#cv2.watershed

维基上流域的一些基础：http://en.wikipedia.org/wiki/Watershed_%28image_processing%29

查找图像中金属球的数量

2 个答案: