Détecter les cercles/ellipses se chevauchant/se chevauchant avec OpenCV et Python

Question

je veux mesurer la circularité des cercles (différence entre les paramètres "cercles" de hauteur et de largeur ou les paramètres de l'ellipse). Les cercles sont donnés en images comme montré ici: 

Après avoir fait des choses habituelles comme color2gray, le seuillage et la détection de bordure, je reçois l'image suivante, comme indiqué:

Avec cela, j'ai déjà essayé beaucoup de choses différentes: 

• Élément de liste Watershed avec findContour (similaire à cette question ) -> openCV détecte l’espace entre les cercles comme un contour fermé et non les cercles, car ils se collent ensemble et ne forment pas de contour fermé
• même problème avec fitEllipse. Les ellipses sont ajustées sur le contour du fond noir et non entre les deux.
• le simple fait d’appliquer une transformation complète (comme dans le code et la troisième image montrée) conduit également à des résultats étranges: 

Voir le code ici:

import sys
import cv2
import numpy
from scipy.ndimage import label

# Application entry point
#img = cv2.imread("02_adj_grey.jpg")
img = cv2.imread("fuss02.jpg")

# Pre-processing.
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)    
cv2.imwrite("SO_0_gray.png", img_gray)

#_, img_bin = cv2.threshold(img_gray, 0, 255, cv2.THRESH_OTSU | cv2.THRESH_BINARY)
_, img_bin = cv2.threshold(img_gray, 170, 255, cv2.THRESH_BINARY)
cv2.imwrite("SO_1_threshold.png", img_bin)

#blur = cv2.GaussianBlur(img,(5,5),0)
img_bin = cv2.morphologyEx(img_bin, cv2.MORPH_CLOSE, numpy.ones((3, 3), dtype=int))
cv2.imwrite("SO_2_img_bin_morphoEx.png", img_bin)

border = img_bin - cv2.erode(img_bin, None)
cv2.imwrite("SO_3_border.png", border)


circles = cv2.HoughCircles(border,cv2.cv.CV_HOUGH_GRADIENT,50,80, param1=80,param2=40,minRadius=10,maxRadius=150)
print circles

cimg = img
for i in circles[0,:]:
# draw the outer circle
    cv2.circle(cimg,(i[0],i[1]),i[2],(0,255,0),2)
    # draw the center of the circle
    cv2.circle(cimg,(i[0],i[1]),2,(0,0,255),3)
    cv2.putText(cimg,str(i[0])+str(',')+str(i[1]), (i[0],i[1]), cv2.FONT_HERSHEY_SIMPLEX, 0.4, 255)

cv2.imwrite("SO_8_cimg.png", cimg)

Quelqu'un a-t-il une idée pour améliorer mon algorithme ou une approche complètement différente? J'ai essayé beaucoup d'approches différentes mais sans succès jusqu'à présent. Merci à tous pour votre aide.

Answer 1

Voici ma tentative de détecter les cercles. En résumé

• effectuer une conversion BGR-> HSV et utiliser le canal V pour le traitement

Canal V:

• seuil, appliquez la fermeture morphologique, puis prenez la transformation de distance (je l'appellerai dist )

dist image:

• créer un modèle. D'après la taille des cercles dans l'image, un disque d'environ 75 pixels semble raisonnable. Prenez sa transformation de distance et utilisez-la comme modèle (je l'appellerai temp ) 

temp image:

• effectuer une correspondance de modèle: dist * temp

dist * temp image:

• trouver les maxima locaux de l'image résultante. L'emplacement des maxima correspond aux centres des cercles et les valeurs maximales correspondent à leurs rayons

Modèle de seuillage correspondant à l'image:

Détecter les cercles comme maxima locaux:

Je l'ai fait en C++, car cela me convient le mieux. Je pense que vous pouvez facilement convertir ceci en python si vous trouvez cela utile. Notez que les images ci-dessus ne sont pas à l'échelle. J'espère que cela t'aides.

EDIT: Ajout de la version Python

C++:

    double min, max;
    Point maxLoc;

    Mat im = imread("04Bxy.jpg");
    Mat hsv;
    Mat channels[3];
    // bgr -> hsv
    cvtColor(im, hsv, CV_BGR2HSV);
    split(hsv, channels);
    // use v channel for processing
    Mat& ch = channels[2];
    // apply Otsu thresholding
    Mat bw;
    threshold(ch, bw, 0, 255, CV_THRESH_BINARY | CV_THRESH_OTSU);
    // close small gaps
    Mat kernel = getStructuringElement(MORPH_ELLIPSE, Size(3, 3));
    Mat morph;
    morphologyEx(bw, morph, CV_MOP_CLOSE, kernel);
    // take distance transform
    Mat dist;
    distanceTransform(morph, dist, CV_DIST_L2, CV_DIST_MASK_PRECISE);
    // add a black border to distance transformed image. we are going to do
    // template matching. to get a good match for circles in the margin, we are adding a border
    int borderSize = 75;
    Mat distborder(dist.rows + 2*borderSize, dist.cols + 2*borderSize, dist.depth());
    copyMakeBorder(dist, distborder, 
            borderSize, borderSize, borderSize, borderSize, 
            BORDER_CONSTANT | BORDER_ISOLATED, Scalar(0, 0, 0));
    // create a template. from the sizes of the circles in the image, 
    // a ~75 radius disk looks reasonable, so the borderSize was selected as 75
    Mat distTempl;
    Mat kernel2 = getStructuringElement(MORPH_ELLIPSE, Size(2*borderSize+1, 2*borderSize+1));
    // erode the ~75 radius disk a bit
    erode(kernel2, kernel2, kernel, Point(-1, -1), 10);
    // take its distance transform. this is the template
    distanceTransform(kernel2, distTempl, CV_DIST_L2, CV_DIST_MASK_PRECISE);
    // match template
    Mat nxcor;
    matchTemplate(distborder, distTempl, nxcor, CV_TM_CCOEFF_NORMED);
    minMaxLoc(nxcor, &min, &max);
    // threshold the resulting image. we should be able to get peak regions.
    // we'll locate the peak of each of these peak regions
    Mat peaks, peaks8u;
    threshold(nxcor, peaks, max*.5, 255, CV_THRESH_BINARY);
    convertScaleAbs(peaks, peaks8u);
    // find connected components. we'll use each component as a mask for distance transformed image,
    // then extract the peak location and its strength. strength corresponds to the radius of the circle
    vector<vector<Point>> contours;
    vector<Vec4i> hierarchy;
    findContours(peaks8u, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE, Point(0, 0));
    for(int idx = 0; idx >= 0; idx = hierarchy[idx][0])
    {
        // prepare the mask
        peaks8u.setTo(Scalar(0, 0, 0));
        drawContours(peaks8u, contours, idx, Scalar(255, 255, 255), -1);
        // find the max value and its location in distance transformed image using mask
        minMaxLoc(dist, NULL, &max, NULL, &maxLoc, peaks8u);
        // draw the circles
        circle(im, maxLoc, (int)max, Scalar(0, 0, 255), 2);
    }

Python:

import cv2

im = cv2.imread('04Bxy.jpg')
hsv = cv2.cvtColor(im, cv2.COLOR_BGR2HSV)
th, bw = cv2.threshold(hsv[:, :, 2], 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
morph = cv2.morphologyEx(bw, cv2.MORPH_CLOSE, kernel)
dist = cv2.distanceTransform(morph, cv2.cv.CV_DIST_L2, cv2.cv.CV_DIST_MASK_PRECISE)
borderSize = 75
distborder = cv2.copyMakeBorder(dist, borderSize, borderSize, borderSize, borderSize, 
                                cv2.BORDER_CONSTANT | cv2.BORDER_ISOLATED, 0)
gap = 10                                
kernel2 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2*(borderSize-gap)+1, 2*(borderSize-gap)+1))
kernel2 = cv2.copyMakeBorder(kernel2, gap, gap, gap, gap, 
                                cv2.BORDER_CONSTANT | cv2.BORDER_ISOLATED, 0)
distTempl = cv2.distanceTransform(kernel2, cv2.cv.CV_DIST_L2, cv2.cv.CV_DIST_MASK_PRECISE)
nxcor = cv2.matchTemplate(distborder, distTempl, cv2.TM_CCOEFF_NORMED)
mn, mx, _, _ = cv2.minMaxLoc(nxcor)
th, peaks = cv2.threshold(nxcor, mx*0.5, 255, cv2.THRESH_BINARY)
peaks8u = cv2.convertScaleAbs(peaks)
contours, hierarchy = cv2.findContours(peaks8u, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
peaks8u = cv2.convertScaleAbs(peaks)    # to use as mask
for i in range(len(contours)):
    x, y, w, h = cv2.boundingRect(contours[i])
    _, mx, _, mxloc = cv2.minMaxLoc(dist[y:y+h, x:x+w], peaks8u[y:y+h, x:x+w])
    cv2.circle(im, (int(mxloc[0]+x), int(mxloc[1]+y)), int(mx), (255, 0, 0), 2)
    cv2.rectangle(im, (x, y), (x+w, y+h), (0, 255, 255), 2)
    cv2.drawContours(im, contours, i, (0, 0, 255), 2)

cv2.imshow('circles', im)

Answer 2

J'ai eu quelques erreurs avec votre code @dhanuskha. Je suppose que c'est parce que j'utilise une version différente de CV. Ce code fonctionne avec CV 3.0 au cas où vous en auriez besoin.

import cv2

im = cv2.imread('input.png')
hsv = cv2.cvtColor(im, cv2.COLOR_BGR2HSV)
th, bw = cv2.threshold(hsv[:, :, 2], 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
morph = cv2.morphologyEx(bw, cv2.MORPH_CLOSE, kernel)
dist = cv2.distanceTransform(morph, cv2.DIST_L2, cv2.DIST_MASK_PRECISE)
borderSize = 75
distborder = cv2.copyMakeBorder(dist, borderSize, borderSize, borderSize, borderSize, 
                                cv2.BORDER_CONSTANT | cv2.BORDER_ISOLATED, 0)
gap = 10                                
kernel2 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2*(borderSize-gap)+1, 2*(borderSize-gap)+1))
kernel2 = cv2.copyMakeBorder(kernel2, gap, gap, gap, gap, 
                                cv2.BORDER_CONSTANT | cv2.BORDER_ISOLATED, 0)
distTempl = cv2.distanceTransform(kernel2, cv2.DIST_L2, cv2.DIST_MASK_PRECISE)
nxcor = cv2.matchTemplate(distborder, distTempl, cv2.TM_CCOEFF_NORMED)
mn, mx, _, _ = cv2.minMaxLoc(nxcor)
th, peaks = cv2.threshold(nxcor, mx*0.5, 255, cv2.THRESH_BINARY)
peaks8u = cv2.convertScaleAbs(peaks)
_, contours, hierarchy = cv2.findContours(peaks8u, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
peaks8u = cv2.convertScaleAbs(peaks)    # to use as mask
for i in range(len(contours)):
    x, y, w, h = cv2.boundingRect(contours[i])
    _, mx, _, mxloc = cv2.minMaxLoc(dist[y:y+h, x:x+w], peaks8u[y:y+h, x:x+w])
    cv2.circle(im, (int(mxloc[0]+x), int(mxloc[1]+y)), int(mx), (255, 0, 0), 2)
    cv2.rectangle(im, (x, y), (x+w, y+h), (0, 255, 255), 2)
    cv2.drawContours(im, contours, i, (0, 0, 255), 2)

cv2.imshow('circles', im)
cv2.waitKey(0)