Mga pagmamanipula ng imahe sa opencv (bahagi

Sa mga nakaraang tutorial, natutunan namin ang tungkol sa OpenCV at nagawa ang pangunahing pagproseso ng imahe at pagkatapos ay sa susunod na tutorial ay nagawa namin ang ilang pagmamanipula ng imahe sa OpenCV tulad ng pag-crop, pag-ikot, pagbabago ng imahe atbp. Kaya't sa pagpapatuloy ng nakaraang tutorial ng Manipulasyon ng Imahe, narito natutunan natin ilang higit pang mga diskarte sa pagmamanipula ng imahe tulad ng at sa pagtatapos ng tutorial magtatayo kami ng isang programa ng python-opencv upang makagawa ng live na sketch mula sa webcam live feed. Gumagamit ang application na ito ng marami sa mga pag-andar sa pagproseso ng Imahe na natutunan namin sa ngayon o matututunan sa tutorial na ito, kaya't ito ay magiging isang mahusay na praktikal na halimbawa upang masakop ang lahat ng mga pag-andar.

Tulad ng sinabi sa nakaraang tutorial, 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, system ng seguridad ng tahanan atbp.

Sa tutorial na ito, makakakita kami ng higit pang mga manipulasyong imahe gamit ang Python OpenCV. Malalaman natin dito na ilapat ang sumusunod na pagpapaandar sa isang imahe gamit ang Python OpenCV:

• Bitwise Operations at Masking
• Conbolusyon at Panlalabo
• Paghasa - Pagbabaliktad ng mga blur ng imahe
• Threshold (Binarization)
• Dilat, Erosion, Pagbubukas / Pagsasara
• Pagtuklas ng gilid at mga gradient ng Larawan
• Pananaw at Affine Transform
• Application ng Live Sketch

1. Bitwise Operations at Masking

Ang mga pagpapatakbo ng bitwise ay makakatulong sa iyo sa masking imahe at tumutulong sa iyo na lumikha ng ilang simpleng mga imahe.

Paggawa ng isang parisukat

i-import ang cv2 import numpy bilang np #we gumagamit lamang ng dalawang dimensyon dahil ito ay isang grayscale na imahe, kung gumagamit kami ng isang #colored na imahe, ginamit namin pagkatapos ang isang rektanggulo = np.zeros ((300,300,3), np.uint8) # Paggawa ng parisukat na parisukat = np.zeros ((300,300), np.uint8) cv2.rectangle (square, (50,50), (250,250), 255, -1) cv2.imshow ("square", square) cv2. waitKey (0)

Paggawa ng isang ellipse

ellipse = np.zeros ((300,300), np.uint8) cv2.ellipse (ellipse, (150,150), (150,150), 30,0,180,255, -1) cv2.imshow ("ellipse", ellipse) cv2.waitKey (0)

Pag-eksperimento sa kaunting pagpapatakbo

#AND_shows lamang kung saan magsalubong ang dalawa

BitwiseAND = cv2.bitwise_and (square, ellipse) cv2.imshow ("AND", BitwiseAND) cv2.waitKey (0)

#OR_shows lamang kung nasaan ang alinman sa parisukat o ellipse

BitwiseOR = cv2.bitwise_or (square, ellipse) cv2.imshow ("O", BitwiseOR) cv2.waitKey (0)

#XOR_shows lamang kung saan umiiral nang mag-isa

BitwiseXOR = cv2.bitwise_xor (square, ellipse) cv2.imshow ("XOR", BitwiseXOR) cv2.waitKey (0)

#NOT_shows lahat ng bagay na hindi bahagi ng ellipse at HINDI pagpapatakbo ay maaaring mailapat lamang sa solong figure

BitwiseNOT_elp = cv2.bitwise_not (ellipse) cv2.imshow ("NOT_ellipse", BitwiseNOT_elp) cv2.waitKey (0) cv2.destroyAllWindows ()

2. Convolution & Blurring

Ang isang convolution ay isang pagpapatakbo sa matematika na isinagawa sa dalawang pag-andar na gumagawa ng isang pangatlong pag-andar na karaniwang isang binagong bersyon ng orihinal na pag-andar.

Output na imahe = imahe Function _{laki ng Kernel}

Sa paningin ng computer ginagamit namin ang mga kernel upang tukuyin ang laki kung saan pinapatakbo namin ang aming pagmamanipula na function sa aming imahe.

Ang blurring ay isang operasyon kung saan average namin ang mga pixel sa loob ng isang rehiyon (Kernel)

Ang OpenCV ay nagpapalabas ng isang imahe sa pamamagitan ng paglalagay ng mga kernels, sasabihin sa iyo ng isang kernel kung paano baguhin ang halaga ng anumang naibigay na pixel sa pamamagitan ng pagsasama nito sa iba't ibang halaga ng mga kalapit na pixel na ang kernel ay inilapat sa bawat pixel sa imahe nang paisa-isa upang makabuo ng huling imahe.

Sa simpleng pagsasabi lamang, ang isang imahen na pagbubuo ay isang elemento ng matalinong pagpaparami ng dalawang mga matrice na sinusundan ng isang kabuuan.

Maaari lamang nating maunawaan ito sa pamamagitan ng sumusunod na halimbawa.

Ang nasa itaas ay isang 3X3 Kernel.

Nag-multiply kami ng 1/25 upang gawing normal ang hal sa 1 na nadaragdagan namin ang tindi o binabawasan ang tindi tulad ng sa kaso ng pag-brighten o pag-darkening ng mga imahe.

Subukan natin ang isang opencv blurring na paraan ng filter2D, na ibinigay ng pagpapaandar cv2.filter2D (imahe, -1, kernel)

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

#nilikha ang isang 3x3 kernel matrix

kernel_3x3 = np.ones ((3,3), np.float32) / 9

# Gumagamit kami ng cv2.filter2D upang umikot ang kernel na may isang imahe

malabo = cv2.filter2D (imahe, -1, kernel_3x3) cv2.imshow ('3x3_blurring', malabo) cv2.waitKey (0)

#nilikha ang isang 7x7 kernel matrix

kernel_7x7 = np.ones ((7,7), np.float32) / 49

# Gumagamit kami ng cv2.filter2D upang umikot ang kernel na may isang imahe

malabo = cv2.filter2D (imahe, -1, kernel_7x7) cv2.imshow ('7x7_blurring', malabo) cv2.waitKey (0) cv2.destroyAllWindows ()

Mayroong iba pang mga uri ng mga pamamaraang blurring din:

cv2.blur - Umaasa ang halaga sa isang tinukoy na window.

cv2.GaussianBlur - Katulad ngunit gumagamit ng isang window ng Gaussian (higit na binibigyang diin ang mga puntos sa paligid ng gitna).

cv2.medianBlur– Gumagamit ng panggitna ng lahat ng mga elemento sa window.

cv2.bilateralFilter– Naglalabas habang pinapanatili ang mga gilid na matalim, pinapanatili nito ang mga gilid at detalye ng linya.

Makikita namin isa-isa sa ibaba, ipakita muna ang orihinal na imahe gamit ang code sa ibaba:

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

cv2.blur:

Sa pamamaraang ito, ang pag-average ay ginagawa sa pamamagitan ng pag-ikot ng imahe gamit ang isang na-normalize na filter ng kahon, isinasagawa ang lugar sa ilalim ng kahon at pinalitan ang gitnang elemento. Dito ang laki ng kahon ay kailangang maging kakaiba at positibo .

# cv2.blur blur = cv2.blur (imahe, (3,3)) cv2.imshow ('Averaging', blur) cv2.waitKey (0)

cv2.GaussianBlur:

# cv2.GaussianBlur #sa halip ng filter ng kahon, subukan natin ang Gaussian kernel Gaussian = cv2.GaussianBlur (imahe, (7,7), 0) cv2.imshow ('Gaussian blurring', Gaussian) cv2.waitKey (0)

cv2.medianBlur:

Tumatagal ito sa gitna ng lahat ng mga pixel sa ilalim ng kernel area at ang sentral na elemento ay pinalitan ng halagang panggitna na ito.

# cv2.medianBlur # kumukuha ng panggitna sa lahat ng mga pixel sa ilalim ng lugar ng kernel at gitnang elemento # ay pinalitan ng halagang median na ito. median = cv2.medianBlur (imahe, 5) cv2.imshow ('median pag-blur', panggitna) cv2.waitKey (0)

cv2.bilateralFilter:

Ang bilateral ay napaka epektibo sa pag-aalis ng ingay habang pinapanatili ang mga gilid ng matalim

# cv2.bilateralFilter #Bilateral ay napaka epektibo sa pag-aalis ng ingay habang pinapanatili ang mga gilid ng matalim na bilateral = cv2.bilateralFilter (imahe, 9,75,75) cv2.imshow ('bilateral blurring', bilateral) cv2.waitKey (0) cv2. sirainAllWindows ()

Ang imahe ng De-noising-hindi Lokal ay nangangahulugang Denoising

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

#parameter pagkatapos Wala ang filter na lakas 'h' (5-10 ay isang mahusay na saklaw) # Susunod ay h para sa mga bahagi ng kulay, itinakda bilang parehong halaga bilang h muli

dst = cv2.fastNlMeansDenoisingColored (imahe, Wala, 6,6,7,21) cv2.imshow ('Mabilis na nangangahulugang denois', dst) cv2.waitKey (0) cv2.destroyAllWindows ()

Mayroong 4 na pagkakaiba-iba ng di-lokal na nangangahulugang denoising

cv2.fastNlMeansDenoising () - para sa solong kulay-abo na imaheng

cv2.fastNlMeansDenoisingColored () - Iisang kulay ng imahe

cv2.fastNlmeansDenoisingMulti () - para sa grayscale ng pagkakasunud-sunod ng imahe

cv2.fastNlmeansDenoisingcoloredMulti () - para sa kulay ng pagkakasunud-sunod ng imahe

3. Paghasa - Pagbabaliktad ng mga blur ng imahe

Ang paghasa ay kabaligtaran ng paglabo, nagpapalakas ito o binibigyang diin sa mga gilid ng imahe.

Kernel =,,

Ang aming kernel matrix ay sums hanggang sa isa, kaya hindi na kailangang gawing normal (ibig sabihin i-multiply ng isang kadahilanan sa parehong ningning tulad ng orihinal), kung ang kernel ay hindi na-normalize sa 1 ang imahe ay magiging mas maliwanag o madidilim.

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

kernel_sharpening = np.array (,

])

# paglalapat ng hasa ng kernel upang mag-input ng imahe

hasa = cv2.filter2D (imahe, -1, kernel_sharpening) cv2.imshow ('pinatalas na imahe', pinatalas) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Threshoding (Binarization)

Ang threshold ay kilos ng pag-convert ng isang imahe sa binary form. Sa opencv may hiwalay na pagpapaandar para sa threshold na tinukoy bilang

Cv2. Threshold (imahe, halaga ng threshold, Max na halaga, uri ng threshold)

May mga sumusunod na uri ng threshold:

• cv2.THRESH_BINARY - pinakakaraniwan
• cv2. THRESH_BINARY_INV - pinakakaraniwan
• cv2.THRESH_TRUNC
• cv2.THRESH_TOZERO
• cv2. THRESH_TOZERO_INV

TANDAAN: ang imahe ay kinakailangan upang mai-convert sa grayscale bago ang threshold

import cv2 import numpy bilang np #load image bilang grayscale image = cv2.imread ('gradient.jpg', 0) cv2.imshow ('original', image) cv2.waitKey (0)

# halaga sa ibaba 127 pumunta sa 0 (itim), at sa itaas 127 ay napupunta sa 255 (puti)

_, thresh1 = cv2. Threshold (imahe, 127,255, cv2.THRESH_BINARY) cv2.imshow ('1 threshold', thresh1) cv2.waitKey (0)

Ang # halaga sa ibaba 127 ay napupunta sa 255 at ang mga halagang higit sa 127 ay napupunta sa 0 (baligtad sa itaas)

_, thresh2 = cv2. Threshold (imahe, 127,255, cv2.THRESH_BINARY_INV) cv2.imshow ('2 threshold', thresh2) cv2.waitKey (0)

Ang #value sa itaas 127 ay pinutol (gaganapin) sa 127, ang 255 na argument ay hindi nagamit.

_, thresh3 = cv2. Threshold (imahe, 127,255, cv2.THRESH_TRUNC) cv2.imshow ('3 thresh trunc', thresh3) cv2.waitKey (0)

Ang mga # halaga sa ibaba 127 ay napupunta sa 0, sa itaas ng 127 ay hindi nagbabago

_, thresh4 = cv2. Threshold (imahe, 127,255, cv2.THRESH_TOZERO) cv2.imshow ('4 threshold', thresh4) cv2.waitKey (0)

Ang #Revesrse sa itaas, sa ibaba 127 ay hindi nabago, sa itaas 127 ay napupunta sa zero

_, thresh5 = cv2. Threshold (imahe, 127,255, cv2.THRESH_TOZERO_INV) cv2.imshow ('5 threshold', thresh5) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Dilat, Erosion, Pagbubukas / Pagsara

Ito ang mga pagpapatakbo sa larangan ng matematika na matematika

Paglawak - nagdaragdag ito ng mga pixel sa mga hangganan ng bagay sa isang imahe.

Erosion - Tinatanggal ang mga pixel sa mga hangganan ng bagay sa isang imahe.

Pagbubukas - pagguho sinundan ng dilat.

Pagsara - Paglawak na sinundan ng pagguho.

Ang pagbubukas ay lubos na kapaki-pakinabang sa pag-denoise ng mga imahe dahil ito ay unang naipis ang imahe sa pamamagitan ng pagguho (tinatanggal ang ingay) at pagkatapos ay pinalawak ito.

Ang pagkalito sa pagluwang at pagguho ng lupa

Minsan mayroong pagkalito sa pagitan ng pagluwang at pagguho ng karaniwang mga larawan na may puting background, tulad ng isinasaalang-alang ng opencv na puting background bilang imaheng nakalalala o nabura sa halip na orihinal na larawan, kaya sa kasong ito ang pagguho ay gumagana bilang pagluwang at kabaligtaran, tulad ng ipinakita sa sample ng imahe ipinapakita sa ibaba.

Tandaan, ang Dilation ay nagdaragdag ng mga pixel sa mga hangganan ng mga bagay sa isang imahe habang tinatanggal ng Erosion ang mga pixel sa mga hangganan ng mga bagay sa isang imahe

import cv2 import numpy bilang np image = cv2.imread ('imagecv.png', 0) cv2.imshow ('orihinal', imahe) cv2.waitKey (0)

#Erosion

# tukuyin natin ang laki ng ating kernel

kernel = np.ones ((5,5), np.uint8)

#ngayon naming nawasak ang imahe, narito ang pag-ulit na hindi sa mga oras na nais mong burahin ang imahe

pagguho = cv2.erode (imahe, kernel, pag-ulit = 1) cv2.imshow ('Erosion', erosion) cv2.waitKey (0)

#dilation

dilat = cv2.dilate (imahe, kernel, pag-ulit = 1) cv2.imshow ('dilation', dilation) cv2.waitKey (0)

# pagbubukas, Mabuti para sa pag-aalis ng ingay

pagbubukas = cv2.morphologyEx (imahe, cv2.MORPH_OPEN, kernel) cv2.imshow ('pagbubukas', pagbubukas) cv2.waitKey (0)

#close, Mabuti para sa pag-aalis ng ingay

pagsasara = cv2.morphologyEx (imahe, cv2.MORPH_CLOSE, kernel) cv2.imshow ('pagsasara', pagsasara) cv2.waitKey (0) cv2.destroyAllWindows ()

6. Edge detection at Image gradients

Napakahalagang lugar ng pagtuklas ng gilid sa paningin ng computer, lalo na kapag nakikipag-usap sa mga contour.

Ang mga gilid ay maaaring tukuyin bilang mga hangganan ng imahe, sa totoo lang ang mga ito ay mga gilid na tumutukoy sa bagay sa mga imahe na pinapanatili nila ang maraming impormasyon tungkol sa imahe.

Ang pormal na mga gilid ay maaaring tukuyin bilang biglaang mga pagbabago (discontinuities) sa isang imahe at maaari nilang i-encode ang maraming impormasyon tulad ng mga pixel.

Ipinapakita ng imahe sa itaas kung paano kinikilala at kinikilala ng paningin ng computer ang imahe.

Mga algorithm sa pagtuklas ng gilid: - Mayroong tatlong pangunahing uri ng mga algorithm ng pagtuklas ng gilid

• Sobel - upang bigyang-diin ang patayo o pahalang na mga imahe.
• Laplacian - pinakamainam dahil sa mababang rate ng error, mahusay na tinukoy na mga gilid at tumpak na pagtuklas.
• Ang algorithm ng pagtuklas ng Canny Edge (devolped ni john.F. Canny noong 1986)

1. Nalalapat ang Gaussian blur

2. Nakakakita ng intensity gradient ng imahe

3. naglalapat ng hindi maximum na pagpigil (ibig sabihin, tinatanggal ang mga pixel na hindi mga gilid).

4. Ang Hysteresis ay naglalapat ng threshold (ibig sabihin kung ang pixel ay nasa loob ng itaas at mas mababang threshold, ito ay isinasaalang-alang bilang isang gilid)

i-import ang cv2 import numpy bilang np image = cv2.imread ('input.jpg', 0) taas, lapad = image.shape

#sobel

# nag-aalis ng mga gilid ng sobel

sobel_x = cv2.Sobel (imahe, cv2.CV_64F, 0,1, ksize = 5) sobel_y = cv2.Sobel (imahe, cv2.CV_64F, 1,0, ksize = 5) cv2.imshow ('orihinal', imahe) cv2.waitKey (0) cv2.imshow ('sobelx', sobel_x) cv2.waitKey (0)

#Marahim

cv2.imshow ('sobely', sobel_y) cv2.waitKey (0)

sobel_OR = cv2.bitwise_or (sobel_x, sobel_y) cv2.imshow ('sobelOR', sobel_OR) cv2.waitKey (0)

#laplaian

laplacian = cv2.Laplacian (imahe, cv2.CV_64F) cv2.imshow ('Laplacian', laplacian) cv2.waitKey (0)

Ang #canny edge detection algorithm ay gumagamit ng mga gradient na halaga bilang mga threshold

# sa canny na kailangan namin upang magbigay ng dalawang mga halaga: threshold1 at threshold2.

#ng anumang gradient na mas malaki kaysa sa threshold 2 ay itinuturing na isang gilid.

#ng anumang gradient na mas malaki kaysa sa threshold 1 ay itinuturing na hindi isang gilid.

Ang # mga halaga sa pagitan ng threshold 1 at threshold 2 ay alinman sa gilid o hindi gilid

#sa kung paano nakakonekta ang kanilang mga intensidad, sa kasong ito ang anumang halaga sa ibaba 60 ay itinuturing na

#non edge wheareas anumang halaga sa itaas 120 ay itinuturing na mga gilid.

canny = cv2.Canny (imahe, 60,120) cv2.imshow ('canny', canny) cv2.waitKey (0) cv2.destroyAllWindows ()

14. Pagbabago ng Pananaw at Affine

Bumalik tayo at tingnan ang mga nagbabago at hindi lilitaw na pagbabago, ang orihinal na imahe na ipinakita sa ibaba ay malinaw na isang hindi affine na imahe habang ang mga gilid ay magtatagpo sa ilang mga punto gayunpaman, maaari nating ituwid ito sa pamamagitan ng pag-aaway at pagkuha ng pananaw magbago

Para sa pananaw na ito ibahin ang anyo kailangan namin ang apat na mga koordinasyon ng orihinal na imahe at pagkatapos ang apat na mga punto ng imahe ng output, ang mga ito ay tinukoy ng mga puntos_A at mga puntos_B Una sa tulong ng mga puntong ito ay nakakalkula namin ang isang transformation matrix, M sa tulong ng pagpapaandar ng getPerspectiveTransform.

At pagkatapos ang matrix na ito ay ibinibigay sa pagpapaandar ng warpPerspective upang makabuo ng pangwakas na output.

Ngayon subukan muna natin ang Perspective transform.

import cv2 import numpy as np import matplotlib.pyplot as plt image = cv2.imread ('paper.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

#coordinate ng 4 na sulok ng orihinal na imahe

puntos_A = np.float32 (,,,])

#coordinates ng 4 na sulok ng nais na output

# Gumagamit kami ng isang ratio ng isang papel na A4 1: 1.41

puntos_B = np.float32 (,,,])

# gamitin ang dalawang hanay ng dalawang puntos upang makalkula ang prespective transformation matrix, M

M = cv2.getPerspectiveTransform (puntos_A, puntos_B) warped = cv2.warpPerspective (imahe, M, (420,594)) cv2.imshow ('warpprespective', warped) cv2.waitKey (0) cv2.destroyAllWindows ()

Ang affine transform ay mas madali pagkatapos ng non-affine transform dahil kailangan natin ng tatlong puntos lamang upang makuha ang pagbabago. Ang buong proseso ay magkapareho ngunit sa halip na ibahin ang pananaw ay mayroon kaming affine transform at tinutukoy din namin ang mga col at row sa warpAffine mula sa pagpapaandar ng hugis sa halip na manu-manong ipasok ito.

import cv2 import numpy bilang np import matplotlib.pyplot bilang plt image = cv2.imread ('box.jpg') mga row, cols = image.shape cv2.imshow ('original', image) cv2.waitKey (0)

#coordinate ng 3 sulok ng orihinal na imahe

puntos_A = np.float32 (,,])

#coordinates ng 3 sulok ng nais na output

# Gumagamit kami ng isang ratio ng isang papel na A4 1: 1.41

puntos_B = np.float32 (,,])

# gamitin ang dalawang hanay ng dalawang puntos upang makalkula ang Affine

#transformation matrix, M

M = cv2.getAffineTransform (puntos_A, puntos_B) warped = cv2.warpAffine (imahe, M, (cols, row)) cv2.imshow ('warpaffine', warped) cv2.waitKey (0) cv2.destroyAllWindows ()

8. Application ng Live Sketch

Una sa lahat, batiin ang iyong sarili na nakagawa ka sa mini proyekto na ito pagkatapos basahin ang lahat ng mga pagpapaandar ng pagmamanipula ng imahe sa itaas. Kaya sa mini proyektong ito ng Python OpenCV matututunan natin ang ilang mga bagong konsepto ng mga loop at pag-andar. Kung pamilyar ka sa pagprograma, dapat kang magkaroon ng isang mas malawak na ideya kung ano ang pagpapaandar at mga loop. Gayunpaman, sa sawa ang pangunahing konsepto ng mga loop at pag-andar ay mananatiling pareho ngunit ang pamamaraan upang tukuyin ang mga ito ay nagbabago ng kaunti.

Kaya't sa pagsisimula ng program na ito maaari naming makita ang isang tiyak na pangkat ng mga pahayag na heading sa ilalim ng " def sketch (imahe): " ito ay isang pormal na kahulugan ng isang pagpapaandar isang pangkat ng mga pahayag na nagtutulungan para sa isang tiyak na kinalabasan.

Kaya't ang sketch na ito ay isang pagpapaandar, sa pag-andar ng sawa ay tinukoy ng "def" at nagtatapos sa isang markang ":". Gayundin ang mga pahayag na kinakailangan upang nasa loob ng pag-andar o maaari mong sabihin kung alin ang kinakailangan para sa paggana upang gumana nang maayos, ay awtomatikong nakahanay sa gilid ng pagpapaandar. Kaya upang lumabas sa mga pag-andar ang mga pahayag na kinakailangan upang ganap na iwanang nakahanay. Para sa karagdagang mga sanggunian maaari kang mag-refer sa google kung paano tinukoy ang mga pagpapaandar sa sawa.

Kaya sa pagpapaandar na sketch na ito ay ipinakilala namin ang maraming mga layer ng pagproseso ng imahe na pagsamahin nang magkasama upang magbigay ng isang output. Una, ang imahe ay ginawang grayscale upang madali itong maproseso ng opencv at pagkatapos ay mailapat ang isang Gaussian blur sa kulay-abo na imahe upang mabawasan ang ingay. Pagkatapos ang mga gilid ay nakuha sa tulong ng canny's edge detection algorithm pagkatapos ng isang binary inverse ay inilapat sa gilid na tinukoy na imahe, dito ang binary kabaligtaran ay maaaring gawin ng bitwise_NOT ngunit sadya naming pinili ang threshold na binary na kabaligtaran habang nagbibigay ito ng kalayaan upang maitakda ang mga parameter nito hanggang sa makakuha kami ng isang malinaw na imahe.

Gayundin upang tandaan na ang pagpapaandar ay tumatagal ng imahe ng mga argumento at ibabalik ang dalawang argument na ret at mask. Habang ang ret ay ang Boolean na nagsasabi na ang pagpapaandar ay matagumpay na natakbo o hindi at ang mask ay ang pangwakas na output ng pag-andar ie ang naprosesong imahe.

Pagkatapos ang pangalawang konsepto ay ang pagpapatakbo ng webcam sa opencv na ginagawa ng cv2. Ang pag- andar ng VideoCapture (0) , na nag-iimbak ng imahe sa isang cap ng bagay na ang cap ay maaaring mabasa na may cap.read () na pag- andar, narito din upang tandaan ang cap na iyon . ang read () ay nasa loob ng walang katapusang habang loop habang patuloy itong kailangang makuha ang mga imahe, upang bigyan ito ng isang live na video, kung saan ang rate rate ng video ay ang frame rate ng iyong webcam na karamihan ay nasa pagitan ng 24 hanggang 60 fps

Ang cap.read () ay nagbabalik ng ret at frame, kung saan ang ret ay ang Boolean na nagpapahiwatig na ang pagpapaandar ay matagumpay na natakbo o hindi at naglalaman ang frame ng imaheng kinunan ng webcam.

Nasa ibaba ang kumpletong Python OpenCV code para sa pagpapatakbo ng Live Sketch

i-import ang cv2 import numpy bilang np #sketch na bumubuo ng function def sketch (imahe): #convert image to grayscale img_gray = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) # paglilinis ng imahe gamit ang Gaussian blur img_gray_blur = cv2.GaussianBlur (img_gray, 5,5), 0) #extract edge canny_edges = cv2.Canny (img_gray_blur, 10,70) #gumawa ng isang invert na binarize ang ret ng imahe , mask = cv2. Threshold (canny_edges, 70,255, cv2.THRESH_BINARY_INV) return mask #initialize webcam, cap ang object na ibinigay ng video capture # Naglalaman ito ng isang Boolean na nagpapahiwatig kung ito ay matagumpay (ret) Naglalaman din ang # ng mga larawang nakolekta mula sa webcam (frame) cap = cv2.VideoCapture (0) habang True: ret, frame = cap.read () cv2.imshow ('livesketcher', sketch (frame)) kung cv2.waitKey (1) == 13: # 13 ang enterkey break #release camera at isara ang window, tandaan na bitawan ang webcam sa tulong ng cap.release () cap.release () cv2.destroyAllWindows ()

Kaya't ito ang pagtatapos ng Bahagi 2 ng mga manipulasyong Larawan sa Python-OpenCV. Upang makakuha ng magagandang understating ng computer vision at OpenCV, dumaan sa mga nakaraang artikulo (Pagsisimula sa Python OpenCV at Mga Manipulasyon ng Imahe sa Python OpenCV (Bahagi 1) at makakagawa ka ng isang bagay na cool sa Computer Vision.