notes

OpenCV Notes/Notes/Basics/bitwise.py

@@ -0,0 +1,27 @@
+import cv2 as cv
+import numpy as np
+
+blank = np.zeros((400,400), dtype='uint8')
+
+rectangle = cv.rectangle(blank.copy(), (30,30), (370,370), 255, -1)
+circle = cv.circle(blank.copy(), (200,200), 200, 255, -1)
+cv.imshow('Rectangle', rectangle)
+cv.imshow('Circle', circle)
+
+# bitwise AND --> intersecting regions
+bitwise_and = cv.bitwise_and(rectangle, circle)
+cv.imshow('Bitwise AND', bitwise_and)
+
+# bitwise OR --> non-intersecting and intersecting regions
+bitwise_or = cv.bitwise_or(rectangle, circle)
+cv.imshow('Bitwise OR', bitwise_or)
+
+# bitwise XOR --> non-intersecting regions
+bitwise_xor = cv.bitwise_xor(rectangle, circle)
+cv.imshow('Bitwise XOR', bitwise_xor)
+
+# bitwise NOT --> inverts the binary color
+bitwise_not = cv.bitwise_not(rectangle)
+cv.imshow('Rectangle NOT', bitwise_not)
+
+cv.waitKey(0)

OpenCV Notes/Notes/Basics/face_detect.py

@@ -0,0 +1,27 @@
+import cv2 as cv
+
+# haar cascades are very sensitive to noise in an image 
+
+img = cv.imread('Photos/group 1.jpg')
+cv.imshow('Group of 5 People', img)
+
+# haar cascades essentially look at an object in an image and using the edges, it determines whether it's a face or not 
+
+gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+cv.imshow('Gray People', gray)
+
+haar_cascade = cv.CascadeClassifier('haar_face.xml')
+
+# rectangular coordinates for the faces that are present in the image
+faces_rect = haar_cascade.detectMultiScale(gray, scaleFactor = 1.1, minNeighbors = 1)   # by minimizing these values, your making openCV more sensitive to noise
+
+print(f'Number of faces found = {len(faces_rect)}')
+
+for (x, y, w,h) in faces_rect:
+    cv.rectangle(img, (x,y), (x+w,y+h), (0,255,0), thickness=2)
+
+cv.imshow('Detected Faces', img)
+
+cv.waitKey(0)
+
+# in order to do this on a video, just do it on each individual frame

OpenCV Notes/Notes/Basics/face_recognition.py

@@ -0,0 +1,30 @@
+import numpy as np
+import cv2 as cv
+
+haar_cascade = cv.CascadeClassifier('haar_face.xml')
+
+people = ['Ben Afflek', 'Elton John', 'Jerry Seinfield', 'Madonna', 'Mindy Kaling']  # can manually type it
+# features = np.load('features.npy', allow_pickle = True)
+# labels = np.load('labels.npy')
+
+face_recognizer = cv.face.LBPHFaceRecognizer_create()
+face_recognizer.read('face_trained.yml')   # trained data
+
+img = cv.imread(r'C:\Users\user\projects\git\opencv-course\Resources\Faces\val\ben_afflek\5.jpg')  # validation
+
+gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+cv.imshow('Person', gray) 
+
+# Detect the face in the image
+faces_rect = haar_cascade.detectMultiScale(gray, 1.1, 4)
+for (x,y,w,h) in faces_rect:
+    faces_roi = gray[y:y+h, x:x+h]
+
+    label, confidence = face_recognizer.predict(faces_roi)
+    print(f'Label = {people[label]} with a confidence of {confidence}')
+
+    cv.putText(img, str(people[label]), (20,20), cv.FONT_HERSHEY_COMPLEX, 1.0, (0, 255, 0), thickness = 2)
+    cv.rectangle (img, (x,y), (x+w,y+h), (0,255,0), thickness = 2)
+
+cv.imshow('Detected Face', img)
+cv.waitKey(0)

OpenCV Notes/Notes/Basics/faces_train.py

@@ -0,0 +1,57 @@
+import os
+import cv2 as cv
+import numpy as np
+
+# create a list of all the people in the image
+# people = ['Ben Afflek', 'Elton John', 'Jerry Seinfield', 'Madonna', 'Mindy Kaling']  # can manually type it
+
+people = []  # OR you could loop over every folder in the folder below
+for i in os.listdir(r'C:\Users\user\projects\git\opencv-course\Resources\Faces\train'):
+    people.append(i)
+
+# print(p)
+
+# create a variable that is equal to the base folder (the folder that contains the five folders of the people)
+DIR = r'C:\Users\user\projects\git\opencv-course\Resources\Faces\train'    # change to wherever the faces folder is located
+
+haar_cascade = cv.CascadeClassifier('haar_face.xml')
+
+features = []  # the image
+labels = []  # the label that goes with the feature (image)
+
+def create_train():
+    for person in people:
+        path = os.path.join(DIR, person)
+        label = people.index(person)
+
+        for img in os.listdir(path):
+            img_path = os.path.join(path, img)
+
+            img_array = cv.imread(img_path)
+            gray = cv.cvtColor(img_array, cv.COLOR_BGR2GRAY)
+
+            faces_rect = haar_cascade.detectMultiScale(gray, scaleFactor = 1.1, minNeighbors = 4)
+
+            for (x,y,w,h) in faces_rect:
+                faces_roi = gray[y:y+h, x:x+w]
+                features.append(faces_roi)
+                labels.append(label)
+                
+
+create_train()
+print('Training done -----------')
+
+features = np.array(features, dtype = object)
+labels = np.array(labels)
+
+# print(f'Length of the features list = {len(features)}')
+# print(f'Length of the labels list = {len(labels)}')
+
+face_recognizer = cv.face.LBPHFaceRecognizer_create()
+
+# Train the Recognizer on the features list and labels list
+face_recognizer.train(features, labels)
+
+face_recognizer.save('face_trained.yml')
+np.save('features.npy', features)
+np.save('labels.npy', labels)

OpenCV Notes/Notes/Basics/gradients.py

@@ -0,0 +1,27 @@
+import cv2 as cv
+import numpy as np
+
+img = cv.imread('Photos/cats.jpg')
+cv.imshow('Cats', img)
+
+gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+cv.imshow('Gray', gray)
+
+# Latplacian
+lap = cv.Laplacian(gray, cv.CV_64F)
+lap = np.uint8(np.absolute(lap))
+cv.imshow('Latplacian', lap)
+
+# Sobel 
+sobelx = cv.Sobel(gray, cv.CV_64F, 1, 0) 
+sobely = cv.Sobel(gray, cv.CV_64F, 0, 1) 
+combined_sobel = cv.bitwise_or(sobelx, sobely)
+
+cv.imshow('Sobel X', sobelx)
+cv.imshow('Sobel Y', sobely)
+cv.imshow('Combined Sobel', combined_sobel)
+
+canny = cv.Canny(gray, 150, 175)   #uses Sobel
+cv.imshow('Canny', canny)
+
+cv.waitKey(0)

OpenCV Notes/Notes/Basics/histograms.py

@@ -0,0 +1,43 @@
+import cv2 as cv
+import matplotlib.pyplot as plt
+import numpy as np
+
+img = cv.imread('Photos/cats.jpg')
+
+blank = np.zeros(img.shape[:2], dtype='uint8') 
+
+gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+cv.imshow('Gray', gray)
+
+mask = cv.circle(blank, (img.shape[1]//2, img.shape[0]//2), 100, 255, -1)
+
+# mask = cv.bitwise_and(gray,gray,mask=circle)
+masked = cv.bitwise_and(img,img,mask=mask)
+cv.imshow('Mask', masked)
+# Grayscale histogram
+# gray_hist = cv.calcHist([gray], [0], mask, [256], [0,256])
+
+# plt.figure()
+# plt.title('Grayscale Histogram')  # distribution of pixels (intensity) in the image
+# plt.xlabel('Bins')
+# plt.ylabel('# of pixels')
+# plt.plot(gray_hist)
+# plt.xlim([0,256])
+# plt.show()
+
+# Color histogram
+
+plt.figure()
+plt.title('Colour Histogram')  
+plt.xlabel('Bins')
+plt.ylabel('# of pixels')
+
+colors = ('b', 'g', 'r')
+for i,col in enumerate(colors):
+    hist = cv.calcHist([img], [i], mask, [256], [0,256])
+    plt.plot(hist, color = col)
+    plt.xlim(0, 256)
+
+plt.show()
+
+cv.waitKey(0)

OpenCV Notes/Notes/Basics/masking.py

@@ -0,0 +1,21 @@
+import cv2 as cv
+import numpy as np
+
+img = cv.imread('Photos/cats2.jpg')
+cv.imshow('Cats', img)
+
+blank = np.zeros(img.shape[:2], dtype='uint8')  # the dimensions of the mask have to be the same size as that of the image
+cv.imshow('Blank Image', blank)
+
+circle = cv.circle(blank.copy(), (img.shape[1]//2 + 45,img.shape[0]//2), 100, 255, -1)
+# cv.imshow('Mask', mask)
+
+rectangle = cv.rectangle(blank.copy(), (30,30), (370,370), 255, -1)
+
+weird_shape = cv.bitwise_and(circle, rectangle)
+cv.imshow('Weird Shape', weird_shape)
+
+masked = cv.bitwise_and(img, img, mask = weird_shape)
+cv.imshow('Weird Shaped Masked Image', masked)
+
+cv.waitKey(0)

OpenCV Notes/Notes/Basics/thresh.py

@@ -0,0 +1,22 @@
+import cv2 as cv
+
+img = cv.imread('Photos/cats.jpg')
+cv.imshow('Cats', img)
+
+# Thresholding is a binarization of an image (an image where pixels are either white or black, (0, 255))
+
+gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+cv.imshow('Gray', gray)
+
+# Simple Thresholding
+threshold, thresh = cv.threshold(gray, 150, 255, cv.THRESH_BINARY) # thresh is the image returned and threshold is the value you inputted which would be 150
+cv.imshow('Simple Thresholded', thresh)
+
+threshold, thresh_inv = cv.threshold(gray, 150, 255, cv.THRESH_BINARY_INV) # thresh is the image returned and threshold is the value you inputted which would be 150
+cv.imshow('Simple Thresholded Inverse', thresh_inv)
+
+# Adaptive Thresholding (computer finds the optimal thresholding value)
+adaptive_thresh = cv.adaptiveThreshold(gray, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY_INV, 11, 9)  # Gaussian puts weight on certain pixels so that's why it looks clearer
+cv.imshow('Adaptive Thresholding', adaptive_thresh)
+
+cv.waitKey(0)