To jest wielki problem modelowania. Mam następujące zalecenia/ pomysły:

1. Podziel obraz na RGB, a następnie przetworz.
2. obróbka wstępna.
3. dynamiczne wyszukiwanie parametrów.
4. Dodaj ograniczenia.
5. upewnij się, co próbujesz wykryć.

Bardziej szczegółowo:

1: jak zauważono w innych odpowiedziach, konwersja na skalę szarości odrzuca zbyt wiele informacji - wszelkie okręgi o podobnej jasności do tła będzie stracony. Znacznie lepiej rozważyć kanały kolorów w izolacji lub w innej przestrzeni kolorów. Można to zrobić na dwa sposoby: wykonać HoughCircles na każdym wstępnie przetworzonym kanale w izolacji, następnie połączyć wyniki lub przetworzyć kanały, następnie połączyć je, a następnie uruchomić HoughCircles. W mojej próbie poniżej wypróbowałem drugą metodę, dzielenie na kanały RGB, przetwarzanie, a następnie łączenie. Uważaj na nadmierne nasycenie obrazu podczas łączenia, używam cv.And, aby uniknąć tego problemu (w tym stage my circles to zawsze czarne pierścienie/krążki na białym tle).

2: obróbka wstępna jest dość trudna i często najlepiej się nią bawić. Skorzystałem z AdaptiveThreshold, która jest naprawdę potężną metodą splotu, która może poprawić krawędzie obrazu poprzez threst pikseli w oparciu o ich lokalną średnią (podobne procesy występują również we wczesnej ścieżce systemu wizualnego ssaków). Jest to również przydatne, ponieważ zmniejsza hałas. Użyłem dilate/erode z tylko jednym przejściem. A ja zachowałeś inne parametry. Wydaje się, że użycie Canny przed HoughCircles bardzo pomaga w znalezieniu "wypełnionych okręgów" , więc prawdopodobnie najlepiej trzymać je w środku. To wstępne przetwarzanie jest dość ciężkie i może prowadzić do fałszywych alarmów z nieco bardziej "blobby circles", ale w naszym przypadku jest to być może pożądane?

3: jak zauważyłeś parametr HoughCircles param2 (Twój parametr LOW) musi być dopasowany do każdego obrazu, aby uzyskać optymalne rozwiązanie, w rzeczywistości z docs :

Im jest mniejszy, tym więcej fałszywych okręgów można wykryć.

Trouble is the sweet spot is gonna be different for every image. Myślę, że najlepszym podejściem jest ustawienie warunku i przeszukanie różnych wartości param2, aż warunek ten zostanie spełniony. Twoje obrazy pokazują Nie nakładające się okręgi, a gdy param2 jest zbyt niska, zazwyczaj otrzymujemy mnóstwo nakładających się okręgów. Proponuję więc poszukać:

Maksimum liczba nie nakładających się i nie zawartych okręgów

Tak więc nazywamy HoughCircles o różnych wartościach param2 aż to zostanie spełnione. Robię to w moim przykładzie poniżej, po prostu zwiększając param2 aż osiągnie założenie progu. Byłoby to o wiele szybsze (i dość łatwe do zrobienia), jeśli wykonasz wyszukiwanie binarne, aby znaleźć, kiedy to zostanie spełnione, ale musisz być ostrożny z obsługą wyjątków, ponieważ opencv często rzuca błąd dla niewinnie wyglądających wartości param2 (przynajmniej na moim instalacji). Innym warunkiem, który byłby bardzo przydatne, aby dopasować się do byłaby liczba kręgów.

4: czy są jeszcze jakieś ograniczenia, które możemy dodać do modelu? Im więcej rzeczy możemy powiedzieć naszemu modelowi, tym łatwe zadanie możemy wykonać, aby wykryć okręgi. Na przykład, czy wiemy:

• liczba okręgów. - nawet górna lub dolna granica jest pomocna.
• możliwe Kolory okręgów, tła lub "nie okręgów".
• ich rozmiary.
• gdzie mogą być na obrazie.

5: niektóre plamy na twoich zdjęciach mogą być tylko luźno nazywane kręgami! Rozważ dwa "niekolistne plamy" na drugim obrazku, mój kod nie może ich znaleźć (dobrze!), ale... jeśli "photoshop" je tak, że są bardziej okrągłe, mój kod może je znaleźć... Może jeśli chcesz wykryć rzeczy, które nie są kręgami, inne podejście, takie jak {15]} może być lepsze.

Problemy

Robiąc ciężkie wstępne przetwarzanie AdaptiveThresholding i "Canny" może powodować duże zniekształcenia dla funkcji obrazu, co może prowadzić do fałszywego wykrywania okręgu lub nieprawidłowego raportowania promienia. Na przykład duży twardy dysk po przetworzeniu może pojawić się pierścień, więc HughesCircles może znaleźć pierścień wewnętrzny. Ponadto nawet docs zauważają, że:

...Zwykle funkcja dobrze wykrywa centra okręgów, jednak może nie znaleźć poprawnych promieni.

Jeśli potrzebujesz dokładniejszych promieni wykrywanie, proponuję następujące podejście (nie zaimplementowane):

Na oryginalnym obrazie, promień-ślad od zgłoszonego środka okręgu, w rozszerzającym się krzyżu (4 promienie: góra/dół/lewo/prawo) {21]} Wykonaj to osobno w każdym kanale RGB]}
• połącz te informacje dla każdego kanału dla każdego promienia w rozsądny sposób(tj. w razie potrzeby Odwróć, przesuń, skaluj itp.)
• weź średnią dla pierwszych kilku pikseli na każdym promieniu, użyj tego, aby wykryć, gdzie znaczące odchylenie na występuje ray.
• Te 4 punkty są szacunkami punktów na obwodzie.
• użyj tych czterech szacunków, aby określić dokładniejszy Promień i położenie środka (!).
Można to uogólnić za pomocą rozszerzającego się pierścienia zamiast czterech promieni.

Wyniki

Kod na końcu robi całkiem dobre dość dużo czasu, te przykłady zostały wykonane z kodu, jak pokazano:

Wykrywa wszystkie okręgi w pierwszym image:

Jak wygląda wstępnie przetworzony obraz przed nałożeniem filtra canny (bardzo widoczne są różne kolorowe okręgi):

Wykrywa wszystkie oprócz dwóch (plamy) na drugim obrazku:

Zmieniony drugi obraz (plamy są koliste, a duży owal stał się bardziej okrągły, co poprawia wykrywanie), wszystkie wykryte:

Całkiem dobrze sprawdza się w wykrywaniu ośrodków w tym obrazie Kandinsky 'ego (nie mogę znaleźć koncentrycznych pierścieni ze względu na stan graniczny).

Kod:

import cv
import numpy as np

output = cv.LoadImage('case1.jpg')
orig = cv.LoadImage('case1.jpg')

# create tmp images
rrr=cv.CreateImage((orig.width,orig.height), cv.IPL_DEPTH_8U, 1)
ggg=cv.CreateImage((orig.width,orig.height), cv.IPL_DEPTH_8U, 1)
bbb=cv.CreateImage((orig.width,orig.height), cv.IPL_DEPTH_8U, 1)
processed = cv.CreateImage((orig.width,orig.height), cv.IPL_DEPTH_8U, 1)
storage = cv.CreateMat(orig.width, 1, cv.CV_32FC3)

def channel_processing(channel):
    pass
    cv.AdaptiveThreshold(channel, channel, 255, adaptive_method=cv.CV_ADAPTIVE_THRESH_MEAN_C, thresholdType=cv.CV_THRESH_BINARY, blockSize=55, param1=7)
    #mop up the dirt
    cv.Dilate(channel, channel, None, 1)
    cv.Erode(channel, channel, None, 1)

def inter_centre_distance(x1,y1,x2,y2):
    return ((x1-x2)**2 + (y1-y2)**2)**0.5

def colliding_circles(circles):
    for index1, circle1 in enumerate(circles):
        for circle2 in circles[index1+1:]:
            x1, y1, Radius1 = circle1[0]
            x2, y2, Radius2 = circle2[0]
            #collision or containment:
            if inter_centre_distance(x1,y1,x2,y2) < Radius1 + Radius2:
                return True

def find_circles(processed, storage, LOW):
    try:
        cv.HoughCircles(processed, storage, cv.CV_HOUGH_GRADIENT, 2, 32.0, 30, LOW)#, 0, 100) great to add circle constraint sizes.
    except:
        LOW += 1
        print 'try'
        find_circles(processed, storage, LOW)
    circles = np.asarray(storage)
    print 'number of circles:', len(circles)
    if colliding_circles(circles):
        LOW += 1
        storage = find_circles(processed, storage, LOW)
    print 'c', LOW
    return storage

def draw_circles(storage, output):
    circles = np.asarray(storage)
    print len(circles), 'circles found'
    for circle in circles:
        Radius, x, y = int(circle[0][2]), int(circle[0][0]), int(circle[0][1])
        cv.Circle(output, (x, y), 1, cv.CV_RGB(0, 255, 0), -1, 8, 0)
        cv.Circle(output, (x, y), Radius, cv.CV_RGB(255, 0, 0), 3, 8, 0)

#split image into RGB components
cv.Split(orig,rrr,ggg,bbb,None)
#process each component
channel_processing(rrr)
channel_processing(ggg)
channel_processing(bbb)
#combine images using logical 'And' to avoid saturation
cv.And(rrr, ggg, rrr)
cv.And(rrr, bbb, processed)
cv.ShowImage('before canny', processed)
# cv.SaveImage('case3_processed.jpg',processed)
#use canny, as HoughCircles seems to prefer ring like circles to filled ones.
cv.Canny(processed, processed, 5, 70, 3)
#smooth to reduce noise a bit more
cv.Smooth(processed, processed, cv.CV_GAUSSIAN, 7, 7)
cv.ShowImage('processed', processed)
#find circles, with parameter search
storage = find_circles(processed, storage, 100)
draw_circles(storage, output)
# show images
cv.ShowImage("original with circles", output)
cv.SaveImage('case1.jpg',output)

cv.WaitKey(0)

Ah, tak... stare niezmienniki koloru/rozmiaru dla problemu kółek (aka transformacja Hougha jest zbyt specyficzna i mało wytrzymała)...

W przeszłości opierałem się bardziej na analizie strukturalnej i kształtowej funkcji OpenCV. Z folderu "samples" można uzyskać bardzo dobry obraz tego, co jest możliwe - szczególnie fitellipse.py i squares.py.

Dla wyjaśnienia, przedstawiam hybrydową wersję tych przykładów i na podstawie oryginalnego źródła. Wykryte kontury są w zielone i elipsy dopasowane w kolorze czerwonym.

Jeszcze nie do końca:

• etapy wstępnego przetwarzania wymagają odrobiny poprawek, aby wykryć słabsze okręgi.
• możesz przetestować kontur dalej, aby określić, czy jest to okrąg, czy nie...

import cv
import numpy as np

# grab image
orig = cv.LoadImage('circles3.jpg')

# create tmp images
grey_scale = cv.CreateImage(cv.GetSize(orig), 8, 1)
processed = cv.CreateImage(cv.GetSize(orig), 8, 1)

cv.Smooth(orig, orig, cv.CV_GAUSSIAN, 3, 3)

cv.CvtColor(orig, grey_scale, cv.CV_RGB2GRAY)

# do some processing on the grey scale image
cv.Erode(grey_scale, processed, None, 10)
cv.Dilate(processed, processed, None, 10)
cv.Canny(processed, processed, 5, 70, 3)
cv.Smooth(processed, processed, cv.CV_GAUSSIAN, 15, 15)

#storage = cv.CreateMat(orig.width, 1, cv.CV_32FC3)
storage = cv.CreateMemStorage(0)

contours = cv.FindContours(processed, storage, cv.CV_RETR_EXTERNAL)
# N.B. 'processed' image is modified by this!

#contours = cv.ApproxPoly (contours, storage, cv.CV_POLY_APPROX_DP, 3, 1) 
# If you wanted to reduce the number of points...

cv.DrawContours (orig, contours, cv.RGB(0,255,0), cv.RGB(255,0,0), 2, 3, cv.CV_AA, (0, 0)) 

def contour_iterator(contour):
  while contour:
    yield contour
    contour = contour.h_next()

for c in contour_iterator(contours):
  # Number of points must be more than or equal to 6 for cv.FitEllipse2
  if len(c) >= 6:
    # Copy the contour into an array of (x,y)s
    PointArray2D32f = cv.CreateMat(1, len(c), cv.CV_32FC2)

    for (i, (x, y)) in enumerate(c):
      PointArray2D32f[0, i] = (x, y)

    # Fits ellipse to current contour.
    (center, size, angle) = cv.FitEllipse2(PointArray2D32f)

    # Convert ellipse data from float to integer representation.
    center = (cv.Round(center[0]), cv.Round(center[1]))
    size = (cv.Round(size[0] * 0.5), cv.Round(size[1] * 0.5))

    # Draw ellipse
    cv.Ellipse(orig, center, size, angle, 0, 360, cv.RGB(255,0,0), 2,cv.CV_AA, 0)

# show images
cv.ShowImage("image - press 'q' to quit", orig)
#cv.ShowImage("post-process", processed)
cv.WaitKey(-1)

EDIT:

Po prostu aktualizacja, aby powiedzieć, że uważam, że głównym tematem wszystkich tych odpowiedzi jest to, że istnieje wiele dalszych założeń i ograniczeń, które może być stosowany do tego, co chcesz uznać za circular . Moja własna odpowiedź nie robi na to pretensji - ani w niskopoziomowym wstępnym przetwarzaniu, ani w wysokopoziomowym geometrycznym dopasowaniu. Fakt, że wiele okręgów nie jest tak naprawdę okrągłych ze względu na sposób ich rysowania lub nie-afiniczne / projekcyjne transformacje obrazu, a także inne właściwości w ich renderowaniu/przechwytywaniu ( kolor, szum, oświetlenie, grubość krawędzi) - wszystko to powoduje dowolną liczbę możliwych okręgów kandydujących w obrębie jednego obrazu.

Jak zawsze w wizji komputerowej istnieje napięcie między pragmatyzmem, zasadą i parsomonią. As I am fond mówienie ludziom, którzy uważają, że CV jest łatwe, nie jest - w rzeczywistości jest to problem AI kompletny . Najlepsze, na co często możesz liczyć poza tym, to coś, co działa przez większość czasu.

Przeglądając Twój kod, zauważyłem, co następuje:

• Konwersja w skali szarości. Rozumiem, dlaczego to robisz, ale zdaj sobie sprawę, że rzucasz tam są informacje. Jak widać na obrazach "post-proces", Twoje żółte kółka są ta sama intensywność co tło, tylko w innym kolorze.

• Wykrywanie krawędzi po usunięciu szumów (erae/dilate). To nie powinno być konieczne; Canny powinien się tym zająć.

• Sprytne wykrywanie krawędzi. Twoje" otwarte " okręgi mają dwie krawędzie, wewnętrzną i zewnętrzną krawędź. Ponieważ są dość blisko, sprytny filtr Gaussa może dodać je razem. Jeśli nie, będziesz miał dwa krawędzie blisko siebie. Czyli przed Canny, masz otwarte i wypełnione koła. Następnie masz odpowiednio 0/2 i 1 krawędź. Ponieważ Hough ponownie wywołuje Canny, w pierwszym przypadku dwie krawędzie mogą być wygładzone razem( w zależności od początkowej szerokości), dlatego algorytm Hough może traktować otwarte i wypełnione okręgi to samo.

Więc, moja pierwsza rekomendacja to zmiana mapowania skali szarości. Nie używaj intensywności, ale używaj barwy/nasycenia / wartości. Ponadto, użyj podejścia różnicowego - szukasz krawędzi. Więc Oblicz transformację HSV, wygładź kopię, a następnie weź różnicę między oryginalną i wygładzoną kopią. Dzięki temu uzyskasz dH, dS, dV wartości (lokalne wahania barwy, nasycenia, wartości) dla każdego punktu. Kwadrat i dodać, aby uzyskać jednowymiarowy obraz, ze szczytami przy wszystkich krawędziach (wewnętrzna i zewnętrzne).

Transformata Hougha używa "modelu", aby znaleźć pewne cechy NA (zazwyczaj) obrazie wykrywanym krawędziami, jak zapewne wiesz. W przypadku HoughCircles model ten jest okręgiem idealnym. Oznacza to, że prawdopodobnie nie istnieje kombinacja parametrów, które sprawią, że wykryje bardziej nieregularne i eliptyczne okręgi na zdjęciu bez zwiększania liczby fałszywych alarmów. Z drugiej strony, ze względu na podstawowy mechanizm głosowania, niezamknięty krąg doskonały lub krąg doskonały z "dent" może się konsekwentnie pojawiać. Więc w zależności od oczekiwanego wyniku Możesz lub nie chcesz użyć tej metody.

To powiedziawszy, jest kilka rzeczy, które widzę, które mogą pomóc ci w drodze z tą funkcją: {16]}

1. HoughCircles dzwoni wewnętrznie, więc chyba możesz to zostawić.
2. param1 (które wywołujesz HIGH) jest zazwyczaj inicjalizowane wokół wartości 200. Jest używany jako parametr do wewnętrznego wywołania do Canny: cv.Canny(processed, cannied, HIGH, HIGH/2). To może pomóc uruchom Canny sam w ten sposób, aby zobaczyć, jak ustawienie HIGH wpływa na obraz obrabiany przez transformację Hougha.
3. param2 (które wywołujesz LOW) jest zazwyczaj inicjowane wokół wartości 100. Jest to próg wyborczy dla akumulatorów transformatora Hougha. Ustawienie go wyżej oznacza więcej fałszywych negatywów, niższe więcej fałszywych pozytywów. Myślę, że to pierwszy raz, z którym chcesz się bawić.

Ref: http://docs.opencv.org/3.0-beta/modules/imgproc/doc/feature_detection.html#houghcircles

Aktualizacja re: wypełnione okręgi: Po znalezieniu kształtów okręgów z transformatą Hougha możesz sprawdzić, czy są wypełnione przez pobranie koloru granicy i porównanie go do jednego lub więcej punktów wewnątrz przypuszczalnego okręgu. Alternatywnie można porównać jeden lub więcej punktów wewnątrz rzekomego okręgu do danego koloru tła. Okrąg jest wypełniony, jeśli poprzednie porównanie sukces, lub w przypadku alternatywnego porównania, jeśli się nie powiedzie.

Ok patrząc na zdjęcia. Proponuję użyć **Active Contours**

• Aktywne Kontury Zaletą aktywnych konturów jest to, że prawie idealnie pasują do każdego kształtu. Czy to kwadraty lub trójkąta i w Twoim przypadku są idealnymi kandydatami.
Jeśli jesteś w stanie wyodrębnić środek okręgów, to świetnie. Aktywne kontury zawsze potrzebują punktu, od którego mogą rosnąć lub kurczyć się, aby dopasować. Nie jest konieczne, aby centra były zawsze wyrównane do centrum. Trochę przesunięcia nadal będzie ok.
• i w Twoim przypadku, jeśli pozwolisz konturom rosnąć od środka na zewnątrz, powinny one spoczywać na granicach okręgu.
• Należy pamiętać, że aktywne kontury, które rosną lub kurczą się, wykorzystują energię balonu , co oznacza, że można ustawić kierunek konturów, do wewnątrz lub na zewnątrz.
• prawdopodobnie będziesz musiał użyć gradientowego obrazu w skali szarości. Ale nadal możesz spróbować również w Kolorze. Jeśli to zadziała!
• i jeśli nie dostarczysz centra, wrzucają dużo aktywnych konturów, sprawiają, że rosną/kurczą się. Kontury, które się osadzają, są przechowywane, niespokojne są wyrzucane. To podejście brutalnej siły. Będzie intensywny procesor. Ale będzie wymagał bardziej starannej pracy, aby upewnić się, że zostawisz prawidłowe kontury i wyrzucisz te złe.