Paghihiwalay ng imahe gamit ang opencv

Sa nakaraang mga tutorial, ginamit namin ang OpenCV para sa pangunahing pagproseso ng imahe at nagawa ang ilang mga advance na pagpapatakbo ng pag-edit ng imahe. Tulad ng alam natin, ang OpenCV ay Open Source Commuter Vision Library na mayroong mga interface ng C ++, Python at Java at sumusuporta sa Windows, Linux, Mac OS, iOS at Android. Kaya madali itong mai-install sa Raspberry Pi na may kapaligiran sa Python at Linux. At ang Raspberry Pi na may OpenCV at naka-attach na camera ay maaaring magamit upang lumikha ng maraming mga application ng pagproseso ng imahe ng real-time tulad ng Pagtuklas ng mukha, lock ng mukha, pagsubaybay sa object, pagtuklas ng plate ng numero ng kotse, Home security system atbp. Sa tutorial na ito malalaman natin na kung paano paghihiwalay ng imahe gamit ang OpenCV. Ang mga pagpapatakbo na isasagawa namin ay nakalista sa ibaba:

• Pagkakahiwalay at mga contour
• Hierarchy at mode ng pagkuha
• Tinatayang mga contour at paghahanap ng kanilang convex hull
• Conex Hull
• Pagtutugma ng Contour
• Pagkilala sa Mga Hugis (bilog, parihaba, tatsulok, parisukat, bituin)
• Pagtuklas ng linya
• Pagtuklas ng blob
• Pag-filter ng mga bloke - bilangin ang mga bilog at elips

1. Pag-segment at mga contour

Ang paghihiwalay ng imahe ay isang proseso kung saan ibinabahagi namin ang mga imahe sa iba't ibang mga rehiyon. Samantalang ang mga contour ay ang tuloy-tuloy na mga linya o curve na nagbubuklod o sumasakop sa buong hangganan ng isang bagay sa isang imahe. At, dito gagamitin namin ang diskarteng paghihiwalay ng imahe na tinatawag na mga contour upang makuha ang mga bahagi ng isang imahe.

Gayundin ang mga contour ay napakahalaga sa

• Pagtuklas ng object
• Pagsusuri sa hugis

At mayroon silang malawak na larangan ng aplikasyon mula sa totoong pagtatasa ng imahe sa mundo hanggang sa pagtatasa ng imaheng medikal tulad ng sa MRI

Alamin natin kung paano ipatupad ang mga contour sa opencv, sa pamamagitan ng pagkuha ng mga contour ng mga parisukat.

i-import ang cv2 import numpy bilang np

Mag-load tayo ng isang simpleng imahe na may 3 itim na mga parisukat

image = cv2.imread ('squares.jpg') cv2.imshow ('input image', imahe) cv2.waitKey (0)

Grayscale

grey = cv2.cvtColor (imahe, cv2.COLOR_BGR2GRAY)

Humanap ng mga nakasisilaw na gilid

talim = cv2.Canny (grey, 30,200) cv2.imshow ('canny edge', talim) cv2.waitKey (0)

Paghanap ng mga contour

# Gumamit ng isang kopya ng iyong imahe, hal - edged.copy (), dahil ang paghahanap ng mga contour baguhin ang imahe # kailangan nating idagdag _, bago ang mga contour bilang isang walang laman na argument dahil sa pag-upgrade ng bersyon ng OpenCV _, mga contour, hierarchy = cv2.findContours (gilid, cv2.RETR_EXternalAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('canny edge pagkatapos ng contouring', talim) cv2.waitKey (0)

Pagpi-print ng contour file upang malaman kung anong mga contour ang sumasama

print (contours) print ('Mga bilang ng mga contour na nahanap =' + str (len (contours)))

Iguhit ang lahat ng mga contour

#use -1 bilang ika-3 na parameter upang iguhit ang lahat ng mga contour cv2.drawContours (imahe, contours, -1, (0,255,0), 3) cv2.imshow ('contours', imahe) cv2.waitKey (0) cv2. sirainAllWindows ()

Output ng Console -],],], …,],],]], dtype = int32), array (],],

], …,

],],]], dtype = int32), array (],],], …,],],]], dtype = int32)]

Nahanap ang mga bilang ng contour = 3. Kaya natagpuan namin ang isang kabuuan ng tatlong mga contour.

Ngayon, sa code sa itaas ay naka-print din kami ng contour file na ginagamit , sinasabi ng file na ito kung paano ang hitsura ng mga contour na ito, tulad ng naka-print sa output ng console sa itaas.

Sa output sa itaas ng console mayroon kaming isang matrix na mukhang mga coordinate ng x, y point. Nag-iimbak ang OpenCV ng mga contour sa isang listahan ng mga listahan. Maaari lamang naming ipakita ang output sa itaas ng console tulad ng sumusunod:

CONTOUR 1 CONTOUR 2 CONTOUR 3

], array (], array (],],],],],],],

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

Ngayon, habang ginagamit namin ang haba ng pag-andar sa contour file, nakukuha namin ang haba na katumbas ng 3, nangangahulugan ito na mayroong tatlong listahan ng mga listahan sa file na iyon, ibig sabihin, tatlong mga contour.

Ngayon, isipin ang CONTOUR 1 ang unang elemento sa array na iyon at ang listahang iyon ay naglalaman ng listahan ng lahat ng mga coordinate at ang mga coordinate na ito ay ang mga puntos sa mga contour na ngayon lamang namin nakita, bilang mga berdeng parihabang kahon.

Mayroong iba't ibang mga pamamaraan upang maiimbak ang mga koordinasyong ito at ang mga ito ay tinatawag na mga pamamaraang approximation, karaniwang ang mga pamamaraan ng pagtatantya ay may dalawang uri

• cv2.CHAIN_APPROX_NONE
• cv2.CHAIN_APPROX_SIMPLE

Ang cv2.CHAIN_APPROX_NONE ay nag- iimbak ng lahat ng hangganan, ngunit hindi namin kinakailangang kailangan ang lahat ng mga puntos ng hangganan, kung ang point ay bumubuo ng isang tuwid na linya, kailangan lamang namin ang panimulang punto at pagtatapos na punto sa linyang iyon.

cv2.CHAIN_APPROX_SIMPLE sa halip ay nagbibigay lamang ng mga punto ng pagsisimula at pagtatapos ng mga hangganan na contour, ang resulta ay mas mahusay na pag-iimbak ng impormasyon ng contour.

_, contours, hierarchy = cv2.findContours (talim, cv2.RETR_EXternal, cv2.CHAIN_APPROX_NONE)

Sa nasa itaas na code cv2.RETR_EXternal ay ang retrieval mode habang ang cv2.CHAIN_APPROX_NONE ay

ang pamamaraang pamamaraang.

Kaya't nalaman natin ang tungkol sa mga contour at pamamaraang pag-approximation, ngayon tuklasin natin ang hierarchy at retrieval mode.

2. Hierarchy at Retrieval Mode

Tinutukoy ng mode ng pagkuha ang hierarchy sa mga contour tulad ng mga sub contour, o panlabas na contour o lahat ng mga contour.

Ngayon may apat na mga mode ng pagkuha na pinagsunod-sunod sa mga uri ng hierarchy.

cv2.RETR_LIST - kinukuha ang lahat ng mga contour.

cv2.RETR_EXternal - kinukuha lamang ang panlabas o panlabas na mga contour.

cv2.RETR_CCOMP - Kinukuha ang lahat sa isang 2-level hierarchy.

cv2.RETR_TREE - Kinukuha ang lahat sa isang buong hierarchy.

Ang heriarkiya ay nakaimbak sa sumusunod na format

Ngayon ay ilarawan natin ang pagkakaiba sa pagitan ng unang dalawang mga mode sa pagkuha, cv2.RETR_LIST at cv2.RETR_EXternalAL.

i-import ang cv2 import numpy bilang np

Hinahayaan mag-load ng isang simpleng imahe na may 3 itim na mga parisukat

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

Grayscale

grey = cv2.cvtColor (imahe, cv2.COLOR_BGR2GRAY)

Maghanap ng Canny Edges

talim = cv2.Canny (grey, 30,200) cv2.imshow ('canny edge', talim) cv2.waitKey (0)

Paghanap ng Mga Contour

# Gumamit ng isang kopya ng iyong imahe, hal - edged.copy (), dahil ang paghahanap ng mga contour baguhin ang imahe # kailangan nating idagdag _, bago ang mga contour bilang isang walang laman na argument dahil sa pag-upgrade ng bukas na bersyon ng cv _, mga contour, hierarchy = cv2.findContours (talim, cv2.RETR_EXternal, cv2.CHAIN_APPROX_NONE) cv2.imshow ('canny edge pagkatapos ng contouring', talim) cv2.waitKey (0)

Pagpi-print ng contour file upang malaman kung anong mga contour ang sumasama.

print (contours) print ('Mga bilang ng mga contour na nahanap =' + str (len (contours)))

Iguhit ang lahat ng mga contour

#use -1 bilang ika-3 na parameter upang iguhit ang lahat ng mga contour cv2.drawContours (imahe, contours, -1, (0,255,0), 3) cv2.imshow ('contours', imahe) cv2.waitKey (0) cv2. sirainAllWindows

i-import ang cv2 import numpy bilang np

Hinahayaan mag-load ng isang simpleng imahe na may 3 itim na mga parisukat

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

Grayscale

grey = cv2.cvtColor (imahe, cv2.COLOR_BGR2GRAY)

Humanap ng mga nakasisilaw na gilid

talim = cv2.Canny (grey, 30,200) cv2.imshow ('canny edge', talim) cv2.waitKey (0)

Paghanap ng mga contour

#use isang kopya ng iyong mga imahe, hal - edged.copy (), dahil ang paghahanap ng mga contours baguhin ang imahe #we kailangang idagdag _, bago ang contours ng isang walang laman argument dahil i-upgrade sa mga bukas na bersyon cv _, contours, hierarchy = cv2.findContours (gilid, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow ('canny edge pagkatapos ng contouring', may gilid) cv2.waitKey (0)

Pagpi-print ng contour file upang malaman kung anong mga contour ang sumasama.

print (contours) print ('Mga bilang ng mga contour na nahanap =' + str (len (contours)))

Iguhit ang lahat ng mga contour

#use -1 bilang ika-3 na parameter upang iguhit ang lahat ng mga contour cv2.drawContours (imahe, contours, -1, (0,255,0), 3) cv2.imshow ('contours', imahe) cv2.waitKey (0) cv2. sirainAllWindows ()

Kaya sa pamamagitan ng pagpapakita ng mga code sa itaas malinaw na nakikita namin ang pagkakaiba sa pagitan ng cv2.RETR_LIST at cv2.RETR_EXTERNNAL , sa cv2.RETR_EXTERNNAL ang mga panlabas na contour lamang ang isinasaalang-alang habang ang panloob na mga contour ay hindi pinapansin.

Habang nasa cv2.RETR_LIST panloob na mga contour ay isinasaalang-alang din.

3. Tinatayang Mga Contour at Paghahanap ng kanilang Convex hull

Sa tinatayang mga contour, ang isang hugis ng tabas ay tinatayang higit sa isa pang hugis ng tabas, na maaaring hindi gaanong katulad sa unang hugis ng tabas.

Para sa approximation ginagamit namin ang approxPolyDP function ng openCV na ipinaliwanag sa ibaba

cv2.approxPolyDP (tabas, kawastuhan ng approximation, sarado)

Mga Parameter:

• Contour - ay ang indibidwal na tabas na nais naming tantyahin.
• Pagkakatugma ng Pag-apruba - mahalagang parameter sa pagtukoy ng kawastuhan ng approximation, maliit na halaga magbigay ng tumpak na approximation, malaking halaga ay nagbibigay ng mas pangkalahatang impormasyon. Ang isang mahusay na panuntunan sa hinlalaki ay mas mababa sa 5% ng contour perimeter.
• Sarado - isang halaga ng Boolean na nagsasaad kung ang tinatayang tabas ay maaaring buksan o sarado.

Subukan nating tantyahin ang isang simpleng pigura ng isang bahay

i-import ang numpy bilang np import cv2

I-load ang imahe at magtago ng isang kopya

imahe = cv2.imread ('house.jpg') orig_image = image.copy () cv2.imshow ('orihinal na imahe', Orig_image) cv2.waitKey (0)

Grayscale at binarize ang imahe

grey = cv2.cvtColor (imahe, cv2.COLOR_BGR2GRAY) ret, thresh = cv2.threshold (grey, 127,255, cv2.THRESH_BINARY_INV)

Maghanap ng Mga Contour

_, contours, hierarchy = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Iterate sa pamamagitan ng bawat tabas at kalkulahin ang kanilang hangganan na rektanggulo

para sa c sa mga contour: 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)

Iterate sa pamamagitan ng bawat tabas at kalkulahin ang tinatayang tabas

para sa c sa mga contour:

# kalkulahin ang kawastuhan bilang isang porsyento ng katumpakan ng contour perimeter = 0.03 * cv2.arcLength (c, True) approx = cv2.approxPolyDP (c, kawastuhan, Totoo) cv2.drawContours (imahe,, 0, (0,255,0), 2) cv2.imshow ('Approx polyDP', imahe) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Convex Hull

Ang convex hull ay karaniwang mga panlabas na gilid, na kinakatawan ng mga linya ng pagguhit sa isang naibigay na pigura.

Maaari itong ang pinakamaliit na polygon na maaaring magkasya sa paligid ng object mismo.

import cv2 import numpy as np image = cv2.imread ('star.jpg') grey = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) cv2.imshow ('orihinal na imahe', imahe) cv2.waitKey (0)

Threshold ang imahe

ret, thresh = cv2. Threshold (grey, 176,255,0)

Maghanap ng mga contour

_, contours, hierarchy = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Pagbukud-bukurin ang mga contour ayon sa lugar at pagkatapos ay alisin ang pinakamalaking contour ng frame

n = len (contours) -1 contours = inayos (contours, key = cv2.contourArea, reverse = False)

Iterate sa pamamagitan ng mga contour at gumuhit ng convex hull

para sa c sa mga contour:

hull = cv2.convexHull (c) cv2.drawContours (imahe,, 0, (0,255,0), 2) cv2.imshow ('convex hull', imahe) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Pagtutugma ng Contour ayon sa mga hugis

cv2.matchShapes (template ng contour, pamamaraan ng contour, parameter ng pamamaraan)

Output - halaga ng pagtutugma (ang mas mababang halaga ay nangangahulugang isang mas malapit na tugma)

template ng contour - Ito ang aming contour na sanggunian na sinusubukan naming hanapin sa isang bagong imahe.

tabas - Ang indibidwal na tabas na sinusuri namin laban.

Paraan - Uri ng pagtutugma ng contour (1,2,3).

parameter ng pamamaraan - iwanang mag-isa bilang 0.0 (hindi nagamit sa python opencv)

i-import ang cv2 import numpy bilang np

I-load ang template ng hugis o imahe ng sanggunian

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

I-load ang target na imahe sa mga hugis na sinusubukan naming itugma

target = cv2.imread ('formestomatch.jpg') grey = cv2.cvtColor (target, cv2.COLOR_BGR2GRAY)

Ang threshold ang parehong mga imahe muna bago gamitin ang cv2.findContours

ret, thresh1 = cv2. Threshold (template, 127,255,0) ret, thresh2 = cv2. Threshold (grey, 127,255,0)

Maghanap ng mga contour sa template

_, contours, hierarhy = cv2.findContours (thresh1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) #Kailangan nating ayusin ang mga contour ayon sa lugar upang maalis namin ang pinakamalaking contour na

Balangkas ng imahe

sorted_contours = pinagsunod-sunod (contours, key = cv2.contourArea, reverse = True) #we extract the second pinakamalaking contour which will be our template contour tempelate_contour = contours #extract the contours from the second target image _, contours, hierarchy = cv2.findContours (thresh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) para sa mga contour: #iterate through bawat contour sa target na imahe at gumamit ng cv2.matchShape upang ihambing ang tugma ng hugis ng contour = cv2.matchShapes (tempelate_contour, c, 1,0.0) print ("match") #kung ang halaga ng tugma ay mas mababa sa 0.15 kung tugma <0.16: closer_contour = c else: closer_contour = cv2.drawContours (target,, - 1, (0,255,0), 3) cv2.imshow ('output', target) cv2.waitKey (0) cv2.destroyAllWindows ()

Output ng Console -

0.16818605122199104

0.19946910256158912

0.18949760627309664

0.11101058276281539

Mayroong tatlong magkakaibang pamamaraan na may iba't ibang pag-andar ng matematika, maaari kaming mag-eksperimento sa bawat pamamaraan sa pamamagitan lamang ng pagpapalit ng cv2.matchShapes (tempelate_contour, c, 1, 0.0) na mga halaga ng pamamaraan na nag-iiba mula 1,2 at 3, para sa bawat halaga makakakuha ka ng iba't ibang tugma mga halaga sa output ng console.

6. Pagkilala sa Mga Hugis (bilog, parihaba, tatsulok, parisukat, bituin)

Maaari ding magamit ang OpenCV para sa pagtuklas ng iba't ibang mga uri ng mga hugis na awtomatikong mula sa imahe. Sa pamamagitan ng paggamit sa ibaba ng code ay makakakita kami ng bilog, rektanggulo, tatsulok, parisukat at mga bituin mula sa imahe.

i-import ang cv2 import numpy bilang np

Mag-load at pagkatapos ay mga imahe ng kulay-abo na sukat

imahe = cv2.imread ('shaped.jpg') grey = cv2.cvtColor (imahe, cv2.COLOR_BGR2GRAY) cv2.imshow ('pagkilala sa mga hugis', imahe) cv2.waitKey (0) ret, thresh = cv2.threshold (grey, 127,255,1)

I-extract ang mga contour

_, contours, hierarchy = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Para sa cnt sa mga contour:

Kumuha ng tinatayang mga polygon approx = cv2.approxPolyDP (cnt, 0.01 * cv2.arcLength (cnt, True), True) kung len (approx) == 3: form_name = "Triangle" cv2.drawContours (imahe,, 0, (0,255, 0), - 1)

hanapin ang contour center upang maglagay ng teksto sa gitna

M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imahe, form_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0, 0), 1) elif len (approx) == 4: x, y, w, h = cv2.boundingRect (cnt) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M)

Suriin kung ang apat na panig na polygon ay parisukat o parihaba

# cv2.boundingRect ibalik ang kaliwang lapad at taas sa mga pixel, simula sa tuktok na # kaliwang sulok, para sa parisukat ay magiging pareho ito kung abs (wh) <= 3: form_name = "square" #find contour center upang maglagay ng teksto sa center cv2.drawContours (imahe,, 0, (0,125,255), - 1) cv2.putText (imahe, form_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) iba pa: shape_name = "Reactangle" #find contour center upang maglagay ng teksto sa center cv2.drawContours (imahe,, 0, (0,0,255), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imahe, form_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (tinatayang) == 10: form_name = 'bituin' cv2.drawContours (imahe,, 0, (255,255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imahe, form_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (approx)> = 15: form_name = 'bilog' cv2.drawContours (imahe,, 0, (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imahe, form_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow ('pagkilala sa mga hugis', imahe) cv2.waitKey (0) cv2.destroyAllWindows ()

7. Pagtuklas ng Linya

Ang pagtuklas ng linya ay napaka-importanteng konsepto sa OpenCV, at may promising paggamit sa totoong mundo. Ang mga awtomatikong kotse ay gumagamit ng mga algorithm ng pagtuklas ng linya para sa pagtuklas ng mga daanan at kalsada.

Sa pagtuklas ng linya haharapin natin ang dalawang mga algorithm,

• Hough Line Algorithm
• Probalistic Hough Line Algorithm.

Maaaring naalala mo ang representasyon ng linya mula sa matematika ng high school na may equation, y = mx + c.

Gayunpaman, sa linya ng OpenCV ay kinakatawan ng ibang paraan

Ang equation sa itaas ρ = xcosӨ + ysincosӨ ay ang representasyon ng OpenCV ng linya, kung saan ang ρ ay ang patayo na distansya ng linya mula sa pinagmulan at Ө ang anggulo na nabuo ng normal ng linyang ito hanggang sa pinagmulan (sinusukat sa mga radian, kung saan ang 1pi radian / 180 = 1 degree).

Ang pagpapaandar ng OpenCV para sa pagtuklas ng linya ay ibinibigay bilang

cv2.HoughLines (binarized na imahe, ρ kawastuhan, Ө kawastuhan, threshold), kung saan ang threshold ay minimum na boto para ito ay maituring na isang linya.

Ngayon ay tuklasin natin ang mga linya para sa isang imahe ng kahon sa tulong ng Hough line function ng opencv.

i-import ang cv2 import numpy bilang np image = cv2.imread ('box.jpg')

Ang grayscale at canny edge ay nakuha

grey = cv2.cvtColor (imahe, cv2.COLOR_BGR2GRAY) mga gilid = cv2.Canny (grey, 100,170, apertureSize = 3)

Patakbuhin ang mga linya ng Hough gamit ang rho katumpakan ng 1 pixel

#theta katumpakan ng (np.pi / 180) na kung saan ay 1 degree # line threshold ay nakatakda sa 240 (bilang ng mga puntos sa linya) linya = cv2.HoughLines (gilid, 1, np.pi / 180, 240) #weerate sa pamamagitan ng bawat linya at i-convert sa format na # hinihiling ng cv2.lines (ibig sabihin nangangailangan ng mga puntos sa pagtatapos) para sa i sa saklaw (0, len (mga linya)): para sa rho, theta sa mga linya: a = np.cos (theta) b = np.sin (theta) 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.line (imahe, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow ('hough lines', imahe) cv2.waitKey (0) cv2.destroyAllWindows ()

Ngayon ulitin natin ang pagtuklas ng linya sa itaas kasama ng iba pang algorithm ng probabilistic Hough line.

Ang ideya sa likod ng probabilistic Hough line ay upang kumuha ng isang random na subset ng mga puntos na sapat na sapat para sa pagtuklas ng linya.

Ang pagpapaandar ng OpenCV para sa probabilistic Hough line ay kinakatawan bilang cv2. HoughLinesP (binarized na imahe, ρ kawastuhan, Ө kawastuhan, threshold, minimum na haba ng linya, max line gap)

Ngayon tuklasin natin ang mga linya ng kahon sa tulong ng mga probabilistic Hough na linya.

i-import ang cv2 import numpy bilang np

Grayscale at canny edge na Kinuha

image = cv2.imread ('box.jpg') grey = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) edge = cv2.Canny (grey, 50,150, apertureSize = 3) #paggamit namin ng parehong rho at thetaaksacies #however, tinukoy namin ang isang minimum na boto (pts kasama ang linya) na 100 # at haba ng linya ng linya na 5 mga pixel at max na puwang sa pagitan ng mga linya ng 10 mga linya ng pixel = cv2.HoughLinesP (mga gilid, 1, np.pi / 180,100,100,10) para sa i sa saklaw (0, len (mga linya)): para sa x1, y1, x2, y2 sa mga linya: cv2.line (imahe, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow ('mga probalistic hough line', imahe) cv2.waitKey (0) cv2.destroyAllWindows

8. Pagtuklas ng blob

Maaaring mailarawan ang mga blobs bilang isang pangkat ng mga konektadong pixel na lahat ay nagbabahagi ng isang karaniwang pag-aari. Ang pamamaraan upang magamit ang OpenCV blob detector ay inilarawan sa pamamagitan ng flow chart na ito.

Para sa pagguhit ng mga pangunahing puntos na ginagamit namin cv2.drawKeypoints na kumukuha ng mga sumusunod na argumento.

cv2.drawKeypoints (input ng imahe, keypoints, blank_output_array, kulay, watawat)

kung saan sa mga watawat maaaring maging

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

at blangko dito ay halos wala ngunit isa-isang matrix ng mga zero

Gawin natin ngayon ang pagtuklas ng patak sa isang imahe ng mga sunflower, kung saan ang mga bloke ay magiging gitnang bahagi ng bulaklak dahil karaniwan sila sa lahat ng mga bulaklak.

i-import ang cv2 import numpy bilang np image = cv2.imread ('Sunflowers.jpg', cv2.IMREAD_GRAYSCALE)

I-set up ang detector na may mga default na parameter

detector = cv2.SimpleBlobDetector_create ()

Makita ang mga patak

keypoints = detector.detect (imahe)

Iguhit ang mga natukoy na patak bilang pulang bilog

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS matiyak na ang #size ng bilog ay tumutugma sa laki ng blangko blangko = np.zeros ((1,1)) blobs = cv2.drawKeypoints (imahe, keypoints, blangko, (0,255,255), cv2.DRAW_MATCHD_FAAG

Ipakita ang mga keypoint

cv2.imshow ('blobs', blobs) cv2.waitKey (0) cv2.destroyAllWindows ()

Kahit na ang code ay gumagana ng maayos ngunit ang ilan sa mga bloke ay napalampas dahil sa hindi pantay na laki ng mga bulaklak dahil ang mga bulaklak sa harap ay malaki kumpara sa mga bulaklak sa dulo.

9. Pag-filter ng mga Blobs - Nagbibilang ng mga Lupon at Elipses

Maaari naming gamitin ang mga parameter para sa pag-filter ng mga bloke ayon sa kanilang hugis, laki at kulay. Para sa paggamit ng mga parameter na may blob detector ginagamit namin ang pagpapaandar ng OpenCV

cv2.SimpleBlobDetector_Params ()

Makikita namin ang pag-filter ng mga patak sa pamamagitan ng pangunahin sa apat na mga parameter na nakalista sa ibaba:

Lugar

params.filterByArea = True / False params.minArea = pixel params.maxArea = pixel

Paikot

params.filterByCircularity = True / False params.minCircularity = 1 pagiging perpekto, 0 pagiging kabaligtaran

Convexity - Lugar ng patak / lugar ng convex hull

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

Inertia

params.filterByInertia = True / False params.minInertiaRatio = 0.01

Subukan nating i-filter ang mga patak sa pamamagitan ng nabanggit na mga parameter

import cv2 import numpy bilang np image = cv2.imread ('blobs.jpg') cv2.imshow ('orihinal na imahe', imahe) cv2.waitKey (0)

Pasimulan ang detektor gamit ang mga default na parameter

detector = cv2.SimpleBlobDetector_create ()

Makita ang mga patak

keypoints = detector.detect (imahe)

Gumuhit ng mga blob sa aming imahe bilang mga pulang bilog

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (imahe, keypoints, blangko, (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (keypoints) text = "total no of blobs" + str (len (keypoints)) cv2.putTxt (blobs, text, (20,550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100,0,255), 2)

Ipakita ang imahe na may mga block keypoint

cv2.imshow ('blob using default parameter', blobs) cv2.waitKey (0)

Itakda ang aming mga parameter ng pag-filter

#initialize ang setting ng parameter gamit ang cv2.SimpleBlobDetector params = cv2.SimpleBlobDetector_Params ()

Itakda ang mga parameter ng pag-filter ng lugar

params.filterByArea = Totoong mga params.minArea = 100

Itakda ang mga parameter ng pag-filter ng pabilog

params.filterByCircularity = True params.minCircularity = 0.9

Itakda ang parameter ng pag-filter ng convexity

params.filterByConvexity = Maling params.minConvexity = 0.2

Itakda ang parameter ng pag-filter ng inertia

params.filterByInertia = Totoong mga params.minInertiaRatio = 0.01

Lumikha ng detector na may parameter

detector = cv2.SimpleBlobDetector_create (params)

Makita ang mga patak

keypoints = detector.detect (imahe)

Gumuhit ng mga blob sa mga imahe bilang pulang bilog

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (imahe, keypoints, blangko, (0,255,0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (keypoints) text = "total no of circular blobs" + str (len (keypoints)) cv2.putTxt (blobs, text, (20,550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,100,255), 2)

Ipakita ang mga patak

cv2.imshow ('pag-filter ng mga pabilog na bloke', blobs) cv2.waitKey (0) cv2.destroyAllWindows ()

Kaya't ito ay kung paano magagawa ang paghihiwalay ng Imahe sa Python-OpenCV. Upang makakuha ng mahusay na understating ng computer vision at OpenCV, dumaan sa mga nakaraang artikulo (Pagsisimula sa Python OpenCV at Mga Manipulasyon ng Imahe sa Python OpenCV at magagawa mong gumawa ng isang bagay na cool sa Computer Vision.