Detecting objects in OpenCV

edit

1. You should adjust your grabbing chain because you have some error, maybe interlaced/progressive or noise, or something else.
2. HoughCircle doesn't works because your binary image doesn't contains circles
3. HoughCircle is better with gray images because it can follow a circumference using gradient of its edge. You could try houghCircle using Green channel from RGB (red is dark in green channel). Remember that Hough could be too slow in a real-time system.
4. With threshold you cut the image upper than a value. You loose gradients, edges and shapes. After a threshold, output shape can be completely different from input shape.
5. If you are looking for red in HSV you should remember that there are 2 ranges for Red [0..yellow] OR [magenta..180]! Using both ranges your binary will be more complete.

Instead of searching for a circle you could search for a blob with area within a given range. If threshold is well done largest blob should be the ball! You could enforce the filter using circularity too. Below is the code to catch this result:

There are trackbars for understand and tune the parameters. Good luck with your robot!

#include "stdafx.h"
#include "Utility.hpp"
#pragma once

const char * winName = "Param";
int minH, minS, minV;
int maxH, maxS, maxV;
int minDiameterPerc, maxDiameterPerc; //relative to img.cols
int minCircularityPerc; // circularity: 0..100%;
cv::Mat src, src_hsv;

bool BlobDetector(const cv::Mat &src_binary, cv::KeyPoint &theBall)
{
    CV_Assert(src_binary.type() == CV_8UC1);
    cv::Mat dst;
    src.copyTo(dst);
    cv::Point ptTxt =cv::Point(10, 15);
    cv::Scalar clTxt = cv::Scalar(255, 255, 0);

    cv::SimpleBlobDetector::Params blob_params;
    // Set params for binary image 
    blob_params.filterByColor = true;
    blob_params.blobColor = 255; //blobs are white
    blob_params.minThreshold = 127;
    blob_params.thresholdStep = 1;
    blob_params.maxThreshold = blob_params.minThreshold + blob_params.thresholdStep;
    blob_params.minRepeatability = 1;
    // other parameters
    blob_params.filterByInertia = false;
    blob_params.filterByConvexity = false;

    // get values from trackbar variables
    double minRadii = minDiameterPerc * src_binary.cols / 100.0 / 2.0;
    double maxRadii = maxDiameterPerc * src_binary.cols / 100.0 / 2.0;
    double minArea = CV_PI * pow(minRadii, 2);
    double maxArea = CV_PI * pow(maxRadii, 2);
    double minCircularity = 1.0 * minCircularityPerc / 100; // circularity: 0..1;

    // set filters as required
    blob_params.filterByCircularity = (minCircularity>0);
    if (blob_params.filterByCircularity)
    {
        blob_params.minCircularity = minCircularity;
        blob_params.maxCircularity = 1.0;
        cv::putText(dst, "Min Circularity:" + to_string(minCircularity), ptTxt,
            cv::FONT_HERSHEY_PLAIN, 1, clTxt);
        ptTxt.y += 15;
    }
    blob_params.filterByArea = ((minArea + maxArea)>0);
    if (blob_params.filterByArea)
    {
        blob_params.minArea = max(1, minArea); //pix
        blob_params.maxArea = max(1, maxArea); //pix
        cv::putText(dst, "Min Diam[px]:" + to_string(cvRound(minRadii * 2)), ptTxt,
            cv::FONT_HERSHEY_PLAIN, 1, clTxt);
        ptTxt.y += 15;
        cv::putText(dst, "Max Diam[px]:" + to_string(cvRound(maxRadii * 2)), ptTxt,
            cv::FONT_HERSHEY_PLAIN, 1, clTxt);
        ptTxt.y += 15;
    }

    //detects blobs
    cv::SimpleBlobDetector detector(blob_params);
    std::vector<cv::KeyPoint> keypoints;
    detector.detect(src_binary, keypoints);

    // draw all blobs in RED
    double maxRadius = 0;
    int radius;
    cv::Point center;
    int idx=-1;
    for (int i = 0; i < keypoints.size(); i++)
    {
        radius = cvRound(keypoints[i].size);
        center = cv::Point(cvRound(keypoints[i].pt.x), cvRound(keypoints[i].pt.y));
        cv::circle(dst, center, radius, cv ...