Képmanipulációk az opencv-ben (rész

Az előző oktatóprogramokban megtanultuk az OpenCV-t és elvégeztünk néhány alapvető képfeldolgozást, majd a következő oktatóanyagban elvégeztünk néhány képmanipulációt az OpenCV-ben, például vágás, forgatás, képtranszformáció stb. Tehát a korábbi Image Manipulation oktatóanyag folytatásaként itt megtudjuk néhány további képmanipulációs technika, például, és az oktatóanyag végén felépítünk egy python-opencv programot, amely élő vázlatot készít a webkamera élő hírcsatornájából. Ez az alkalmazás számos olyan képfeldolgozási funkciót fog használni, amelyeket eddig megtanultunk vagy ebben az oktatóanyagban megtanulunk, így ez jó gyakorlati példa lesz az összes funkció lefedésére.

Amint azt az előző bemutatóban elmondtuk, az OpenCV egy Open Source Commuter Vision Library, amely C ++, Python és Java felülettel rendelkezik, és támogatja a Windows, Linux, Mac OS, iOS és Android rendszereket. Így könnyen telepíthető a Raspberry Pi-be Python és Linux környezettel. Az OpenCV-vel és a csatlakoztatott kamerával rendelkező Raspberry Pi sok valós idejű képfeldolgozó alkalmazás létrehozására használható, például Arcfelismerés, Arczár, Objektumkövetés, Autószámtábla-felismerés, Otthoni biztonsági rendszer stb.

Ebben az oktatóanyagban további képmanipulációkat fogunk látni a Python OpenCV használatával. Itt megtanuljuk a következő függvény alkalmazását egy képen a Python OpenCV használatával:

• Bitenkénti műveletek és maszkolás
• Konvolúció és elmosódás
• Élesítés - A kép megfordítása elmosódik
• Küszöbérték (binárisítás)
• Tágulás, erózió, nyitás / zárás
• Élérzékelés és képátmenet
• Perspektíva és affin transzformáció
• Élő vázlat alkalmazás

1. Bitenkénti műveletek és maszkolás

A bitenkénti műveletek segítenek a kép maszkolásában és egyszerű képek létrehozásában.

Négyzet készítése

import cv2 import numpy as np # csak két dimenziót használunk, mert ez egy szürkeárnyalatos kép, ha #colored képet használtunk, akkor egy téglalapot = np.zeros ((300,300,3), np.uint8) # Négyzet alakú négyzet készítése = np.zeros ((300,300), np.uint8) cv2.téglalap (négyzet, (50,50), (250,250), 255, -1) cv2.imshow ("négyzet", négyzet) cv2. waitKey (0)

Ellipszis készítése

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

Kísérletezés bitenkénti műveletekkel

#AND_ csak ott mutat, ahol a kettő metszi

BitenkéntAND = cv2.bitwise_and (négyzet, ellipszis) cv2.imshow ("ÉS", BitirányosanAND) cv2.waitKey (0)

# VAGY csak ott jelenik meg, ahol négyzet vagy ellipszis van

Bitwise OR = cv2.bitwise_or (négyzet, ellipszis) cv2.imshow ("OR", BitwiseOR) cv2.waitKey (0)

#XOR_show csak ott, ahol bármelyik önmagában létezik

BitwiseXOR = cv2.bitwise_xor (négyzet, ellipszis) cv2.imshow ("XOR", BitwiseXOR) cv2.waitKey (0)

#NOT_mutat mindent, ami nem része az ellipszisnek, és a NEM művelet csak egyetlen ábrára alkalmazható

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

2. Konvolúció és elmosódás

A konvolúció két olyan függvényen végrehajtott matematikai művelet, amely egy harmadik függvényt eredményez, amely általában az eredeti függvény módosított változata.

Kimeneti kép = kép Funkció _{Kernel mérete}

A számítógépes látásmódban a kernel segítségével meghatározhatjuk, hogy a képen mi felett milyen méretben futtatjuk a manipuláló funkciót.

Az elmosódás egy olyan művelet, amelyben átlagoljuk a pixeleket egy régión belül (Kernel)

Az OpenCV elmosódik a kép a kernelek alkalmazásával, a kern megmondja, hogyan változtathatja meg az adott pixel értékét úgy, hogy egyesíti azt a szomszédos pixelek különböző mennyiségével, amelyet a kern a kép minden pixelére egyenként alkalmaz, hogy elkészítse a végső képet.

Egyszerűen szólva: a képkonvolúció egyszerűen két mátrix elemből álló szorzata, amelyet egy összeg követ.

Egyszerűen megérthetjük a következő példával.

A fenti egy 3X3-as kernel.

A normalizáláshoz 1/25-tel szorozzuk, azaz összegezzük 1-re, mi növeltük az intenzitást vagy csökkentettük az intenzitást, mint a képek világosabbá vagy sötétebbé válása esetén.

Teszteljünk egy opencv elmosódási módszer szűrőt2D, amelyet a cv2.filter2D (kép, -1, kernel) függvény ad meg

import cv2 import numpy as np image = cv2.imread ('elephant.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

# 3x3-as kernelmátrix létrehozása

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

# a cv2.filter2D segítségével konvertáljuk a kernelt egy képpel

elmosódott = cv2.filter2D (kép, -1, kernel_3x3) cv2.imshow ('3x3_blurring', elmosódott) cv2.waitKey (0)

# 7x7 magmátrix létrehozása

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

# a cv2.filter2D segítségével konvertáljuk a kernelt egy képpel

elmosódott = cv2.filter2D (image, -1, kernel_7x7) cv2.imshow ('7x7_blurring', homályos) cv2.waitKey (0) cv2.destroyAllWindows ()

Vannak más típusú elmosódási módszerek is:

cv2.blur - Átlagolja az értéket egy megadott ablak felett.

cv2.GaussianBlur - Hasonló, de Gauss-ablakot használ (nagyobb hangsúlyt kap a középpont körüli pontokra).

cv2.medianBlur– Az ablak összes elemének mediánját használja.

cv2.bilateralFilter– Elmosódik, miközben élesen tartja az éleit, megőrzi az éleket és a vonal részleteit.

Látni fogjuk egyesével lentebb, először jelenítsük meg az eredeti képet az alábbi kód használatával:

import cv2 import numpy as np image = cv2.imread ('elephant.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

cv2.blur:

Ebben a módszerben az átlagolás a kép normalizált dobozszűrővel történő összevonásával történik, ez átveszi a helyet a doboz alatt, és helyettesíti a központi elemet. Itt a doboz méretének furcsának és pozitívnak kell lennie .

# cv2.blur blur = cv2.blur (kép, (3,3)) cv2.imshow ('Átlagolás, elmosódás) cv2.waitKey (0)

cv2.GaussianBlur:

# cv2.GaussianBlur # a dobozszűrő helyett próbáljuk meg a Gaussian kernelt Gaussian = cv2.GaussianBlur (kép, (7,7), 0) cv2.imshow ('Gaussian blurring', Gaussian) cv2.waitKey (0)

cv2.medianBlur:

A kernelterület alatti összes pixel mediánja, és a középső elem ezzel a mediánértékkel lesz helyettesítve.

# cv2.medianBlur # az összes pixel mediánját veszi fel a kernelterület alatt, és a # központi elemet ezzel a mediánértékkel helyettesítjük. medián = cv2.medianBlur (kép, 5) cv2.imshow ('median elmosódás', medián) cv2.waitKey (0)

cv2.bilateralFilter:

A kétoldalú nagyon hatékony a zajeltávolításban, miközben élesen tartja az éleit

# cv2.bilateralFilter # A kétoldalú nagyon hatékony a zajeltávolításban, miközben élesen tartja a széleit kétoldalú = cv2.bilateralFilter (kép, 9,75,75) cv2.imshow ('kétoldalú elmosódás', kétoldalú) cv2.waitKey (0) cv2. destrAllWindows ()

Image No-noising-non Local azt jelenti, hogy denoising

import cv2 import numpy as np image = cv2.imread ('elephant.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

#parameter a Nincs után a szűrő erőssége 'h' (5-10 jó tartomány) #next a h a színkomponenseknél, állítsa be ugyanazt az értéket, mint megint h

dst = cv2.fastNlMeansDenoisingColored (image, None, 6,6,7,21) cv2.imshow ('Gyors azt jelenti, hogy denois', dst) cv2.waitKey (0) cv2.destroyAllWindows ()

A nem lokális eszközöknek 4 változata van denoising

cv2.fastNlMeansDenoising () - egyetlen szürkeárnyalatos képhez

cv2.fastNlMeansDenoisingColored () - Egyszínű kép

cv2.fastNlmeansDenoisingMulti () - képsorrend szürkeárnyalatos

cv2.fastNlmeansDenoisingcoloredMulti () - színes képsorrendhez

3. Élesítés - A kép megfordítása elmosódik

Az élesítés ellentétes az elmosódással, erősíti vagy hangsúlyozza a kép széleit.

Kernel =,,

A kernelmátrixunk összegez egyet, így nincs szükség normalizálásra (azaz szorzótényezővel meg kell szorozni ugyanolyan fényerőre, mint az eredeti), ha a kernelt nem normalizáljuk 1-re, akkor a kép világosabb vagy sötétebb lesz.

import cv2 import numpy as np image = cv2.imread ('elephant.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

kernel_sharpening = np.array (,

])

# élesítő kern alkalmazása a bemeneti képhez

élesített = cv2.filter2D (image, -1, kernel_sharpening) cv2.imshow ('élesített kép', élesített) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Threshoding (binárisítás)

A küszöbérték a kép bináris formába konvertálása. Az opencv-ben a küszöbérték külön funkciója van definiálva

Cv2.threshold (kép, küszöbérték, Max érték, küszöb típus)

A következő küszöbtípusok vannak:

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

MEGJEGYZÉS: a kép át kell alakítani szürkeárnyalatosvá a küszöbérték megadása előtt

import cv2 import numpy as np #load image as szürkeárnyalatos image = cv2.imread ('gradient.jpg', 0) cv2.imshow ('original', image) cv2.waitKey (0)

A # 127 alatti érték 0-ra megy (fekete), és 127 felett 255-re (fehér)

_, thresh1 = cv2.threshold (kép, 127,255, cv2.THRESH_BINARY) cv2.imshow ('1 küszöb', thresh1) cv2.waitKey (0)

A # 127 alatti érték 255-re, a 127 feletti érték pedig 0-ra megy (a fenti fordítottja)

_, thresh2 = cv2.küszöb (kép, 127,255, cv2.THRESH_BINARY_INV) cv2.imshow ('2 küszöb', thresh2) cv2.waitKey (0)

A 127 feletti # értéket 127-nél csonkolják (tartják), a 255-ös argumentum nincs használatban.

_, thresh3 = cv2.threshold (kép, 127,255, cv2.THRESH_TRUNC) cv2.imshow ('3 thresh trunc ', thresh3) cv2.waitKey (0)

A # 127 alatti értékek 0-ra mennek, a 127 felett változatlanok

_, thresh4 = cv2.threshold (kép, 127,255, cv2.THRESH_TOZERO) cv2.imshow ('4 küszöb', thresh4) cv2.waitKey (0)

A #Revesrse értéke 127 alatt változatlan, a 127 felett nullára megy

_, thresh5 = cv2.threshold (kép, 127,255, cv2.THRESH_TOZERO_INV) cv2.imshow ('5 küszöb', thresh5) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Tágulás, erózió, nyitás / zárás

Ezek a műveletek a matematikai morfológia területén

Dilatáció - pixeleket ad hozzá a képen lévő objektum határaihoz.

Erózió - Eltávolítja a képpontokat az objektum határainál.

Nyitás - erózió, majd dilatáció.

Zárás - tágulás, majd erózió.

A felbontás nagyon hasznos a képek zsírtalanításában, mivel először erózióval elvékonyítja a képet (eltávolítja a zajt), majd kitágítja.

Összetévesztés dilatációval és erózióval

Néha összetévesztés van a dilatáció és az erózió között általában fehér háttérrel rendelkező képeknél, mivel az opencv a fehér hátteret tágított vagy erodált képnek tekinti az eredeti kép helyett, ezért ebben az esetben az erózió dilatációként működik, és fordítva, ahogy a képminta mutatja lásd alább.

Ne feledje, hogy a tágulás pixeleket ad hozzá a képen lévő objektumok határaihoz, míg az Erosion eltávolítja a képpont objektumainak határain lévő képpontokat

import cv2 import numpy as np image = cv2.imread ('imagecv.png', 0) cv2.imshow ('original', image) cv2.waitKey (0)

# Erózió

# definiáljuk a kernel méretét

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

#most leromboljuk a képet, itt az iteráció nem olyan gyakran van, amikor meg akarja rontani a képet

erózió = cv2.erode (kép, kernel, iterációk = 1) cv2.imshow ('Erózió', erózió) cv2.waitKey (0)

#tágulás

dilatáció = cv2.dilate (kép, kernel, iterációk = 1) cv2.imshow ('dilation', dilation) cv2.waitKey (0)

#opening, Jó a zaj eltávolítására

nyitás = cv2.morphologyEx (kép, cv2.MORPH_OPEN, kernel) cv2.imshow ('nyitás', nyitás) cv2.waitKey (0)

# bezárás, jó a zaj eltávolítására

záró = cv2.morphologyEx (kép, cv2.MORPH_CLOSE, kernel) cv2.imshow ('zárás', zárás) cv2.waitKey (0) cv2.destroyAllWindows ()

6. Élfelismerés és képátmenet

Az élérzékelés nagyon fontos terület a számítógépes látásban, különösen a kontúrok kezelésekor.

Az élek a kép határaként definiálhatók, valójában élek, amelyek meghatározzák az objektumot a képeken, és rengeteg információt megőriznek a képről.

Az Edges formálisan a kép hirtelen változásaként (folytonosságokként) határozható meg, és annyi információt kódolhatnak, mint pixelek.

A fenti kép azt mutatja, hogy a számítógépes látás hogyan azonosítja és ismeri fel a képet.

Élfelismerő algoritmusok: - Az élfelismerő algoritmusoknak három fő típusa van

• Sobel - a függőleges vagy vízszintes képek hangsúlyozására.
• Laplacian - optimális az alacsony hibaarány, a jól meghatározott élek és a pontos érzékelés miatt.
• Canny Edge detektáló algoritmus (John F. F. Canny átterjesztette 1986-ban)

1. Gauss-féle elmosódást alkalmaz

2. Megtalálja a kép intenzitási gradiensét

3. nem maximális elnyomást alkalmaz (azaz eltávolítja azokat a képpontokat, amelyek nem élek).

4. A hiszterézis küszöböt alkalmaz (azaz ha a képpont a felső és az alsó küszöbön belül van, akkor az élnek tekinthető)

import cv2 import numpy as np image = cv2.imread ('input.jpg', 0) magasság, szélesség = image.shape

#sobel

# sobel élek kivonása

sobel_x = cv2.Sobel (kép, cv2.CV_64F, 0,1, ksize = 5) sobel_y = cv2.Sobel (kép, cv2.CV_64F, 1,0, ksize = 5) cv2.imshow ('eredeti', kép) cv2.waitKey (0) cv2.imshow ('sobelx', sobel_x) cv2.waitKey (0)

#Sobely

cv2.imshow ('józanul', 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 (kép, cv2.CV_64F) cv2.imshow ('Laplacian', laplacian) cv2.waitKey (0)

A # canny edge Detection algoritmus gradiens értékeket használ

küszöbértékként.

# a 2. küszöbnél nagyobb gradiens élnek tekinthető.

Az # küszöböt meghaladó gradiens nem tekinthető élnek.

#values között 1-es küszöbérték és a küszöbérték 2 közül vagy a szélén vagy nem él

#on milyen a intenzitások vannak kötve, ebben az esetben bármilyen érték 60 alatt van tekinthetők

#non élek wheareas bármilyen érték meghaladja a 120 minősülnek élek.

canny = cv2.Canny (kép, 60,120) cv2.imshow ('canny', canny ) cv2.waitKey (0) cv2.destroyAllWindows ()

14. Perspektíva és affin transzformáció

Tegyünk egy lépést hátra, és vessünk egy pillantást az affin és a nem affin transzformációkra. Az alább látható eredeti kép egyértelműen nem affin kép, mivel az élek egy ponton találkoznak, azonban megvethetjük vetemedéssel és a perspektívával átalakul.

Ehhez a perspektivikus transzformációhoz szükségünk van az eredeti kép négy koordinátájára, majd a kimeneti kép négy pontjára, ezeket pontok_A és pontok_B jelölik. Először ezen pontok segítségével számoljuk ki az M transzformációs mátrixot a getPerspectiveTransform függvény segítségével .

Ezután ezt a mátrixot kapja a warpPerspective függvény a végső kimenet előállításához.

Most először próbáljuk ki a Perspektíva transzformációt.

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

# koordinátája az eredeti kép 4 sarkának

pontok_A = np. float32 (,,,])

# a kívánt kimenet 4 sarkának

koordinátái # egy A4-es papír 1: 1,41 arányát használjuk

pontok_B = np. float32 (,,,])

# használja a két pont két halmazát az elõrejelezõ transzformációs mátrix, M kiszámításához

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

Az affin transzformáció könnyebb, mint a nem affin transzformáció, mivel csak három pontra van szükségünk a transzformáció megszerzéséhez. Az egész folyamat ugyanúgy megy, de a perspektivikus transzformáció helyett most affin transzformációnk van, és definiálunk oszlopokat és sorokat a warpAffine -ban az alak függvényből ahelyett, hogy kézzel adnánk meg.

import cv2 import numpy as np import matplotlib.pyplot as plt image = cv2.imread ('box.jpg') sorok, cols = image.shape cv2.imshow ('eredeti', image) cv2.waitKey (0)

# koordinátája az eredeti kép 3 sarkának

points_A = np. float32 (,,])

# a kívánt kimenet 3 sarkának

koordinátái # egy A4-es papír 1: 1,41 arányát használjuk

points_B = np. float32 (,,])

# használja a két pont két halmazát az Affine # transzformációs mátrix, M kiszámításához

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

8. Élő vázlat alkalmazás

Először is gratuláljon magának, hogy elkészítette ezt a mini projektet, miután elolvasta a fenti képmanipulációs funkciókat. Tehát a Python OpenCV ebben a mini projektjében megtanulunk néhány új fogalmat a hurkokról és a függvényekről. Ha ismeri a programozást, tágabb elképzeléssel kell rendelkeznie arról, hogy mi a funkció és a hurkok. A pythonban azonban a hurkok és a függvények alapfogalma ugyanaz marad, de a meghatározásuk módja kissé megváltozik.

Tehát ennek a programnak a kezdetekor láthatunk egy bizonyos állításcsoportot a „ def vázlat (kép) ” alatt : ez egy formális definíciója annak a függvénynek, amelynek egy állításcsoport együtt dolgozik egy bizonyos kimeneten.

Tehát ez a vázlat egy függvény, a pythonban a függvényt def definiálja, és egy „:” jellel végződik. Azok az állítások, amelyeknek a függvényen belül kell lenniük, vagy mondhatjuk, amelyek szükségesek a függvény megfelelő működéséhez, automatikusan függesztésre kerülnek a függvény által. Tehát a függvényekből való kilépéshez a kijelentéseket teljesen balra kellett igazítani. A további hivatkozásokért tekintse meg a google-t, hogy miként definiálják a függvényeket a pythonban.

Tehát ebben a vázlatfunkcióban a képfeldolgozás több rétegét vezettük be, amelyek együttesen adnak kimenetet. Először is, a képet szürkeárnyalattá alakítják, így az opencv könnyedén feldolgozhatja, majd egy Gauss-féle elmosódást alkalmaznak a szürkeárnyalatos képre a zaj csökkentése érdekében. Ezután az éleket kinyerjük a canny éldetektálási algoritmusának segítségével, majd egy bináris inverz kerül alkalmazásra az él által definiált képen, itt a bináris inverz is bitwise_NOT segítségével történhet, de szándékosan választottuk ezt a bináris inverz küszöböt, mivel ez szabadságot ad beállítani a paramétereit, amíg tiszta képet nem kapunk.

Azt is meg kell jegyeznünk, hogy a függvény képet készít az argumentumokról, és visszaadja a két argumentumot ret és mask. Míg a ret logikai érték, azt mondja, hogy a függvény sikeresen fut, vagy sem, és a maszk a függvény, azaz a feldolgozott kép végső kimenete.

Ezután a második koncepció a webkamera működtetése az opencv-ben, amelyet a cv2 hajt végre. A VideoCapture (0) függvény, amely a képet egy objektum- sapkában tárolja, amelyet a cap a cap.read () függvénnyel leolvashat, itt is megjegyezheti ezt a sapkát. A read () a végtelen cikluson belül van , mivel folyamatosan kellett rögzítenie a képeket, hogy egy élő videót kapjon, ahol a videó képkockasebessége az Ön webkamerájának képkockasebessége lenne, amely többnyire 24 és 60 között van. fps.

A cap.read () visszaadja a ret és a frame értéket, ahol a ret a logikai érték, jelezve, hogy a függvény sikeresen lefutott vagy sem, és a keret tartalmazza a webkamera által készített képet.

Az alábbiakban bemutatjuk a teljes Python OpenCV kódot az Élő vázlat futtatásához

import cv2 import numpy as np #sketch generáló függvény def sketch (kép): #convert kép szürkeskálává img_gray = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) # a kép kitisztítása Gauss-féle elmosódással img_gray_blur = cv2.GaussianBlay (5,5), 0) #extract extrák canny_edges = cv2.Canny (img_gray_blur, 10,70) # invertálás végrehajtása binarizálja a képet ret, mask = cv2.threshold (canny_edges, 70,255, cv2.THRESH_BINARY_INV) return mask #initialize webcam, sapka az a tárgy által biztosított video elfog #it tartalmaz egy logikai jelzi, hogy sikeres volt (ret) A #it tartalmazza a webkameráról (frame) cap = cv2 gyűjtött képeket is. VideoCapture (0), míg True: ret, frame = cap.read () cv2.imshow ('livesketcher', vázlat (frame)) if cv2.waitKey (1) == 13: # 13 az enterkey- törés # kiadja a kamerát és zárja be az ablakot, ne felejtse el elengedni a webkamerát a cap.release () cap.release () cv2.destroyAllWindows () segítségével

Tehát ezzel vége a Képkezelések Python-OpenCV-ben 2. részének. A számítógépes látás és az OpenCV alábecsülése érdekében olvassa el a korábbi cikkeket (A Python OpenCV használatának megkezdése és a Képkezelések a Python OpenCV-ben (1. rész), és a Computer Vision segítségével valami jót készíthet.