Beeldmanipulaties in opencv (part

In de vorige tutorials hebben we geleerd over OpenCV en hebben we wat basisbeeldverwerking gedaan en in de volgende tutorial hebben we wat beeldmanipulatie in OpenCV gedaan, zoals bijsnijden, roteren, beeldtransformatie enz. Dus in het vervolg met de vorige tutorial over beeldmanipulatie, leren we hier wat meer technieken voor beeldmanipulatie zoals en aan het einde van de tutorial zullen we een python-opencv-programma bouwen om live sketches te maken van de webcam live feed. Deze applicatie zal veel van de beeldverwerkingsfuncties gebruiken die we tot nu toe hebben geleerd of die we in deze tutorial zullen leren, dus dit zal een goed praktisch voorbeeld zijn om alle functies te behandelen.

Zoals verteld in de vorige tutorial, is OpenCV Open Source Commuter Vision Library met C ++, Python en Java-interfaces en ondersteunt Windows, Linux, Mac OS, iOS en Android. Het kan dus eenvoudig worden geïnstalleerd in Raspberry Pi met Python- en Linux-omgeving. En Raspberry Pi met OpenCV en aangesloten camera kan worden gebruikt om veel realtime beeldverwerkingstoepassingen te maken, zoals gezichtsdetectie, gezichtsvergrendeling, objecttracering, auto nummerplaat detectie, huisbeveiligingssysteem etc.

In deze tutorial gaan we wat meer beeldmanipulaties zien met Python OpenCV. Hier zullen we leren om de volgende functie toe te passen op een afbeelding met Python OpenCV:

• Bitwise-bewerkingen en maskering
• Convolutie en vervaging
• Verscherpen - Het beeld omkeren wordt wazig
• Thresholding (binarisering)
• Uitzetting, erosie, openen / sluiten
• Randdetectie en afbeeldingsverlopen
• Perspectief en affiniteitstransformatie
• Live Sketch-applicatie

1. Bitsgewijze bewerkingen en maskering

Bitsgewijze bewerkingen helpen u bij het maskeren van afbeeldingen en helpen u bij het maken van enkele eenvoudige afbeeldingen.

Een vierkant maken

import cv2 import numpy als np # we gebruiken slechts twee dimensies omdat dit een grijswaardenafbeelding is, als we een #gekleurde afbeelding gebruikten, hadden we toen een rechthoek = np.zeros ((300,300,3), np.uint8) # gebruikt Een vierkant vierkant maken = np.zeros ((300,300), np.uint8) cv2.rechthoek (vierkant, (50,50), (250,250), 255, -1) cv2.imshow ("vierkant", vierkant) cv2. waitKey (0)

Een ellips maken

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

Experimenteren met bitsgewijze bewerkingen

#AND_ toont alleen waar de twee elkaar kruisen

BitwiseAND = cv2.bitwise_and (vierkant, ellips) cv2.imshow ("AND", BitwiseAND) cv2.waitKey (0)

#OR_ toont alleen waar een vierkant of ellips is

BitwiseOR = cv2.bitwise_or (vierkant, ellips) cv2.imshow ("OR", BitwiseOR) cv2.waitKey (0)

#XOR_ toont alleen waar een van beide op zichzelf bestaat

BitwiseXOR = cv2.bitwise_xor (vierkant, ellips) cv2.imshow ("XOR", BitwiseXOR) cv2.waitKey (0)

#NOT_shows alles dat geen deel uitmaakt van de ellips en de NOT-bewerking kan alleen op één cijfer worden toegepast

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

2. Convolutie en vervaging

Een convolutie is een wiskundige bewerking die wordt uitgevoerd op twee functies en een derde functie produceert die typisch een gewijzigde versie van de oorspronkelijke functie is.

Uitvoer image = image Functie _{Kernelgrootte}

In computervisie gebruiken we kernels om de grootte te specificeren waarover we onze manipulatiefunctie over onze afbeelding uitvoeren.

Vervaging is een bewerking waarbij we het gemiddelde van de pixels binnen een regio bepalen (kernel)

OpenCV vervaagt een afbeelding door kernels toe te passen, een kernel vertelt je hoe je de waarde van een bepaalde pixel kunt veranderen door deze te combineren met een verschillend aantal aangrenzende pixels. De kernel wordt een voor een op elke pixel in de afbeelding toegepast om de uiteindelijke afbeelding te produceren.

Simpel gezegd, een beeldconvolutie is gewoon een elementgewijze vermenigvuldiging van twee matrices gevolgd door een som.

We kunnen het eenvoudig begrijpen aan de hand van het volgende voorbeeld.

Het bovenstaande is een 3X3 Kernel.

We vermenigvuldigen met 1/25 om de som te normaliseren tot 1, we hadden de intensiteit verhoogd of de intensiteit verlaagd zoals in het geval van het lichter of donkerder worden van beelden.

Laten we een opencv vervagingsmethode testen filter2D, gegeven door de functie cv2.filter2D (afbeelding, -1, kernel)

import cv2 import numpy als np afbeelding = cv2.imread ('elephant.jpg') cv2.imshow ('origineel', afbeelding) cv2.waitKey (0)

#creëren van een 3x3 kernelmatrix

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

# we gebruiken cv2.filter2D om de kernel te convolueren met een afbeelding

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

#creëren van een 7x7 kernelmatrix

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

# we gebruiken cv2.filter2D om de kernel te convolueren met een afbeelding

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

Er zijn ook andere soorten vervagingsmethoden:

cv2.blur - Gemiddelde waarde over een bepaald venster.

cv2.GaussianBlur - Gelijkaardig maar gebruikt een Gaussiaans venster (meer nadruk op punten rond het midden).

cv2.medianBlur– Gebruikt mediaan van alle elementen in het venster.

cv2.bilateralFilter– Vervaagt terwijl de randen scherp blijven, het behoudt de randen en lijndetails.

We zullen hieronder een voor een zien, geef eerst de originele afbeelding weer met behulp van onderstaande code:

import cv2 import numpy als np afbeelding = cv2.imread ('elephant.jpg') cv2.imshow ('origineel', afbeelding) cv2.waitKey (0)

cv2.vervagen:

Bij deze methode wordt middeling gedaan door het beeld te convolueren met een genormaliseerd boxfilter, deze neemt de plaats onder de box in en vervangt het centrale element. Hier moet de doosgrootte vreemd en positief zijn .

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

cv2.GaussianBlur:

# cv2.GaussianBlur #in plaats van boxfilter, laten we de Gauss-kernel proberen Gaussian = cv2.GaussianBlur (afbeelding, (7,7), 0) cv2.imshow ('Gaussian vervaging', Gaussian) cv2.waitKey (0)

cv2.medianBlur:

Het kost de mediaan van alle pixels onder het kernelgebied en het centrale element wordt vervangen door deze mediaan.

# cv2.medianBlur # neemt de mediaan van alle pixels onder het kernelgebied en het centrale element #is vervangen door deze mediaan. gemiddelde = cv2.medianBlur (afbeelding 5) cv2.imshow (mediaan vervaging ", België) cv2.waitKey (0)

cv2.bilateralFilter:

Bilateraal is zeer effectief bij het verwijderen van ruis terwijl de randen scherp blijven

# cv2.bilateralFilter #Bilateral is zeer effectief in het verwijderen van ruis terwijl de randen scherp blijven bilateraal = cv2.bilateralFilter (afbeelding, 9,75,75) cv2.imshow ('bilaterale vervaging', bilateraal) cv2.waitKey (0) cv2. destroyAllWindows ()

Image De-noise-non Local betekent ruisonderdrukking

import cv2 import numpy als np afbeelding = cv2.imread ('elephant.jpg') cv2.imshow ('origineel', afbeelding) cv2.waitKey (0)

#parameter na None is de filtersterkte 'h' (5-10 is een goed bereik) #next is h voor kleurcomponenten, opnieuw ingesteld als dezelfde waarde als h

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

Er zijn 4 varianten van niet-lokale middelen voor ruisonderdrukking

cv2.fastNlMeansDenoising () - voor enkele grijsschaalafbeelding

cv2.fastNlMeansDenoisingColored () - Afbeelding in één kleur

cv2.fastNlmeansDenoisingMulti () - voor grijstinten van afbeeldingen

cv2.fastNlmeansDenoisingcoloredMulti () - voor gekleurde afbeeldingen

3. Verscherping - Het beeld vervaagt omkeren

Verscherpen is het tegenovergestelde van vervaging, het versterkt of benadrukt de randen van het beeld.

Kernel =,,

Onze kernelmatrix telt één op, dus het is niet nodig om te normaliseren (dwz vermenigvuldigen met een factor tot dezelfde helderheid als het origineel), als de kernel niet wordt genormaliseerd naar 1, zou het beeld helderder of donkerder zijn.

import cv2 import numpy als np afbeelding = cv2.imread ('elephant.jpg') cv2.imshow ('origineel', afbeelding) cv2.waitKey (0)

kernel_sharpening = np.array (,

])

# Sharpening-kernel toepassen om afbeelding in te voeren

sharpened = cv2.filter2D (afbeelding, -1, kernel_sharpening) cv2.imshow ('scherpere afbeelding', verscherpt) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Threshoding (binarisering)

Thresholding is het omzetten van een afbeelding in een binaire vorm. In opencv is er een aparte functie voor drempels gedefinieerd als

Cv2.threshold (afbeelding, drempelwaarde, maximale waarde, drempeltype)

Er zijn de volgende soorten drempels:

• cv2.THRESH_BINARY - meest voorkomende
• cv2. THRESH_BINARY_INV - meest voorkomende
• cv2.THRESH_TRUNC
• cv2.THRESH_TOZERO
• cv2. THRESH_TOZERO_INV

OPMERKING: de afbeelding moet worden geconverteerd naar grijswaarden voordat de drempelwaarde wordt bereikt

import cv2 import numpy als np # afbeelding laden als grijswaardenafbeelding = cv2.imread ('gradient.jpg', 0) cv2.imshow ('origineel', afbeelding) cv2.waitKey (0)

#waarde onder 127 ga naar 0 (zwart), en boven 127 gaat naar 255 (wit)

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

#waarde onder 127 gaat naar 255 en waarden boven 127 gaan naar 0 (omgekeerd van hierboven)

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

#waarde boven 127 wordt afgekapt (vastgehouden) op 127, het 255-argument wordt niet gebruikt.

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

#waarden onder 127 gaan naar 0, boven 127 blijven ongewijzigd

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

#Revesrse van boven, onder 127 is ongewijzigd, boven 127 gaat naar nul

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

5. Uitzetting, erosie, openen / sluiten

Dit zijn de bewerkingen op het gebied van wiskundige morfologie

Dilatatie - het voegt pixels toe aan de grenzen van het object in een afbeelding.

Erosie - Verwijdert pixels aan de randen van objecten in een afbeelding.

Opening - Erosie gevolgd door dilatatie.

Sluiten - Uitzetting gevolgd door erosie.

Het openen is erg nuttig bij het ruisonderdrukken van de beelden, aangezien het het beeld eerst verdunt door erosie (verwijdert de ruis) en het vervolgens verwijdt.

Verwarring met verwijding en erosie

Er is soms verwarring tussen dilatatie en erosie, meestal in foto's met een witte achtergrond, omdat opencv een witte achtergrond beschouwt als een afbeelding die moet worden uitgezet of geërodeerd in plaats van de originele foto, dus in dit geval werkt erosie als dilatatie en vice versa, zoals getoond in het beeldvoorbeeld hieronder weergegeven.

Onthoud dat Dilation pixels toevoegt aan de grenzen van objecten in een afbeelding, terwijl Erosion pixels verwijdert aan de grenzen van objecten in een afbeelding

import cv2 import numpy als np afbeelding = cv2.imread ('imagecv.png', 0) cv2.imshow ('origineel', afbeelding) cv2.waitKey (0)

#Erosie

# laten we onze kernelgrootte definiëren

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

# nu we de afbeelding eroderen, hier is iteratie geen enkele keer dat je de afbeelding wilt eroderen

erosie = cv2.erode (afbeelding, kernel, iteraties = 1) cv2.imshow ('Erosie', erosie) cv2.waitKey (0)

#verwijding

dilation = cv2.dilate (afbeelding, kernel, iteraties = 1) cv2.imshow ('dilation', dilate) cv2.waitKey (0)

#opening, Goed voor het verwijderen van de ruis

opening = cv2.morphologyEx (afbeelding, cv2.MORPH_OPEN, kernel) cv2.imshow ('opening', opening) cv2.waitKey (0)

#sluiting, goed voor het verwijderen van ruis

sluiten = cv2.morphologyEx (afbeelding, cv2.MORPH_CLOSE, kernel) cv2.imshow ('sluiten', sluiten) cv2.waitKey (0) cv2.destroyAllWindows ()

6. Randdetectie en afbeeldingsverlopen

Randdetectie is een zeer belangrijk gebied in computervisie, vooral bij het omgaan met contouren.

Randen kunnen worden gedefinieerd als grenzen van de afbeelding, het zijn eigenlijk randen die objecten in afbeeldingen definiëren, ze bewaren veel informatie over de afbeelding.

Formeel kunnen randen worden gedefinieerd als plotselinge veranderingen (discontinuïteiten) in een afbeelding en ze kunnen evenveel informatie coderen als pixels.

De bovenstaande afbeelding laat zien hoe computer vision de afbeelding identificeert en herkent.

Randdetectie-algoritmen: - Er zijn drie hoofdtypen randdetectie-algoritmen

• Sobel - om de nadruk te leggen op verticale of horizontale afbeeldingen.
• Laplace - optimaal vanwege het lage foutenpercentage, goed gedefinieerde randen en nauwkeurige detectie.
• Canny Edge-detectiealgoritme (ontwikkeld door john.F.Canny in 1986)

1. Past Gaussiaanse vervaging toe

2. Vindt intensiteitgradiënt van afbeelding

3. past niet-maximale onderdrukking toe (dwz verwijdert pixels die geen randen zijn).

4. Hysterese past drempel toe (dwz als de pixel zich binnen de bovenste en onderste drempel bevindt, wordt deze als een rand beschouwd)

import cv2 import numpy als np image = cv2.imread ('input.jpg', 0) hoogte, breedte = image.shape

#sobel

#aftrekken van sobel-randen

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

#Sobely

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

laplace = cv2.Laplaceian (afbeelding, cv2.CV_64F) cv2.imshow ('Laplaceian', laplaceian) cv2.waitKey (0)

#canny randdetectie-algoritme gebruikt gradiëntwaarden als drempelwaarden

# we moeten in ieder geval twee waarden opgeven: drempel1 en drempel2.

#elke gradiënt groter dan drempel 2 wordt beschouwd als een rand.

#elke gradiënt groter dan drempel 1 wordt beschouwd als geen rand.

#values tussen drempel 1 en 2 drempelwaarde ofwel als rand of non-edge

#op hoe hun intensiteiten worden verbonden, in dit geval elke waarde onder 60 worden beschouwd

#non randen wheareas elke waarde boven 120. randen worden beschouwd.

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

14. Perspectief en affiniteitstransformatie

Laten we een stap terug doen en kijken naar affiene en niet-affiene transformaties, de originele afbeelding hieronder is duidelijk een niet-affiene afbeelding, aangezien de randen elkaar op een gegeven moment zullen ontmoeten, maar we kunnen het recht maken door krom te trekken en het perspectief te nemen transformeren.

Voor deze perspectieftransformatie hebben we de vier coördinaten van het originele beeld nodig en vervolgens de vier punten van het uitvoerbeeld, deze worden aangeduid met punten_A en punten_B. Ten eerste berekenen we met behulp van deze punten een transformatiematrix, M met behulp van de functie getPerspectiveTransform.

En dan wordt deze matrix aan de warpPerspective- functie gegeven om de uiteindelijke uitvoer te genereren.

Laten we nu eerst de perspectieftransformatie proberen.

import cv2 import numpy als np import matplotlib.pyplot als plt afbeelding = cv2.imread ('paper.jpg') cv2.imshow ('origineel', afbeelding) cv2.waitKey (0)

#coördinatie van 4 hoeken van de originele afbeelding

points_A = np.float32 (,,,])

#coördinaten van 4 hoeken van de gewenste uitvoer

# we gebruiken een verhouding van een A4-papier 1: 1,41

points_B = np.float32 (,,,])

#gebruik de twee sets van twee punten om de prespectieve transformatiematrix M te berekenen

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

Affiene transformatie is gemakkelijker dan de niet-affiene transformatie omdat we maar drie punten nodig hebben om de transformatie te krijgen. Het hele proces gaat hetzelfde, maar in plaats van perspectieftransformatie hebben we nu een affiene transformatie en we definiëren ook cols en rijen in warpAffine vanuit de vormfunctie in plaats van deze handmatig in te voeren.

import cv2 import numpy als np import matplotlib.pyplot als plt afbeelding = cv2.imread ('box.jpg') rijen, cols = image.shape cv2.imshow ('origineel', afbeelding) cv2.waitKey (0)

#coördinatie van 3 hoeken van de originele afbeelding

points_A = np.float32 (,,])

#coördinaten van 3 hoeken van de gewenste uitvoer

# we gebruiken een verhouding van een A4-papier 1: 1,41

points_B = np.float32 (,,])

#gebruik de twee sets van twee punten om de affiene #transformatiematrix M te berekenen

M = cv2.getAffineTransform (punten_A, punten_B) warped = cv2.warpAffine (afbeelding, M, (cols, rijen)) cv2.imshow ('warpaffine', kromgetrokken) cv2.waitKey (0) cv2.destroyAllWindows ()

8. Live Sketch-applicatie

Allereerst, feliciteer jezelf met het goedmaken van dit miniproject nadat je alle bovenstaande functies voor beeldmanipulatie hebt gelezen. Dus in dit miniproject van Python OpenCV gaan we enkele nieuwe concepten van loops en functies leren. Als je bekend bent met programmeren, moet je een breder idee hebben van wat de functie en loops zijn. In Python blijft het basisconcept van lussen en functies echter hetzelfde, maar de methode om ze te definiëren verandert een beetje.

Dus aan het begin van dit programma zien we een bepaalde groep statements onder de “ def sketch (image) ” : dit is een formele definitie van een functie een groep statements die samenwerken voor een bepaalde output.

Dus deze sketch is een functie, in python wordt de functie gedefinieerd door "def" en eindigt met een ":" teken. Ook de uitspraken die nodig zijn om binnen de functie te staan ​​of je kunt zeggen welke nodig zijn om de functie correct te laten werken, worden automatisch zijdelings uitgelijnd door de functie. Dus om uit de functies te komen, moesten de uitspraken volledig links uitgelijnd zijn. Voor de verdere verwijzingen kunt u naar google verwijzen over hoe de functies zijn gedefinieerd in python.

Dus in deze schetsfunctie hebben we verschillende lagen van beeldverwerking geïntroduceerd die samen een output opleveren. Ten eerste wordt de afbeelding omgezet in grijstinten zodat de opencv deze gemakkelijk kan verwerken en vervolgens wordt een Gaussiaanse vervaging toegepast op de grijsschaalafbeelding om de ruis te verminderen. Vervolgens worden de randen geëxtraheerd met behulp van het canny's edge-detectie-algoritme en vervolgens wordt een binaire inverse toegepast op het randgedefinieerde beeld, hier zou de binaire inverse ook kunnen worden gedaan door bitwise_NOT maar we hadden bewust deze drempel binaire inverse gekozen omdat het vrijheid geeft om zijn parameters in te stellen totdat we een duidelijk beeld krijgen.

Merk ook op dat de functie de argumenten afbeelding neemt en de twee argumenten ret en mask retourneert. Terwijl de ret de Boolean is die vertelt dat de functie al dan niet succesvol wordt uitgevoerd en het masker de uiteindelijke uitvoer van de functie is, dwz het verwerkte beeld.

Dan is het tweede concept het bedienen van de webcam in opencv, dat wordt gedaan door de functie cv2.VideoCapture (0) , die de afbeelding opslaat in een object- cap die cap kan worden gelezen met de functie cap.read () , ook hier om die cap op te merken . read () bevindt zich in de oneindige while-lus omdat het continu de beelden moest vastleggen, om het een gevoel te geven van een live video, waarbij de framesnelheid van de video de framesnelheid van je webcam zou zijn, die meestal tussen 24 en 60 ligt fps.

cap.read () geeft ret en frame terug, waarbij de ret de Booleaanse waarde is die aangeeft dat de functie met succes is uitgevoerd of niet en het frame de afbeelding bevat die met de webcam is gemaakt.

Hieronder staat de volledige Python OpenCV-code voor het uitvoeren van de Live Sketch

import cv2 import numpy als np #sketch genererende functie def sketch (afbeelding): #convert afbeelding naar grijswaarden img_gray = cv2.cvtColor (afbeelding, cv2.COLOR_BGR2GRAY) #opruiming van de afbeelding met Gaussiaanse vervaging img_gray_blur = cv2.GaussianBlur (img_gray, (5,5), 0) #extract borders canny_edges = cv2.Canny (img_gray_blur, 10,70) #do an invert binariseer de afbeelding ret, mask = cv2.threshold (canny_edges, 70,255, cv2.THRESH_BINARY_INV) return mask #initialize webcam, cap is het object dat wordt geleverd door video- opname #it ​​bevat een Boolean die aangeeft of het succesvol was (ret) #it ​​bevat ook de afbeeldingen die zijn verzameld van de webcam (frame) cap = cv2.VideoCapture (0) while True: ret, frame = cap.read () cv2.imshow ('livesketcher', sketch (frame)) if cv2.waitKey (1) == 13: # 13 is de enterkey break #release camera en sluit venster, vergeet niet om de webcam vrij te geven met behulp van cap.release () cap.release () cv2.destroyAllWindows ()

Dit is dus het einde van deel 2 van beeldmanipulaties in Python-OpenCV. Om een ​​goed begrip te krijgen van computer vision en OpenCV, ga je door eerdere artikelen (Aan de slag met Python OpenCV en beeldmanipulaties in Python OpenCV (deel 1) en je zult iets cools kunnen maken met Computer Vision.