Attēlu manipulācijas opencv (daļa

Iepriekšējās apmācībās mēs esam iemācījušies par OpenCV un paveikuši pamata attēlu apstrādi, un pēc tam nākamajā apmācībā mēs esam paveikuši dažas attēlu manipulācijas OpenCV, piemēram, apgriešanu, pagriešanu, attēlu pārveidošanu utt. Tātad, turpinot iepriekšējo Image Manipulation apmācību, šeit mēs mācāmies vēl daži attēlu manipulācijas paņēmieni, piemēram, un apmācības beigās mēs izveidosim programmu Python-Opencv, lai izveidotu tiešu skici no tīmekļa kameras tiešraides. Šajā lietojumprogrammā tiks izmantotas daudzas attēlu apstrādes funkcijas, kuras mēs esam iemācījušies līdz šim vai mācīsimies šajā apmācībā, tāpēc tas būs labs praktisks piemērs, lai aptvertu visas funkcijas.

Kā stāstīts iepriekšējā apmācībā, 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. Un 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 zīmes noteikšanu, mājas drošības sistēmu utt.

Šajā apmācībā mēs redzēsim vēl dažas attēlu manipulācijas, izmantojot Python OpenCV. Šeit mēs iemācīsimies izmantot šādu funkciju attēlam, izmantojot Python OpenCV:

• Operācijas pa bitiem un maskēšana
• Pārvēršana un izplūšana
• Asināšana - attēla maiņa tiek aizmiglota
• Sliekšņa noteikšana (binarizācija)
• Paplašināšanās, erozija, atvēršana / aizvēršana
• Malas noteikšana un attēla gradienti
• Perspektīva un Affine pārveidošana
• Live Sketch lietojumprogramma

1. Operācijas pa bitiem un maskēšana

Darbības ar bitiem palīdz jums maskēt attēlus un izveidot dažus vienkāršus attēlus.

Kvadrāta veidošana

importēt cv2 import numpy kā np # mēs izmantojam tikai divas dimensijas, jo tas ir pelēktoņu attēls, ja mēs izmantojām #krāsu attēlu, tad mēs izmantojām taisnstūri = np.zeros ((300,300,3), np.uint8) # Kvadrātveida kvadrāta izveidošana = np.zeros ((300,300), np.uint8) cv2. taisnstūris (kvadrāts, (50,50), (250,250), 255, -1) cv2.imshow ("kvadrāts", kvadrāts) cv2. waitKey (0)

Elipsijas veidošana

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

Eksperimentēšana ar bit bit operācijām

#AND_ parāda tikai tur, kur divi krustojas

BitwiseAND = cv2.bitwise_and (kvadrāts, elipse) cv2.imshow ("AND", BitwiseAND) cv2.waitKey (0)

# VAI_rāda tikai kvadrātu vai elipsi

BitwiseOR = cv2.bitwise_or (kvadrāts, elipse) cv2.imshow ("OR", BitwiseOR) cv2.waitKey (0)

#XOR_shows tikai tad, ja kāds no tiem pastāv pats

BitwiseXOR = cv2.bitwise_xor (kvadrāts, elipse) cv2.imshow ("XOR", BitwiseXOR) cv2.waitKey (0)

#NOT_parāda visu, kas nav elipses sastāvdaļa, un operāciju NEVAR piemērot tikai vienam skaitlim

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

2. Konversija un izplūdums

Sagriešana ir matemātiska operācija veikta divām funkcijām ražo trešā funkcija, kas parasti ir modificēta versija sākotnējo funkciju.

Izejas attēls = attēls Funkcija _{Kodola lielums}

Ar datoru redzējumu mēs izmantojam kodola ir norādīt izmēru pār kuru mēs vadām mūsu manipulējot funkciju pār mūsu attēlu.

Aizmiglošana ir darbība, kurā mēs vidēji aprēķinām pikseļus reģionā (kodols)

OpenCV aizmiglo attēlu, lietojot kodolus, kodols stāsta, kā mainīt jebkura konkrētā pikseļa vērtību, apvienojot to ar dažādu blakus esošo pikseļu daudzumu, kuru kodols tiek piemērots katram attēla pikseļam pa vienam, lai izveidotu galīgo attēlu.

Vienkārši sakot, attēla konvekcija ir vienkārši divu matricu reizinājums ar elementu, kam seko summa.

Mēs to vienkārši varam saprast, izmantojot šādu piemēru.

Iepriekš minētais ir 3X3 kodols.

Lai normalizētu, mēs reizinām ar 1/25, ti, summējot līdz 1, mēs esam palielinājuši intensitāti vai samazinājuši intensitāti tāpat kā attēlu spilgtuma vai tumšuma gadījumā.

Pieņemsim tests OpenCV nojauc metodi filter2D, ņemot vērā ar funkciju cv2.filter2D (attēla, -1, kodola)

importēt cv2 importēt numpy kā np image = cv2.imread ('elephant.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

# 3x3 kodola matricas izveide

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

# mēs izmantojam cv2.filter2D, lai savietotu kodolu ar attēlu

izplūdis = cv2.filter2D (attēls, -1, kodols_3x3) cv2.imshow ('3x3_blurring', izplūdis) cv2.waitKey (0)

# 7x7 kodola matricas izveide

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

# mēs izmantojam cv2.filter2D, lai savietotu kodolu ar attēlu

izplūdis = cv2.filter2D (attēls, -1, kodola_7x7) cv2.imshow ('7x7_blurring', izplūdis) cv2.waitKey (0) cv2.destroyAllWindows ()

Ir arī citi izplūšanas metožu veidi:

cv2.blur - vidējā vērtība virs norādītā loga.

cv2.GaussianBlur - līdzīgs, bet izmanto Gausa logu (lielāks uzsvars tiek likts uz punktiem ap centru).

cv2.medianBlur– izmanto visu loga elementu mediānu.

cv2.bilateralFilter - aizmiglo, vienlaikus saglabājot asas malas, tiek saglabātas malas un līnijas detaļas.

Mēs redzēsim pa vienam zemāk, vispirms parādiet sākotnējo attēlu, izmantojot zemāk esošo kodu:

importēt cv2 importēt numpy kā np image = cv2.imread ('elephant.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

cv2.blur:

Šajā metodē vidējā vērtēšana tiek veikta, savijot attēlu ar normalizētu lodziņa filtru, tas aizņem vietu zem lodziņa un aizstāj centrālo elementu. Šeit lodziņa izmēram jābūt nepāra un pozitīvam .

# cv2.blur blur = cv2.blur (attēls, (3,3)) cv2.imshow ('Vidējais vērtējums', izplūdums) cv2.waitKey (0)

cv2.Gaussian Blur:

# cv2.GaussianBlur # lodziņa filtra vietā izmēģināsim Gausa kodolu Gaussian = cv2.GaussianBlur (attēls, (7,7), 0) cv2.imshow ('Gaussian blurring', Gaussian) cv2.waitKey (0)

cv2.medianBlur:

Tas aizņem visu pikseļu mediānu zem kodola laukuma, un centrālais elements tiek aizstāts ar šo vidējo vērtību.

# cv2.medianBlur # ņem visu pikseļu mediānu zem kodola apgabala, un centrālais elements # tiek aizstāts ar šo vidējo vērtību. mediāna = cv2.medianBlur (attēls 5) cv2.imshow ("vidējais banalizēšana", mediāna) cv2.waitKey (0)

cv2.bilateralFilter:

Divpusējs ir ļoti efektīvs trokšņu noņemšanā, vienlaikus saglabājot asas malas

# cv2.bilateralFilter #Bilateral ir ļoti efektīvs trokšņu noņemšanā, vienlaikus saglabājot asas malas divpusējas = cv2.bilateralFilter (attēls, 9,75,75) cv2.imshow ('divpusējs izplūdums', divpusējs) cv2.waitKey (0) cv2. destrAllWindows ()

Attēla atturēšana bez lokāla nozīmē attīrīšana

importēt cv2 importēt numpy kā np image = cv2.imread ('elephant.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

#parameter pēc Neviens nav filtra stiprums 'h' (5-10 ir labs diapazons) #next ir h krāsu komponentiem, atkal iestatiet to pašu vērtību kā h

dst = cv2.fastNlMeansDenoisingColored (image, None, 6,6,7,21) cv2.imshow ('Fast nozīmē denois', dst) cv2.waitKey (0) cv2.destroyAllWindows ()

Ir 4 varianti, kas nav lokāli līdzekļi denoising

cv2.fastNlMeansDenoising () - vienam pelēka mēroga attēlam

cv2.fastNlMeansDenoisingColored () - vienkrāsains attēls

cv2.fastNlmeansDenoisingMulti () - attēlu secības pelēktoņiem

cv2.fastNlmeansDenoisingcoloredMulti () - krāsu secībai

3. Asināšana - attēla nomaiņa tiek mainīta atpakaļ

Asināšana ir pretēja izplūšanai, tā stiprina vai uzsver attēla malas.

Kodols =,,

Mūsu kodola matrica summējas līdz vienai, tāpēc nav nepieciešams normalizēt (ti, reizināt ar koeficientu līdz tādam pašam spilgtumam kā sākotnējam), ja kodols netiek normalizēts līdz 1, attēls būtu gaišāks vai tumšāks.

importēt cv2 importēt numpy kā np image = cv2.imread ('elephant.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

kernel_sharpening = np.array (,

])

#pielietojot asināšanas kodolu ievades attēlam

sharpened = cv2.filter2D (image, -1, kernel_sharpening) cv2.imshow ('asināts attēls', asināts) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Threshoding (binarizācija)

Sliekšņa noteikšana ir attēla pārveidošana binārā formā. Opencv ir atsevišķa sliekšņa noteikšanas funkcija, kas definēta kā

CV2. Slieksnis (attēls, sliekšņa vērtība, maksimālā vērtība, sliekšņa tips)

Ir šādi sliekšņu veidi:

• cv2.THRESH_BINARY - visbiežāk
• CV2. THRESH_BINARY_INV - visbiežāk
• cv2.THRESH_TRUNC
• cv2.THRESH_TOZERO
• CV2. THRESH_TOZERO_INV

PIEZĪME: attēls ir jāpārvērš pelēktoņos pirms sliekšņa noteikšanas

importēt cv2 importēt numpy kā np #load attēlu kā pelēktoņu attēlu = cv2.imread ('gradient.jpg', 0) cv2.imshow ('original', image) cv2.waitKey (0)

#value zem 127 pāriet uz 0 (melns), un virs 127 iet uz 255 (balts)

_, thresh1 = cv2.threshold (attēls, 127,255, cv2.THRESH_BINARY) cv2.imshow ('1 slieksnis', thresh1) cv2.waitKey (0)

#value zem 127 iet uz 255 un vērtības virs 127 iet uz 0 (reverss virs iepriekš)

_, thresh2 = cv2.threshold (attēls, 127,255, cv2.THRESH_BINARY_INV) cv2.imshow ('2 slieksnis', thresh2) cv2.waitKey (0)

#value virs 127 tiek saīsināts (aizturēts) pie 127, arguments 255 nav izmantots.

_, thresh3 = cv2.threshold (attēls, 127,255, cv2.THRESH_TRUNC) cv2.imshow ('3 thresh trunc ', thresh3) cv2.waitKey (0)

# vērtības zem 127 ir 0, virs 127 nemainās

_, thresh4 = cv2.threshold (attēls, 127,255, cv2.THRESH_TOZERO) cv2.imshow ('4 slieksnis', thresh4) cv2.waitKey (0)

#Revesrse no iepriekš, zem 127 ir nemainīgs, virs 127 iet uz nulli

_, thresh5 = cv2.threshold (attēls, 127,255, cv2.THRESH_TOZERO_INV) cv2.imshow ('5 slieksnis', thresh5) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Paplašināšanās, erozija, atvēršana / aizvēršana

Tās ir operācijas matemātiskās morfoloģijas jomā

Paplašināšana - tā pievieno pikseļus attēla objekta robežām.

Erozija - noņem pikseļus pie attēla objekta robežām.

Atvēršana - erozija, kurai seko dilatācija.

Noslēgums - paplašināšanās, kam seko erozija.

Atvēršana ir ļoti noderīga, lai attīrītu attēlus, jo vispirms tas tiek sabiezināts ar eroziju (noņem troksni) un pēc tam to paplašina.

Apjukums ar dilatāciju un eroziju

Dažreiz ir sajaukums starp dilatāciju un eroziju, parasti attēlos ar baltu fonu, jo opencv balto fonu uzskata par attēlu, kas ir paplašināts vai sabojāts, nevis oriģinālo attēlu, tāpēc šajā gadījumā erozija darbojas kā dilatācija un otrādi, kā parādīts attēla paraugā parādīts zemāk.

Atcerieties, ka Dilatācija pievieno pikseļus attēla objektu robežām, savukārt Erozija noņem pikseļus pie attēla objektu robežām

importēt cv2 importēt numpy kā np image = cv2.imread ('imagecv.png', 0) cv2.imshow ('oriģināls', attēls) cv2.waitKey (0)

# Erozija

# definēsim mūsu kodola lielumu

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

# tagad mēs graujam attēlu, šeit atkārtojums nav laiks, kad vēlaties izdzēst attēlu

erozija = cv2.erode (attēls, kodols, atkārtojumi = 1) cv2.imshow ('Erozija', erozija) cv2.waitKey (0)

# dilatācija

dilatācija = cv2.dilate (attēls, kodols, iterācijas = 1) cv2.imshow ('dilatācija', dilatācija) cv2.waitKey (0)

#opening, labi trokšņu noņemšanai

atvēršana = cv2.morphologyEx (attēls, cv2.MORPH_OPEN, kodols) cv2.imshow ('atvēršana', atvēršana) cv2.waitKey (0)

# aizverot, labi trokšņu noņemšanai

aizvēršana = cv2.morphologyEx (attēls, cv2.MORPH_CLOSE, kodols) cv2.imshow ('aizvēršana', aizvēršana) cv2.waitKey (0) cv2.destroyAllWindows ()

6. Malas noteikšana un attēla gradienti

Malas noteikšana ir ļoti svarīga joma datora redzējumā, it īpaši, ja tiek galā ar kontūrām.

Malas var definēt kā attēla robežas, patiesībā tās ir malas, kas attēla objektu definē, tādējādi saglabājot daudz informācijas par attēlu.

Formāli malas var definēt kā pēkšņas izmaiņas (pārtraukumus) attēlā, un tās var kodēt tikpat daudz informācijas kā pikseļi.

Iepriekš redzamais attēls parāda, kā datorvīzija identificē un atpazīst attēlu.

Malu noteikšanas algoritmi: - Ir trīs galvenie malu noteikšanas algoritmu veidi

• Sobel - uzsvars uz vertikāliem vai horizontāliem attēliem.
• Laplasijs - optimāls zemā kļūdu līmeņa, labi definētu malu un precīzas noteikšanas dēļ.
• Canny Edge noteikšanas algoritms (Džons F. F. Canny nodevis 1986. gadā)

1. Piemēro Gausa aizmiglojumu

2. Atrod attēla intensitātes gradientu

3. piemēro ne-maksimālu slāpēšanu (ti, noņem pikseļus, kas nav malas).

4. Histerēze piemēro slieksni (ti, ja pikseļi atrodas augšējā un apakšējā sliekšņa robežās, to uzskata par malu)

importēt cv2 importēt numpy kā np image = cv2.imread ('input.jpg', 0) height, width = image.shape

#obel

#izvelkot sobel malas

sobel_x = cv2.Sobel (attēls, cv2.CV_64F, 0,1, ksize = 5) sobel_y = cv2.Sobel (attēls, cv2.CV_64F, 1,0, ksize = 5) cv2.imshow ('oriģināls', attēls) cv2.waitKey (0) cv2.imshow ('sobelx', sobel_x) cv2.waitKey (0)

# Patiesi

cv2.imshow ('sobly', 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 (attēls, cv2.CV_64F) cv2.imshow ('Laplacian', laplacian) cv2.waitKey (0)

# canny mala noteikšanas algoritms izmanto sliekšņa vērtības kā

sliekšņus.

Jebkurš gradients, kas lielāks par 2. slieksni, tiek uzskatīts par malu.

Jebkurš gradients, kas lielāks par 1. slieksni, netiek uzskatīts par malu.

# vērtības starp 1. un 2. slieksni ir vai nu kā malas, vai bez malas

# par to, kā to intensitāte ir savienota, šajā gadījumā jebkura vērtība, kas zemāka par 60, tiek uzskatīta par

# nav malām, un jebkura vērtība, kas pārsniedz 120, tiek uzskatīta par malām.

canny = cv2.Canny (attēls, 60,120) cv2.imshow ('canny', canny ) cv2.waitKey (0) cv2.destroyAllWindows ()

14. Perspektīva un afinitātes pārveidošana

Sāksim soli atpakaļ un apskatīsim afīniskās un bezfīniskās transformācijas. Zemāk redzamais oriģinālais attēls nepārprotami ir nemainīgs attēls, jo malas kādā brīdī saskarsies, tomēr mēs to varam iztaisnot, deformējot un skatoties perspektīvā pārveidot.

Šai perspektīvas transformācijai mums ir vajadzīgas četras sākotnējā attēla koordinātas un pēc tam četri izejas attēla punkti, tos apzīmē ar punktiem_A un punktiem_B Pirmkārt, ar šo punktu palīdzību mēs aprēķinām transformācijas matricu M ar funkciju getPerspectiveTransform palīdzību .

Un tad šī matrica tiek piešķirta funkcijai warpPerspective, lai ģenerētu galīgo izvadi.

Tagad vispirms izmēģināsim perspektīvas pārveidošanu.

importēt cv2 importēt numpy kā np importēt matplotlib.pyplot kā plt image = cv2.imread ('paper.jpg') cv2.imshow ('oriģināls', attēls) cv2.waitKey (0)

# sākotnējā attēla 4 stūru koordināta

punkti_A = np.flot32 (,,,])

# vēlamās izejas 4 stūru

koordinātas # mēs izmantojam A4 formāta papīra attiecību 1: 1,41

punkti_B = np.flot32 (,,,])

# izmantojiet divu punktu divus kopas, lai aprēķinātu priekšnoteikuma transformācijas matricu M

M = cv2.getPerspectiveTransform (points_A, points_B) warped = cv2.warpPerspective (image, M, (420 594)) cv2.imshow ('warpprespective', warped) cv2.waitKey (0) cv2.destroyAllWindows ()

Affine transformācija ir vieglāka nekā non-affine transformācija, jo mums ir nepieciešami tikai trīs punkti, lai iegūtu transformāciju. Viss process notiek vienādi, bet perspektīvās transformācijas vietā mums tagad ir afīna transformācija, kā arī mēs definējam kolonnas un rindas warpAffine no formas funkcijas, nevis manuāli ievadām to.

importēt cv2 importēt numpy kā np importēt matplotlib.pyplot kā plt image = cv2.imread ('box.jpg') rindas, cols = image.shape cv2.imshow ('oriģināls', attēls) cv2.waitKey (0)

# sākotnējā attēla 3 stūru koordināta

punkti_A = np. pludiņš32 (,,])

# vēlamās izejas 3 stūru

koordinātas # mēs izmantojam A4 formāta papīra attiecību 1: 1,41

punkti_B = np.flot32 (,,])

# izmantojiet divu punktu divus kopas, lai aprēķinātu Affine

# transformācijas matricu M

M = cv2.getAffineTransform (points_A, points_B) warped = cv2.warpAffine (image, M, (cols, rows)) cv2.imshow ('warpaffine', warped) cv2.waitKey (0) cv2.destroyAllWindows ()

8. Live Sketch lietojumprogramma

Pirmkārt, apsveiciet sevi, ka esat izveidojis šo mini projektu pēc visu iepriekšminēto attēlu manipulācijas funkciju izlasīšanas. Tātad šajā Python OpenCV mini projektā mēs apgūsim dažus jaunus cilpu un funkciju jēdzienus. Ja esat pārzinis programmēšanu, jums ir jābūt plašākam priekšstatam par to, kāda ir funkcija un cilpas. Tomēr pitonā cilpu un funkciju pamatjēdziens paliek nemainīgs, bet metode to definēšanai nedaudz mainās.

Tātad šīs programmas sākumā mēs varam redzēt noteiktu paziņojumu grupu, kas atrodas sadaļā “ def skice (attēls) ”: šī ir formāla funkcijas definīcija, kurai paziņojumu grupa strādā kopā ar noteiktu izvadi.

Tātad šī skice ir funkcija, pitonā funkcija tiek definēta ar “def” un beidzas ar atzīmi “:”. Arī paziņojumi, kuriem jābūt funkcijas iekšpusē, vai jūs varat pateikt, kas nepieciešami, lai funkcija darbotos pareizi, funkcija ir automātiski izlīdzināta sānos. Tātad, lai iznāktu no funkcijām, paziņojumiem bija jābūt pilnīgi kreisiem. Papildu atsauces varat meklēt vietnē google par to, kā funkcijas tiek definētas pitonā.

Tātad šajā skices funkcijā mēs esam ieviesuši vairākus attēlu apstrādes slāņus, kas apvienojas, lai iegūtu rezultātu. Pirmkārt, attēls tiek pārveidots pelēktoņos, lai opencv to varētu viegli apstrādāt, un pēc tam pelēkā skalas attēlam tiek piemērots Gausa izplūdums, lai samazinātu troksni. Pēc tam malas tiek iegūtas ar canny's malu noteikšanas algoritma palīdzību, tad uz malas definētā attēla tiek pielietota binārā inversija, šeit bināro inversu varēja izdarīt arī bitwise_NOT, bet mēs apzināti izvēlējāmies šo sliekšņa bināro inversu, jo tas dod brīvību lai iestatītu tā parametrus, līdz iegūstam skaidru attēlu.

Jāņem vērā arī tas, ka funkcija uzņem argumentu attēlu un atgriež abus argumentus ret un mask. Kamēr ret ir Būla teiktais, ka funkcija tiek veiksmīgi palaista vai nē, un maska ​​ir funkcijas, ti, apstrādātā attēla, galīgā izeja.

Tad otrais jēdziens ir tīmekļa kameras darbība opencv, ko veic cv2. VideoCapture (0) funkcija, kas attēlu saglabā objekta vāciņā, kuru vāciņu var nolasīt ar cap.read () funkciju, arī šeit, lai atzīmētu šo vāciņu. read () atrodas bezgalīgajā ciklā, jo tam nepārtraukti vajadzēja uzņemt attēlus, lai radītu tiešraides sajūtu, kur video kadru ātrums būtu jūsu tīmekļa kameras kadru ātrums, kas pārsvarā ir no 24 līdz 60 kadri sekundē.

cap.read () atgriež ret un kadru, kur ret ir Būla skaitlis, kas norāda, ka funkcija ir veiksmīgi izpildīta vai nē, un rāmis satur tīmekļa kameras uzņemto attēlu.

Zemāk ir pilns Python OpenCV kods, lai palaistu Live Sketch

imports CV2 importa numpy kā NP #sketch ražošanas funkcija def skice (attēls): #convert attēlu pelēktoņu img_gray = cv2.cvtColor (attēla, cv2.COLOR_BGR2GRAY) #cleaning veido attēlu, izmantojot Gausa aizmiglot img_gray_blur = cv2.GaussianBlur (img_gray (5,5), 0) #extract malas canny_edges = cv2.Canny (img_gray_blur, 10,70) # do invertu binarizēt attēlu ret, mask = cv2.threshold (canny_edges, 70,255, cv2.THRESH_BINARY_INV) atgriezties masku #initialize webcam, vāciņš ir, ko nodrošina objekta video tveršanas #it satur Būla norādot, ja tas ir bijis veiksmīgs (ret) # it satur arī attēlus, kas savākti no tīmekļa kameras (rāmis) cap = cv2.VideoCapture (0), bet True: ret, frame = cap.read () cv2.imshow ('livesketcher', skice (rāmis)) if cv2.waitKey (1) == 13: # 13 ir ievadatslēgu pārtraukums # atbrīvojiet kameru un aizveriet logu. Atcerieties atbrīvot tīmekļa kameru ar cap.release () cap.release () cv2.destroyAllWindows () palīdzību

Tātad tas ir attēlu manipulāciju Python-OpenCV 2. daļas beigas. 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ācijas Python OpenCV (1. daļa)), un jūs varēsit izveidot kaut ko foršu ar Computer Vision.