Attēlu segmentēšana, izmantojot opencv

Iepriekšējās apmācībās mēs izmantojām OpenCV pamata attēlu apstrādei un veicām dažas iepriekšējas attēlu rediģēšanas darbības. Kā mēs zinām, OpenCV ir atvērtā pirmkoda piepilsētas bibliotēka, kurai ir C ++, Python un Java saskarnes un kas atbalsta Windows, Linux, Mac OS, iOS un Android. Tātad to var viegli instalēt Raspberry Pi ar Python un Linux vidi. Raspberry Pi ar OpenCV un pievienoto kameru var izmantot, lai izveidotu daudzas reāllaika attēlu apstrādes programmas, piemēram, sejas noteikšanu, sejas bloķēšanu, objektu izsekošanu, automašīnas numura noteikšanu, mājas drošības sistēmu utt. Šajā apmācībā mēs uzzināsim, kā attēlu segmentēšana, izmantojot OpenCV. Darbības, kuras mēs veiksim, ir uzskaitītas zemāk:

• Segmentēšana un kontūras
• Hierarhija un izguves režīms
• Tuvinot kontūras un atrodot to izliekto korpusu
• Koneksa korpuss
• Kontūras saskaņošana
• Formu identificēšana (aplis, taisnstūris, trīsstūris, kvadrāts, zvaigzne)
• Līnijas noteikšana
• Lāse atklāšana
• Blobu filtrēšana - apļu un elipses skaitīšana

1. Segmentēšana un kontūras

Attēlu segmentēšana ir process, kurā mēs sadalām attēlus dažādos reģionos. Tā kā kontūras ir nepārtrauktas līnijas vai līknes, kas saista vai aptver visu objekta robežu attēlā. Un šeit mēs izmantosim attēla segmentēšanas tehniku, ko sauc par kontūrām, lai iegūtu attēla daļas.

Arī kontūras ir ļoti svarīgas

• Objekta noteikšana
• Formas analīze

Viņiem ir ļoti plašs pielietojuma lauks, sākot no reālās pasaules attēlu analīzes līdz medicīnisko attēlu analīzei, piemēram, MRI

Zināsim, kā ieviest kontūras opencv, iegūstot kvadrātu kontūras.

import cv2 import numpy kā np

Ielādēsim vienkāršu attēlu ar 3 melniem kvadrātiem

image = cv2.imread ('kvadrāti.jpg') cv2.imshow ('ievades attēls', attēls) cv2.waitKey (0)

Pelēktoņu

pelēks = cv2.cvtColor (attēls, cv2.COLOR_BGR2GRAY)

Atrodiet smalkas malas

apmales = cv2.Canny (pelēks, 30 200) cv2.imshow ('canny malas', apmales) cv2.waitKey (0)

Kontūru atrašana

#izmantojiet sava attēla kopiju, piemēram, - edged.copy (), jo kontūru atrašana maina attēlu # mums ir jāpievieno _, pirms kontūras kā tukšs arguments, pateicoties OpenCV versijas jaunināšanai _, contours, hierarchy = cv2.findContours (griezīgs, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('canny malas pēc konturēšanas', apmales) cv2.waitKey (0)

Kontūru faila drukāšana, lai uzzinātu, no kā sastāv kontūras

print (contours) print ('Atrasto kontūru skaits =' + str (len (contours)))

Uzzīmējiet visas kontūras

Izmantojiet -1 kā 3. parametru, lai uzzīmētu visas kontūras cv2.drawContours (attēls, kontūras, -1, (0,255,0), 3) cv2.imshow ('kontūras', attēls) cv2.waitKey (0) cv2. destrAllWindows ()

Konsoles izeja -],],], …,],],]], dtype = int32), masīvs (],],

], …,

],],]], dtype = int32), masīvs (],],], …,],],]], tipa = int32)]

Atrasto kontūru skaits = 3. Tātad mēs esam atraduši kopumā trīs kontūras.

Tagad, iepriekš minētajā kodā mēs arī izmantojām kontūru faila izdruku , šis fails stāsta, kā šie kontūras izskatās, kā iespiests iepriekš konsoles izvadā.

Iepriekšminētajā konsoles izvadē mums ir matrica, kas izskatās kā x, y punktu koordinātas. OpenCV saglabā kontūras sarakstu sarakstos. Iepriekšminēto konsoles izvadi mēs varam vienkārši parādīt šādi:

CONTOUR 1 CONTOUR 2 CONTOUR 3

], masīvs (], masīvs (],],],],],],],

…,…,…,],],],],],],]], dtype = int32),]], dtype = int32),]], dtype = int32)]

Tagad, kad kontūru failā izmantojam garuma funkciju, garums ir vienāds ar 3, tas nozīmē, ka šajā failā bija trīs sarakstu saraksti, ti, trīs kontūras.

Tagad iedomājieties, ka CONTOUR 1 ir pirmais elements šajā masīvā, un šajā sarakstā ir visu koordinātu saraksts, un šīs koordinātas ir punkti gar kontūrām, kuras mēs tikko redzējām, kā zaļas taisnstūrveida lodziņi.

Šo koordinātu glabāšanai ir dažādas metodes, un tās sauc par aproksimācijas metodēm, galvenokārt aproksimācijas metodes ir divu veidu

• cv2.CHAIN_APPROX_NONE
• cv2.CHAIN_APPROX_SIMPLE

cv2.CHAIN_APPROX_NONE saglabā visu robežpunktu, taču mums nav obligāti vajadzīgi visi robežpunkti, ja punkts veido taisnu līniju, mums ir nepieciešams tikai sākuma punkts un beigu punkts šajā līnijā.

cv2.CHAIN_APPROX_SIMPLE tā vietā nodrošina tikai norobežojošo kontūru sākuma un beigu punktus, kā rezultātā daudz efektīvāk tiek saglabāta kontūru informācija.

_, kontūras, hierarhija = cv2.findContours (griezīgs, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

Iepriekš minētajā kodā cv2.RETR_EXTERNAL ir izguves režīms, savukārt cv2.CHAIN_APPROX_NONE ir

aproksimācijas metodi.

Tātad mēs esam iemācījušies par kontūrām un aproksimācijas metodi, tagad izpētīsim hierarhiju un izguves režīmu.

2. Hierarhija un izguves režīms

Izgūšanas režīms nosaka hierarhiju kontūrās, piemēram, apakš kontūrās, ārējā kontūrā vai visos kontūros.

Tagad hierarhijas tipos ir sakārtoti četri izguves režīmi.

cv2.RETR_LIST - izgūst visas kontūras.

cv2.RETR_EXTERNAL - izgūst tikai ārējās vai ārējās kontūras.

cv2.RETR_CCOMP - izgūst visus 2 līmeņu hierarhijā.

cv2.RETR_TREE - izgūst visus pilnā hierarhijā.

Hierarhija tiek saglabāta šādā formātā

Tagad ilustrēsim atšķirību starp pirmajiem diviem izguves režīmiem - cv2.RETR_LIST un cv2.RETR_EXTERNAL.

import cv2 import numpy kā np

Ļauj ielādēt vienkāršu attēlu ar 3 melniem laukumiem

image = cv2.imread ('square donut.jpg') cv2.imshow ('input image, image) cv2.waitKey (0)

Pelēktoņu

pelēks = cv2.cvtColor (attēls, cv2.COLOR_BGR2GRAY)

Atrodiet Canny Edges

apmales = cv2.Canny (pelēks, 30 200) cv2.imshow ('canny malas', apmales) cv2.waitKey (0)

Kontūru atrašana

#izmantojiet sava attēla kopiju, piemēram, - edged.copy (), jo kontūru atrašana maina attēlu # mums ir jāpievieno _, pirms kontūras kā tukšs arguments, pateicoties atvērtās cv versijas jaunināšanai _, kontūras, hierarhija = cv2.findContours (griezīgs, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('canny malas pēc konturēšanas', apmales) cv2.waitKey (0)

Kontūru faila drukāšana, lai uzzinātu, no kā sastāv kontūras.

print (contours) print ('Atrasto kontūru skaits =' + str (len (contours)))

Uzzīmējiet visas kontūras

Izmantojiet -1 kā 3. parametru, lai uzzīmētu visas kontūras cv2.drawContours (attēls, kontūras, -1, (0,255,0), 3) cv2.imshow ('kontūras', attēls) cv2.waitKey (0) cv2. iznīcināt AllWindows

import cv2 import numpy kā np

Ļauj ielādēt vienkāršu attēlu ar 3 melniem laukumiem

image = cv2.imread ('square donut.jpg') cv2.imshow ('input image, image) cv2.waitKey (0)

Pelēktoņu

pelēks = cv2.cvtColor (attēls, cv2.COLOR_BGR2GRAY)

Atrodiet smalkas malas

apmales = cv2.Canny (pelēks, 30 200) cv2.imshow ('canny malas', apmales) cv2.waitKey (0)

Kontūru atrašana

#izmantojiet sava attēla kopiju, piemēram, - edged.copy (), jo kontūru atrašana maina attēlu # mums ir jāpievieno _, pirms kontūras kā tukšs arguments atvērtās CV versijas _, contours, hierarchy = jaunināšanas dēļ cv2.findContours (griezīgs, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow ('canny malas pēc konturēšanas', apmales) cv2.waitKey (0)

Kontūru faila drukāšana, lai uzzinātu, no kā sastāv kontūras.

print (contours) print ('Atrasto kontūru skaits =' + str (len (contours)))

Uzzīmējiet visas kontūras

Izmantojiet -1 kā 3. parametru, lai uzzīmētu visas kontūras cv2.drawContours (attēls, kontūras, -1, (0,255,0), 3) cv2.imshow ('kontūras', attēls) cv2.waitKey (0) cv2. destrAllWindows ()

Tātad, demonstrējot iepriekš minētos kodus, mēs skaidri redzējām atšķirību starp cv2.RETR_LIST un cv2.RETR_EXTERNNAL , cv2.RETR_EXTERNNAL tiek ņemti vērā tikai ārējie kontūras, bet iekšējās kontūras tiek ignorētas.

Atrodoties cv2.RETR_LIST, tiek ņemtas vērā arī iekšējās kontūras.

3. Kontūru tuvināšana un to izliekta korpusa atrašana

Tuvinot kontūras, kontūras forma tiek tuvināta citai kontūras formai, kas var nebūt tik ļoti līdzīga pirmajai kontūras formai.

Tuvināšanai mēs izmantojam openCV funkciju aptuveniPolyDP, kas ir paskaidrots zemāk

cv2.approxPolyDP (kontūra, aproksimācijas precizitāte, slēgta)

Parametri:

• Kontūra - ir individuālā kontūra, kuru mēs vēlamies tuvināt.
• Tuvināšanas precizitāte - svarīgs parametrs, lai noteiktu tuvināšanas precizitāti, maza vērtība dod precīzu tuvinājumu, lielas vērtības sniedz vairāk vispārīgas informācijas. Labs īkšķa noteikums ir mazāks par 5% no kontūras perimetra.
• Slēgts - Būla vērtība, kas norāda, vai aptuvenais kontūrs varētu būt atvērts vai aizvērts.

Mēģināsim tuvināt vienkāršu mājas skaitli

import numpy kā np import cv2

Ievietojiet attēlu un saglabājiet kopiju

image = cv2.imread ('house.jpg') orig_image = image.copy () cv2.imshow ('sākotnējais attēls', orig_image) cv2.waitKey (0)

Pelēktoņu un binarizējiet attēlu

pelēks = cv2.cvtColor (attēls, cv2.COLOR_BGR2GRAY) ret, thresh = cv2.threshold (pelēks, 127,255, cv2.THRESH_BINARY_INV)

Atrodiet kontūras

_, kontūras, hierarhija = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Atkārtojiet katru kontūru un aprēķiniet to saistošo taisnstūri

par C kontūrām: x, y, w, h = cv2.boundingRect (c) cv2.rectangle (orig_image, (x, y), (x + w, y + H), (0,0,255), 2) CV2.imshow ('Bounding rect', orig_image) cv2.waitKey (0)

Atkārtojiet katru kontūru un aprēķiniet aptuveno kontūru

c kontūrās:

# aprēķināt precizitāti procentos no kontūras perimetra precizitātes = 0,03 * cv2.arcLength (c, True) apm = cv2.approxPolyDP (c, precizitāte, True) cv2.drawContours (attēls,, 0, (0,255,0), 2) cv2.imshow ('Aptuveni polyDP', attēls) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Izliekts korpuss

Izliekts korpuss būtībā ir ārējās malas, ko attēlo ar līniju vilkšanu virs konkrētā attēla.

Tas varētu būt mazākais daudzstūris, kas var ietilpt ap pašu objektu.

importēt cv2 importēt numpy kā np image = cv2.imread ('star.jpg') pelēks = cv2.cvtColor (attēls, cv2.COLOR_BGR2GRAY) cv2.imshow ('sākotnējais attēls', attēls) cv2.waitKey (0)

Pārsniedziet attēla slieksni

ret, kulšana = cv2. slieksnis (pelēks, 176 255,0)

Atrodiet kontūras

_, kontūras, hierarhija = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Kārtojiet kontūras pēc apgabala un pēc tam noņemiet lielāko rāmja kontūru

n = len (kontūras) -1 kontūras = sakārtotas (kontūras, atslēga = cv2.contourArea, reverse = False)

Atkārtojiet kontūras un izvelciet izliektu korpusu

c kontūrās:

korpus = cv2.convexHull (c) cv2.drawContours (attēls,, 0, (0,255,0), 2) cv2.imshow ('izliekts korpuss', attēls) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Kontūras saskaņošana pēc formām

cv2.matchShapes (kontūras veidne, kontūras metode, metodes parametrs)

Rezultāts - atbilstības vērtība (zemāka vērtība nozīmē tuvāku atbilstību)

kontūras veidne - tas ir mūsu atskaites kontūrs, kuru mēs cenšamies atrast jaunā attēlā.

kontūra - individuālais kontūrs, pret kuru mēs pārbaudāmies.

Metode - kontūru saskaņošanas veids (1,2,3).

metodes parametrs - atstājiet mierā kā 0.0 (netiek izmantots Python Opencv)

import cv2 import numpy kā np

Ielādējiet formas veidni vai atsauces attēlu

template = cv2.imread ('star.jpg', 0) cv2.imshow ('template', template) cv2.waitKey (0)

Ielādējiet mērķa attēlu ar formām, kuras mēs cenšamies saskaņot

target = cv2.imread ('shapestomatch.jpg') pelēks = cv2.cvtColor (target, cv2.COLOR_BGR2GRAY)

Pirms cv2.findContours izmantošanas vispirms nosakiet slieksni abiem attēliem

ret, thresh1 = cv2.threshold (veidne, 127,255,0) ret, thresh2 = cv2.threshold (pelēks, 127,255,0)

Veidnē atrodiet kontūras

_, contours, hierarhy = cv2.findContours (thresh1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) # mums ir jāšķiro kontūras pēc apgabala, lai mēs varētu noņemt lielāko kontūru, kas ir

Attēla kontūra

sorted_contours = sakārtoti (kontūras, atslēga = cv2.contourArea, reverse = True) # mēs izvelkam otro lielāko kontūru, kas būs mūsu veidnes kontūra tempelate_contour = contours # izvelciet kontūras no otrā mērķa attēla _, kontūras, hierarhija = cv2.findContours (thresh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) c kontūrās: # rakstiet pa katru kontūru mērķa attēlā un izmantojiet cv2.matchShape, lai salīdzinātu kontūras formas atbilstību = cv2.matchShapes (tempelate_contour, c, 1,0.0) print ("sakritība") # ja atbilstības vērtība ir mazāka par 0,15, ja atbilst <0,16: tuvākais_kontūrs = c cits: tuvākais_kontūrs = cv2.drawContours (mērķis,, - 1, (0,255,0), 3) cv2.imshow ('izeja', mērķis) cv2.waitKey (0) cv2.destroyAllWindows ()

Konsoles izeja -

0,16818605122199104

0.19946910256158912

0.18949760627309664

0.11101058276281539

Ir trīs dažādas metodes ar dažādām matemātikas funkcijām, mēs varam eksperimentēt ar katru metodi, vienkārši aizstājot cv2.matchShapes (tempelate_contour, c, 1, 0.0) metodes vērtības, kas svārstās no 1,2 līdz 3, katrai vērtībai jūs saņemsiet atšķirīgu atbilstību vērtības konsoles izvadā.

6. Formu identificēšana (aplis, taisnstūris, trīsstūris, kvadrāts, zvaigzne)

OpenCV var izmantot arī, lai automātiski noteiktu dažāda veida formas no attēla. Izmantojot zemāk esošo kodu, mēs no attēla varēsim noteikt apli, taisnstūri, trīsstūri, kvadrātu un zvaigznes.

import cv2 import numpy kā np

Ielādējiet un pēc tam pelēkā mērogā attēlus

image = cv2.imread ('formas.jpg') pelēks = cv2.cvtColor (attēls, cv2.COLOR_BGR2GRAY) cv2.imshow ('formas identificēšana', attēls) cv2.waitKey (0) ret, thresh = cv2.threshold (pelēks, 127,255,1)

Izvelciet kontūras

_, kontūras, hierarhija = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Par cnt kontūrās:

Saņemt aptuvenās poligonus apm = cv2.approxPolyDP (cnt, 0.01 * cv2.arcLength (CNT, True), True) ja len (aptuveni) == 3: shape_name = "Triangle" cv2.drawContours (attēla,, 0, (0255, 0), - 1)

atrodiet kontūru centru, lai centrā ievietotu tekstu

M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (attēls, formas_nosaukums, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0, 0), 1) elif len (aptuveni) == 4: x, y, w, h = cv2.boundingRect (cnt) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M)

Pārbaudiet, vai šis četrpusīgais daudzstūris ir kvadrāts vai taisnstūris

# cv2.boundingRect atgriež kreiso platumu un augstumu pikseļos, sākot no augšējā # kreisā stūra, kvadrātam tas būtu aptuveni vienāds, ja abs (wh) <= 3: shape_name = "square" # atrast kontūru centru, lai ievietotu tekstu centrs cv2.drawContours (attēls,, 0, (0,125,255), - 1) cv2.putText (attēls, formas_nosaukums, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) else: shape_name = "Reactangle" # atrodiet kontūras centru, lai tekstu ievietotu centrā cv2.drawContours (attēls,, 0, (0,0,255), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (attēls, formas_nosaukums, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (aptuveni) == 10: formas_nosaukums = "zvaigzne" cv2.drawContours (attēls,, 0, (255,255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (attēls, formas_nosaukums, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (aptuveni)> = 15: shape_name = 'aplis' cv2.drawContours (attēls,, 0, (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (attēls, formas_nosaukums, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow ('formu identificēšana, attēls) cv2.waitKey (0) cv2.destroyAllWindows ()

7. Līnijas noteikšana

Līnijas noteikšana ir ļoti svarīgs jēdziens OpenCV, un to daudzsološi izmanto reālajā pasaulē. Autonomās automašīnas joslu un ceļu noteikšanai izmanto līniju noteikšanas algoritmus.

Līnijas noteikšanā mēs strādāsim ar diviem algoritmiem,

• Hough līnijas algoritms
• Probālistiskais Hough līnijas algoritms.

Iespējams, esat atcerējies līnijas attēlojumu no vidusskolas matemātikas ar vienādojumu y = mx + c.

Tomēr OpenCV līnijā tiek attēlots cits veids

Vienādojums virs ρ = xcosӨ + ysincosӨ ir līnijas OpenCV attēlojums, kur ρ ir perpendikulārs līnijas attālums no sākuma un Ө ir leņķis, ko veido šīs līnijas normāls pret izcelsmi (mērot radiānos, kur 1pi radiāni / 180 = 1 grāds).

OpenCV funkcija līnijas noteikšanai tiek dota kā

cv2.HoughLines (binārs attēls, ρ precizitāte, Ө precizitāte, slieksnis), kur slieksnis ir minimālais balss, lai to uzskatītu par līniju.

Tagad atklāsim līnijas lodziņa attēlam, izmantojot opcijas Hough līnijas funkciju.

importēt cv2 importēt numpy kā np image = cv2.imread ('box.jpg')

Izvelk pelēktoņu un kārtainās malas

pelēks = cv2.cvtColor (attēls, cv2.COLOR_BGR2GRAY) malas = cv2.Canny (pelēks, 100,170, apertūras izmērs = 3)

Palaidiet Hough līnijas, izmantojot 1 pikseļa rho precizitāti

#theta precizitāte (np.pi / 180), kas ir 1 grāds # līnijas slieksnis, ir iestatīta uz 240 (punktu skaits uz līnijas) līnijas = cv2.oughoughlines (malas, 1, np.pi / 180, 240) # mēs atkārtojam cauri katrai līnijai un pārveidojiet formātā #, kuru pieprasa cv2.lines (ti, nepieciešami beigu punkti) i diapazonā (0, len (līnijas)): rho, teta rindās: a = np.cos (teta) b = np.sin (teta) x0 = a * rho y0 = b * rho x1 = int (x0 + 1000 * (- b)) y1 = int (y0 + 1000 * (a)) x2 = int (x0-1000 * (-b)) y2 = int (y0-1000 * (a)) cv2.līnija (attēls, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow ('līnijas', attēls) cv2.waitKey (0) cv2.destroyAllWindows ()

Tagad atkārtosim virs līnijas noteikšanu ar citu varbūtības Hough līnijas algoritmu.

Varbūtīgās Hough līnijas ideja ir ņemt nejaušu punktu apakškopu, kas ir pietiekama līnijas noteikšanai.

OpenCV funkcija varbūtības pakāpes Hough līnijai tiek attēlota kā cv2.

Tagad atklāsim lodziņa līnijas ar varbūtības Hough līniju palīdzību.

import cv2 import numpy kā np

Pelēktoņu un kārtainās malas ekstrahētas

image = cv2.imread ('box.jpg') pelēks = cv2.cvtColor (attēls, cv2.COLOR_BGR2GRAY) malas = cv2.Canny (pelēks, 50,150, apertureSize = 3) # atkal izmantojam tās pašas rho un theta precizitātes # tomēr, mēs norādām minimālo balsu skaitu (punkti gar līniju) 100 # un min. 5 pikseļu līnijas garums un maksimālā atstarpe starp 10 pikseļu līniju līnijām = cv2.HoughLinesP (malas, 1, np.pi / 180,100,100,10) i diapazonā (0, len (līnijas)): x1, y1, x2, y2 līnijās: cv2.line (attēls, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow ('probalistic hough lines', image) cv2.waitKey (0) cv2.destroyAllWindows

8. Lāse atklāšana

Blobus var raksturot kā savienotu pikseļu grupu, kuriem visiem ir kopīgs īpašums. Metode OpenCV lāse detektora izmantošanai ir aprakstīta šajā plūsmas diagrammā.

Galveno punktu zīmēšanai mēs izmantojam cv2.drawKeypoints, kas ņem šādus argumentus.

cv2.drawKeypoints (ievades attēls, atslēgas punkti, blank_output_array, krāsa, karodziņi)

kur varētu atrasties karogi

cv2.DRAW_MATCHES_FLAGS_DEFAULT

cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS

cv2.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG

cv2.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS

un tukšs šeit ir gandrīz nekas cits kā tikai pa nullēm matrica

Tagad veiksim pļavas noteikšanu uz saulespuķu attēla, kur lāse būtu zieda centrālās daļas, jo tās ir izplatītas starp visiem ziediem.

importēt cv2 importēt numpy kā np image = cv2.imread ('Sunflowers.jpg', cv2.IMREAD_GRAYSCALE)

Iestatiet detektoru ar noklusējuma parametriem

detektors = cv2.SimpleBlobDetector_create ()

Noteikt lāseņus

keypoints = detector.detect (attēls)

Uzzīmējiet atrastos lāseņus kā sarkanos apļus

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS nodrošina, ka apļa # izmērs atbilst plankuma tukšumam = np.zeros ((1,1)) blobs = cv2.drawKeypoints (attēls, atslēgu punkti, tukšs, (0,255,255)), 0,255,255), cv2.DRA

Parādīt galvenos punktus

cv2.imshow ('lāse', lāse ) cv2.waitKey (0) cv2.destroyAllWindows ()

Pat ja kods darbojas labi, bet daži no plankumiem tiek izlaisti nevienmērīgu ziedu izmēru dēļ, jo ziedi priekšā ir lieli, salīdzinot ar ziediem beigās.

9. Blobu filtrēšana - apļu un elipses skaitīšana

Mēs varam izmantot parametrus, lai filtrētu plankumus pēc to formas, lieluma un krāsas. Lai izmantotu parametrus ar lāse detektoru, mēs izmantojam OpenCV funkciju

cv2.SimpleBlobDetector_Params ()

Blobus filtrēsim galvenokārt pēc četriem zemāk uzskaitītajiem parametriem:

Platība

params.filterByArea = True / False params.minArea = pikseļi params.maxArea = pikseļi

Apkārtraksts

params.filterByCircularity = True / False params.minCircularity = 1 ir ideāls, 0 ir pretējs

Izliekums - lāse / izliekta korpusa laukums

params.filterByConvexity = True / False params.minConvexity = apgabals

Inerce

params.filterByInertia = True / False params.minInertiaRatio = 0,01

Tagad mēģināsim filtrēt plankumus pēc iepriekš minētajiem parametriem

importēt cv2 importēt numpy kā np image = cv2.imread ('blobs.jpg') cv2.imshow ('sākotnējais attēls', attēls) cv2.waitKey (0)

Inicializējiet detektoru, izmantojot noklusējuma parametrus

detektors = cv2.SimpleBlobDetector_create ()

Noteikt lāseņus

keypoints = detector.detect (attēls)

Uz mūsu attēla uzzīmējiet plankumus kā sarkanus apļus

tukšs = np.zeros ((1,1)) lāse = cv2.drawKeypoints (attēls, atslēgas punkti, tukšs, (0,0255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (keypoints) text = "kopējais burbuļu skaits" + [len (keypoints)] cv2.putText (lāse, teksts, (20,550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100,0, 255), 2

Parādīt attēlu ar lāse galvenajiem punktiem

cv2.imshow ('lāse, izmantojot noklusējuma parametrus', lāse) cv2.waitKey (0)

Iestatiet mūsu filtrēšanas parametrus

#initialize parametru iestatījums, izmantojot cv2.SimpleBlobDetector params = cv2.SimpleBlobDetector_Params ()

Iestatiet apgabala filtrēšanas parametrus

params.filterByArea = Patiesie params.minArea = 100

Iestatiet aprites filtrēšanas parametrus

params.filterByCircularity = Patiesie params.minCircularity = 0,9

Iestatiet izliekuma filtrēšanas parametru

params.filterByConvexity = Nepatiesi params.minConvexity = 0,2

Iestatiet inerces filtrēšanas parametru

params.filterByInertia = Īstā params.minInertiaRatio = 0,01

Izveidojiet detektoru ar parametru

detektors = cv2.SimpleBlobDetector_create (parametri)

Noteikt lāseņus

keypoints = detector.detect (attēls)

Uzzīmējiet burbuļus uz attēliem kā sarkanus apļus

blank = np.zeros ((1,1)) lāse = cv2.drawKeypoints (attēls, atslēgas punkti, tukšs, (0,255,0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (keypoints) text = "kopējais apļveida burbuļu skaits str (len (keypoints)) cv2.putText (lāse, teksts, (20,550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,100,255), 2)

Parādīt lāseņus

cv2.imshow ('apļveida lāseņu filtrēšana', lāse ) cv2.waitKey (0) cv2.destroyAllWindows ()

Tātad šādi segmentēt attēlu var Python-OpenCV. Lai labi nepietiekami novērtētu datora redzi un OpenCV, izlasiet iepriekšējos rakstus (Darba sākšana ar Python OpenCV un Attēlu manipulācijām Python OpenCV un jūs varēsit izveidot kaut ko foršu ar Computer Vision.