Delete circles using opencv

Question

I am working on an opencv issue to find out which circles are full. However, sometimes the edge of the circles causes false positives. It amazes me if I can remove these circles by rotating all the white pixels with a high R value to RGB. My approach is to create a mask of pixels that are pinkish and then subtract the mask from the original image to remove the circles. At the moment I am getting a black mask. I'm doing something wrong. Please guide.

    rgb = cv2.imread(img, cv2.CV_LOAD_IMAGE_COLOR)
    rgb_filtered = cv2.inRange(rgb, (200, 0, 90), (255, 110, 255))
    cv2.imwrite('mask.png',rgb_filtered) 

Answer 1

Here is my solution. Unfortunately, this is also in C ++, and here's how it works:

• , , ( )
• , .
• , , . , ( , , , , , , )

• , () ( ) ( ).

  int main()
  {
  cv::Mat colorImage = cv::imread("countFilledCircles.png");
  cv::Mat image = cv::imread("countFilledCircles.png", CV_LOAD_IMAGE_GRAYSCALE);
  
  // threshold the image!
  cv::Mat thresholded;
  cv::threshold(image,thresholded,0,255,CV_THRESH_BINARY_INV | CV_THRESH_OTSU);
  
  // save threshold image for demonstration:
  cv::imwrite("countFilledCircles_threshold.png", thresholded);
  
  
  // find outer-contours in the image these should be the circles!
  cv::Mat conts = thresholded.clone();
  std::vector<std::vector<cv::Point> > contours;
  std::vector<cv::Vec4i> hierarchy;
  
  cv::findContours(conts,contours,hierarchy, CV_RETR_EXTERNAL, CV_C    HAIN_APPROX_SIMPLE, cv::Point(0,0));
  
  
  
  // colors in which marked/unmarked circle outlines will be drawn:
  cv::Scalar colorMarked(0,255,0);
  cv::Scalar colorUnMarked(0,0,255);
  
  // each outer contour is assumed to be a circle
  // TODO: you could first find the mean radius of all assumed circles and try to find outlier (dirt etc in the image)
  for(unsigned int i=0; i<contours.size(); ++i)
  {
          cv::Point2f center;
          float radius;
          // find minimum circle enclosing the contour
          cv::minEnclosingCircle(contours[i],center,radius);
  
          bool marked = false;
  
      cv::Rect circleROI(center.x-radius, center.y-radius, center.x+radius, center.y+radius);
      //circleROI = circleROI & cv::Rect(0,0,image.cols, image.rows);
  
      // count pixel inside the circle
      float sumCirclePixel = 0;
      float sumCirclePixelMarked = 0;
      for(int j=circleROI.y; j<circleROI.y+circleROI.height; ++j)
          for(int i=circleROI.x; i<circleROI.x+circleROI.width; ++i)
          {
              cv::Point2f current(i,j);
              // test if pixel really inside the circle:
          if(cv::norm(current-center) < radius)
              {
                  // count total number of pixel in the circle
                  sumCirclePixel = sumCirclePixel+1.0f;
                  // and count all pixel in the circle which hold the segmentation threshold
                  if(thresholded.at<unsigned char>(j,i))
                      sumCirclePixelMarked = sumCirclePixelMarked + 1.0f;
              }
          }
  
      const float ratioThreshold = 0.5f;
      if(sumCirclePixel)
          if(sumCirclePixelMarked/sumCirclePixel > ratioThreshold) marked = true;
  
      // draw the circle for demonstration
      if(marked)
          cv::circle(colorImage,center,radius,colorMarked,1);
      else
          cv::circle(colorImage,center,radius,colorUnMarked,1);
      }
  
  
  cv::imshow("thres", thresholded);
  cv::imshow("colorImage", colorImage);
  cv::imwrite("countFilledCircles_output.png", colorImage);
  
  cv::waitKey(-1);
  }
  

:

otsu:

:

Answer 2

Python. :

• .
• Otsu.
• , , .
• .

. 0.7, .

import cv2
import numpy

# Read image and apply gaussian blur

img = cv2.imread("circles.png", cv2.CV_LOAD_IMAGE_GRAYSCALE)
img = cv2.GaussianBlur(img, (5, 5), 0)

# Apply OTSU thresholding and reverse it so the circles are in the foreground (white)

_, otsu = cv2.threshold(img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
otsu = cv2.bitwise_not(otsu).astype("uint8")

# Find contours that have no parent

contours, hierarchy = cv2.findContours(numpy.copy(otsu), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
parent_contours = [contours[idx] for idx, val in enumerate(hierarchy[0]) if val[3] == -1]

# Loop through all contours to check the ratio of white to black pixels inside each one

filled_circles_contours = list()

for contour in parent_contours:

    contour_mask = numpy.zeros(img.shape).astype("uint8")
    cv2.drawContours(contour_mask, [contour], -1, 1, thickness=-1)
    white_len_mask = len(cv2.findNonZero(contour_mask))
    white_len_thresholded = len(cv2.findNonZero(contour_mask * otsu))
    white_ratio = float(white_len_thresholded) / white_len_mask

    if white_ratio > 0.7:
        filled_circles_contours.append(contour)

# Show image with detected circles

cv2.drawContours(img, filled_circles_contours, -1, (0, 0, 0), thickness=2)
cv2.namedWindow("Result")
cv2.imshow("Result", img)
cv2.waitKey(0)

, :

Answer 3

:

• , gaussian blur .
• otsu, ,
• Hough, , , . , .
• ROI - .

:

When we draw our result on the original image:

Here is a sample code (sorry in C ++):

void findFilledCircles( Mat& img ){
    Mat gray;
    cvtColor( img, gray, CV_BGR2GRAY );

    /* Apply some blurring to remove some noises */
    GaussianBlur( gray, gray, Size(5, 5), 1, 1);

    /* Otsu thresholding maximizes inter class variance, pretty good in separating background from foreground */
    threshold( gray, gray, 0.0, 255.0, CV_THRESH_OTSU );
    erode( gray, gray, Mat(), Point(-1, -1), 1 );

    /* Sadly, this is tuning heavy, adjust the params for Hough Circles */
    double dp       = 1.0;
    double min_dist = 15.0;
    double param1   = 40.0;
    double param2   = 10.0;
    int min_radius  = 15;
    int max_radius  = 22;

    /* Use hough circles to find the circles, maybe we could use watershed for segmentation instead(?) */
    vector<Vec3f> found_circles;
    HoughCircles( gray, found_circles, CV_HOUGH_GRADIENT, dp, min_dist, param1, param2, min_radius, max_radius );

    /* This is just to draw coloured circles on the 'originally' gray image */
    vector<Mat> out = { gray, gray, gray };
    Mat output;
    merge( out, output );

    float diameter  = max_radius * 2;
    float area      = diameter * diameter;

    Mat roi( max_radius, max_radius, CV_8UC3, Scalar(255, 255, 255) );
    for( Vec3f circ: found_circles ) {
    /* Basically we extract the region of the circles, and count the ratio of black pixels (0) and white pixels (255) */
        Mat( gray, Rect( circ[0] - max_radius, circ[1] - max_radius, diameter, diameter ) ).copyTo( roi );
        float filled_percentage = 1.0 - 1.0 * countNonZero( roi ) / area;

        /* If more than half is filled, then maybe it filled */
        if( filled_percentage > 0.5 )
            circle( output, Point2f( circ[0], circ[1] ), max_radius, Scalar( 0, 0, 255), 3 );
        else
            circle( output, Point2f( circ[0], circ[1] ), max_radius, Scalar( 255, 255, 0), 3 );
    }


    namedWindow("");
    moveWindow("", 0, 0);
    imshow("", output );
    waitKey();
}