Proper way to determine thresholding parameters

Question

I am trying to find triangles (blue contours) and trapezoids (yellow contours) in real time. In general it's okay.
But there is some problems. First it's a false positives. Triangles become trapezoids and vice versa. And I don't know how to how to solve this problem. Second it's "noise". . I tried to check area of the figure, but the noise can be equal to the area. So it did not help so much. The noise depends on the thresholding parameters. cv::adaptiveThresholddoes not help at all. It's adds even more noise (and it so SLOW) erode and dilate cant fix it in a proper way

And here is my code.

cv::Mat detect(cv::Mat imageRGB)
{
    //RGB -> GRAY
    cv::Mat imageGray;
    cv::cvtColor(imageRGB, imageGray, CV_BGR2GRAY);
    //Bluring it
    cv::Mat image;
    cv::GaussianBlur(imageGray, image, cv::Size(5,5), 2);
    //Thresholding
    cv::threshold(image, image, 100, 255, CV_THRESH_BINARY_INV);

    //SLOW and NOISE
    //cv::adaptiveThreshold(image, image, 255.0, CV_ADAPTIVE_THRESH_GAUSSIAN_C, CV_THRESH_BINARY, 21, 0);

    //Calculating canny params.
    cv::Scalar mu;
    cv::Scalar sigma;
    cv::meanStdDev(image, mu, sigma);

    cv::Mat imageCanny;

    cv::Canny(image,
              imageCanny,
              mu.val[0] + sigma.val[0],
              mu.val[0] - sigma.val[0]);

    //Detecting conturs.
    std::vector<std::vector<cv::Point> > contours;
    std::vector<cv::Vec4i> hierarchy;
    cv::findContours(imageCanny, contours, hierarchy,CV_RETR_TREE, CV_CHAIN_APPROX_NONE);

    //Hierarchy is not needed here so clear it.
    hierarchy.clear();

    for (std::size_t i = 0; i < contours.size(); i++)
    {
        //fitEllipse need at last 5 points.
        if (contours.at(i).size() < 5)
        {
            continue;
        }
        //Skip small contours.
        if (std::fabs(cv::contourArea(contours.at(i))) < 800.0)
        {
            continue;
        }
        //Calculating RotatedRect from contours NOT from hull
        //because fitEllipse need at last 5 points.

        cv::RotatedRect bEllipse = cv::fitEllipse(contours.at(i));

        //Finds the convex hull of a point set.
        std::vector<cv::Point> hull;
        cv::convexHull(contours.at(i), hull, true);
        //Approx it, so we'll get 3 point for triangles
        //and 4 points for trapez.
        cv::approxPolyDP(hull, hull, 15, true);
        //Is our contour convex. It's mast be.
        if (!cv::isContourConvex(hull))
        {
            continue;
        }
        //Triangle
        if (hull.size() == 3)
        {
            cv::drawContours(imageRGB, contours, i, cv::Scalar(255, 0, 0), 2);
            cv::circle(imageRGB, bEllipse.center, 3, cv::Scalar(0, 255, 0), 2);
        }
        //trapez
        if (hull.size() == 4)
        {
            cv::drawContours(imageRGB, contours, i, cv::Scalar(0, 255, 255), 2);
            cv::circle(imageRGB, bEllipse.center, 3, cv::Scalar(0, 0, 255), 2);
        }
    }
    return imageRGB;
}

So... In general all problems coused by wrong thresholding parameters, how can I calculete it in a proper way (automatically, of course)? And how can I can (lol, sorry for my english) prevent false positives?

Answer 1

Thesholding - i think that you should try Otsu binarization - here is some theory and a nice picture and here is documentation. This kind of thresholding generally is trying to find 2 most common values in image and use average value of them as a threshold value.

Alternatively consider using HSV color space, it might be easier to distinguish black and white regions from other regions. Another idea is to use inRange function (in RGB or in HSV color space - should work in woth situations) - you need to find 2 ranges (one from black regions and one for white) and search only for those regions (using inRange function) - look at this post.

Another way to accomplish this task might be using some library for blob extraction like this one or blob extractor which is part of OpenCV.

Distinguish triangle from trapezoid - i see 2 basic ways to improve you solution here:

• in this line cv::approxPolyDP(hull, hull, 15, true); make third parameter (15 in this situation) not a constant value, but some part of contour area or length. Definitely it should adapt to contour size, it can't be just a canstant value. It's hard to say how to calculate it without some testing - try to start with 1-5% of contour area or length (i would start with length, but this is just my guess) and see whether this value is fine/to big/to small an check other values if needed. Unfortunetely there is no other way, but finding this equation manually shouldn't take very long time.
• when you have 4 or 5 points calculate the equations of lines which join consecutive points (point 1 with point 2, point 2 with point 3, etc don't forget to calculate line between first point and last point), than check whether any 2 of those lines are parallel (or at least are close to being parallel - angle between them is close to 0 degress) - if you find any parallel lines than this contour is trapezoid, otherwise it's a triangle.