OpenCV每日函数 特征检测和描述模块(1) SimpleBlobDetector类(从图像中提取blobs)

        该类实现了一个从图像中提取 blob 的简单算法：

1. 通过使用从 minThreshold（包括）到 maxThreshold（不包括）的多个阈值以及相邻阈值之间的距离 thresholdStep，将源图像转换为二值图像。
2. 通过 findContours 从每个二值图像中提取连通分量并计算它们的中心。
3. 通过坐标对多个二值图像的中心进行分组。闭合中心形成一组，对应一个 blob，由 minDistBetweenBlobs 参数控制。
4. 从这些组中，估计 blob 的最终中心及其半径，并作为关键点的位置和大小返回。

        此类对返回的 blob 执行多次过滤。您应该将 filterBy* 设置为 true/false 以打开/关闭相应的过滤。可用的过滤器：

• 按颜色。此过滤器将 blob 中心的二值图像的强度与 blobColor 进行比较。如果它们不同，则会过滤掉 blob。使用 blobColor = 0 提取深色斑点，使用 blobColor = 255 提取浅色斑点。
• 按面积。提取的 blob 具有介于 minArea（包括）和 maxArea（不包括）之间的区域。
• 通过圆形过滤。提取的斑点具有圆形度（4∗π∗Areaperimeter∗perimeter) 在 minCircularity（包括）和 maxCircularity（不包括）之间。
• 通过最小惯量与最大惯量之比。提取的 blob 在 minInertiaRatio（包括）和 maxInertiaRatio（不包括）之间具有此比率。
• 通过凸性。提取的 blob 具有 minConvexity（包括）和 maxConvexity（不包括）之间的凸度（面积/blob 凸包面积）。

        调整参数的默认值以提取深色圆形斑点。

cv::SimpleBlobDetector::create	(	const SimpleBlobDetector::Params & 	parameters = SimpleBlobDetector::Params()	)	

        见下面源码

opencvmodulesfeatures2dsrcblobdetector.cpp

SimpleBlobDetector::Params::Params()
{
    thresholdStep = 10;
    minThreshold = 50;
    maxThreshold = 220;
    minRepeatability = 2;
    minDistBetweenBlobs = 10;

    filterByColor = true;
    blobColor = 0;

    filterByArea = true;
    minArea = 25;
    maxArea = 5000;

    filterByCircularity = false;
    minCircularity = 0.8f;
    maxCircularity = std::numeric_limits::max();

    filterByInertia = true;
    //minInertiaRatio = 0.6;
    minInertiaRatio = 0.1f;
    maxInertiaRatio = std::numeric_limits::max();

    filterByConvexity = true;
    //minConvexity = 0.8;
    minConvexity = 0.95f;
    maxConvexity = std::numeric_limits::max();
}

void SimpleBlobDetectorImpl::detect(InputArray image, std::vector& keypoints, InputArray mask)
{
    CV_INSTRUMENT_REGION();

    keypoints.clear();
    CV_Assert(params.minRepeatability != 0);
    Mat grayscaleImage;
    if (image.channels() == 3 || image.channels() == 4)
        cvtColor(image, grayscaleImage, COLOR_BGR2GRAY);
    else
        grayscaleImage = image.getMat();

    if (grayscaleImage.type() != CV_8UC1) {
        CV_Error(Error::StsUnsupportedFormat, "Blob detector only supports 8-bit images!");
    }

    std::vector < std::vector > centers;
    for (double thresh = params.minThreshold; thresh < params.maxThreshold; thresh += params.thresholdStep)
    {
        Mat binarizedImage;
        threshold(grayscaleImage, binarizedImage, thresh, 255, THRESH_BINARY);

        std::vector < Center > curCenters;
        findBlobs(grayscaleImage, binarizedImage, curCenters);
        if(params.maxThreshold - params.minThreshold <= params.thresholdStep) {
            // if the difference between min and max threshold is less than the threshold step
            // we're only going to enter the loop once, so we need to add curCenters
            // to ensure we still use minDistBetweenBlobs
            centers.push_back(curCenters);
        }
        std::vector < std::vector > newCenters;
        for (size_t i = 0; i < curCenters.size(); i++)
        {
            bool isNew = true;
            for (size_t j = 0; j < centers.size(); j++)
            {
                double dist = norm(centers[j][centers[j].size() / 2 ].location - curCenters[i].location);
                isNew = dist >= params.minDistBetweenBlobs && dist >= centers[j][ centers[j].size() / 2 ].radius && dist >= curCenters[i].radius;
                if (!isNew)
                {
                    centers[j].push_back(curCenters[i]);

                    size_t k = centers[j].size() - 1;
                    while( k > 0 && curCenters[i].radius < centers[j][k-1].radius )
                    {
                        centers[j][k] = centers[j][k-1];
                        k--;
                    }
                    centers[j][k] = curCenters[i];

                    break;
                }
            }
            if (isNew)
                newCenters.push_back(std::vector (1, curCenters[i]));
        }
        std::copy(newCenters.begin(), newCenters.end(), std::back_inserter(centers));
    }

    for (size_t i = 0; i < centers.size(); i++)
    {
        if (centers[i].size() < params.minRepeatability)
            continue;
        Point2d sumPoint(0, 0);
        double normalizer = 0;
        for (size_t j = 0; j < centers[i].size(); j++)
        {
            sumPoint += centers[i][j].confidence * centers[i][j].location;
            normalizer += centers[i][j].confidence;
        }
        sumPoint *= (1. / normalizer);
        KeyPoint kpt(sumPoint, (float)(centers[i][centers[i].size() / 2].radius) * 2.0f);
        keypoints.push_back(kpt);
    }

    if (!mask.empty())
    {
        KeyPointsFilter::runByPixelsMask(keypoints, mask.getMat());
    }
}

Ptr SimpleBlobDetector::create(const SimpleBlobDetector::Params& params)
{
    return makePtr(params);
}

String SimpleBlobDetector::getDefaultName() const
{
    return (Feature2D::getDefaultName() + ".SimpleBlobDetector");
}