opencv cheatsheet

Python
Follow me on
Sumit Khanna for more updates
OpenCV CheatSheet & Comprehensive

Guide
OpenCV (Open Source Computer Vision Library) is an open-source computer vision and
machine learning software library. OpenCV was built to provide a common infrastructure for
computer vision applications and to accelerate the use of machine perception in commercial
products. The library contains more than 2500 optimized algorithms, including a
comprehensive set of both classic and state-of-the-art computer vision and machine learning
algorithms. These algorithms can be used for various purposes such as detecting and
recognizing faces, identifying objects, classifying human actions in videos, tracking camera
movements, tracking moving objects, extracting 3D models of objects, stitching images
together to produce a high-resolution image of an entire scene, finding similar images from an
image database, removing red-eye, following eye movements, and much more.
Cheat Sheet Table
Method Name Definition
cv2.imread Reads an image from a file.
cv2.imwrite Writes an image to a file.
cv2.imshow Displays an image in a window.
cv2.cvtColor Converts an image from one color space to

another.
cv2.GaussianBlur Applies a Gaussian blur to an image.
cv2.Canny Applies the Canny edge detector to an image.
Detects lines in a binary image using the Hough

cv2.HoughLines
Transform.
Detects circles in a binary image using the

cv2.HoughCircles
Hough Transform.
cv2.findContours Finds contours in a binary image.
cv2.drawContours Draws contours on an image.
cv2.rectangle Draws a rectangle on an image.
cv2.circle Draws a circle on an image.
cv2.line Draws a line on an image.
cv2.putText Puts text on an image.
cv2.resize Resizes an image to the specified dimensions.
cv2.warpAffine Applies an affine transformation to an image.
cv2.warpPerspective Applies a perspective transformation to an

image.
Computes the affine matrix for rotating an image
cv2.getRotationMatrix2D
by a specified angle.
Computes the affine transformation matrix from

cv2.getAffineTransform
three pairs of points.
Computes the perspective transformation

cv2.getPerspectiveTransform
matrix from four pairs of points.
cv2.dilate Applies the dilation operation to an image.
cv2.erode Applies the erosion operation to an image.
Applies advanced morphological

cv2.morphologyEx
transformations to an image.
cv2.threshold Applies a fixed-level threshold to an image.
cv2.adaptiveThreshold Applies an adaptive threshold to an image.
cv2.equalizeHist Equalizes the histogram of a grayscale image.
cv2.calcHist Computes the histogram of an image.
cv2.compareHist Compares two histograms.
Compares a template image with a source

cv2.matchTemplate
image using a specific method.
cv2.VideoCapture Opens a video file or a capturing device.
cv2.VideoWriter Writes video frames to a video file.

Computes dense optical flow using the Lucas-

cv2.calcOpticalFlowPyrLK
Kanade method.
Computes dense optical flow using the

cv2.calcOpticalFlowFarneback
Farneback method.
cv2.dnn.readNet Reads a deep learning network model from a

file.
Converts an image to a blob for input into a deep
cv2.dnn.blobFromImage
learning network.
cv2.dnn_Net.forward Runs a forward pass of the deep learning

network.
cv2.CascadeClassifier Detects objects using a cascade classifier.
cv2.face.LBPHFaceRecognizer_create Creates an LBPH face recognizer.
cv2.face.FisherFaceRecognizer_create Creates a Fisher face recognizer.
cv2.face.EigenFaceRecognizer_create Creates an Eigen face recognizer.
cv2.bgsegm.createBackgroundSubtractorMOG Creates a MOG background subtractor.
cv2.bgsegm.createBackgroundSubtractorMOG Creates a MOG2 background subtractor.

2
cv2.bgsegm.createBackgroundSubtractorKNN Creates a KNN background subtractor.
cv2.bgsegm.createBackgroundSubtractorGMG Creates a GMG background subtractor.
cv2.FastFeatureDetector_create Creates a FAST feature detector.
Creates an ORB feature detector and descriptor

cv2.ORB_create
extractor.
Creates a SIFT feature detector and

cv2.SIFT_create
descriptor extractor.
Creates a SURF feature detector and descriptor

cv2.SURF_create
extractor.
Creates a BRISK feature detector and descriptor

cv2.BRISK_create
extractor.
cv2.drawKeypoints Draws keypoints on an image.

Explanation and Usage
1. cv2.imrea
d
Reads an image from a file.
Usage:
import
cv2
# Read an image
image =
cv2.imread('path/to/image.jpg')
# Display the image

cv2.imshow('Image',
image)
cv2.waitKey(0)
cv2.destroyAllWindows()
2. cv2.imwrit
e
Writes an image to a file.
Usage:
import
cv2
# Read an image
image =
# Write the image to a new file

cv2.imwrite('path/to/new_image.jpg',
image)
3. cv2.imsho
w
Displays an image in a window.
Usage:
import
cv2
# Read an image
image =
# Display the image

cv2.imshow('Image',
image)
cv2.waitKey(0)
4. cv2.cvtColo
r
Converts an image from one color space to another.
Usage:
import
cv2
# Read an image
image =
# Convert the image to grayscale

gray_image = cv2.cvtColor(image,
cv2.COLOR_BGR2GRAY)
# Display the grayscale image

cv2.imshow('Gray Image',
gray_image)
cv2.waitKey(0)
5. cv2.GaussianBlu
r
Applies a Gaussian blur to an image.
Usage:
import
cv2
# Read an image
image =
# Apply Gaussian blur

blurred_image = cv2.GaussianBlur(image, (15,
15), 0)
# Display the blurred image

cv2.imshow('Blurred Image',
blurred_image) cv2.waitKey(0)
6. cv2.Cann
y
Applies the Canny edge detector to an image.
Usage:
import
cv2
# Read an image
image = cv2.imread('path/to/image.jpg',
cv2.IMREAD_GRAYSCALE)
# Apply Canny edge detector

edges = cv2.Canny(image, 100,
200)
# Display the edges

cv2.imshow('Edges',
edges) cv2.waitKey(0)
7. cv2.HoughLine
s
Detects lines in a binary image using the Hough Transform.
Usage:
import cv2
import numpy as np
# Read an image
image = cv2.imread('path/to/image.jpg', cv2.IMREAD_GRAYSCALE)

edges = cv2.Canny(image, 50, 150, apertureSize=3)
# Detect lines using Hough Transform

lines = cv2.HoughLines(edges, 1, np.pi/180, 200)
# Draw the lines on the

image for line in lines:
rho, theta = line[0]
a = np.cos(theta)
b = np.sin(theta)
x0 = a * rho
y0 = b * rho
x1 = int(x0 + 1000 * (-
b)) x2 = int(x0 - 1000 *
(-b)) y1 = int(y0 + 1000
* (a)) y2 = int(y0 -
1000 * (a))
cv2.line(image, (x1, y1), (x2,
y2), (0, 0, 255), 2)
# Display the result

cv2.imshow('Hough Lines', image)
cv2.waitKey(0)
8. cv2.HoughCircle
s
Detects circles in a binary image using the Hough Transform.
Usage:
import cv2
import numpy as
np
# Read an image

blurred_image = cv2.GaussianBlur(image, (9,
9), 2)
# Detect circles using Hough Transform

circles = cv2.HoughCircles(blurred_image, cv2.HOUGH_GRADIENT, 1,
20,
param1=50, param2=30, minRadius=0,
# Convert the circles to integers

circles =
np.uint16(np.around(circles))
# Draw the circles on the image

for i in circles[0, :]:
cv2.circle(image, (i[0], i[1]), i[2], (0, 255,
0), 2)
cv2.circle(image, (i[0], i[1]), 2, (0, 0, 255),

cv2.imshow('Hough Circles',
image)
cv2.waitKey(0)
9. cv2.findContour
s
Finds contours in a binary image.
Usage:
import
cv2
# Read an image
# Apply threshold to get a binary image

_, binary_image = cv2.threshold(image, 127, 255,
cv2.THRESH_BINARY)
# Find contours
contours, hierarchy = cv2.findContours(binary_image, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
# Draw the contours on the image

cv2.drawContours(image, contours, -1, (0, 255,
0), 3)

cv2.imshow('Contours',
image) cv2.waitKey(0)
10. cv2.drawContour
s
Draws contours on an image.
Usage:
import
cv2
# Read an image
# Apply threshold to get a binary image

_, binary_image = cv2.threshold(image, 127, 255,
cv2.THRESH_BINARY)
# Find contours
contours, hierarchy = cv2.findContours(binary_image, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
# Draw the contours on the image

cv2.drawContours(image, contours, -1, (0, 255,
0), 3)

cv2.imshow('Drawn Contours',
image)
cv2.waitKey(0)
11. cv2.rectangl
e
Draws a rectangle on an image.
Usage:
import
cv2
# Read an image
image =
# Draw a rectangle on the image

cv2.rectangle(image, (50, 50), (200, 200), (255, 0,
0), 3)

cv2.imshow('Rectangle',
image)
cv2.waitKey(0)
12. cv2.circl
e
Draws a circle on an image.
Usage:
import
cv2
# Read an image
image =
# Draw a circle on the image

cv2.circle(image, (150, 150), 50, (0, 255,
0), 3)

cv2.imshow('Circle',
13. cv2.lin
e
Draws a line on an image.
Usage:
import
cv2
# Read an image
image =
# Draw a line on the image

cv2.line(image, (100, 100), (300, 300), (0, 0,
255), 3)

cv2.imshow('Line',
image)
cv2.waitKey(0)
14. cv2.putTex
t
Puts text on an image.
Usage:
import
cv2
# Read an image
image =
# Put text on the image

cv2.putText(image, 'OpenCV', (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2,
cv2.LINE_A

cv2.imshow('Text',
15. cv2.resiz
e
Resizes an image to the specified dimensions.
Usage:
import
cv2
# Read an image
image =
# Resize the image

resized_image = cv2.resize(image, (400,
300))

cv2.imshow('Resized Image',
resized_image) cv2.waitKey(0)
16. cv2.warpAffin
e
Applies an affine transformation to an image.
Usage:
import cv2
import numpy as
np
# Read an image
image =
# Define the transformation matrix

M = np.float32([[1, 0, 100], [0, 1,
50]])
# Apply affine transformation

transformed_image = cv2.warpAffine(image, M, (image.shape[1],
image.shape[0]))

cv2.imshow('Affine Transformation',
transformed_image) cv2.waitKey(0)
17. cv2.warpPerspecti
ve
Applies a perspective transformation to an image.
Usage:
import cv2
import numpy as
np
# Read an image
image =
# Define the points for perspective transformation

pts1 = np.float32([[50, 50], [200, 50], [50, 200], [200,
200]])
pts2 = np.float32([[10, 100], [200, 50], [100, 250], [300,
# Compute the perspective transformation

matrix
M = cv2.getPerspectiveTransform(pts1, pts2)
# Apply perspective transformation

transformed_image = cv2.warpPerspective(image, M, (image.shape[1],
image.shape[0]))

cv2.imshow('Perspective Transformation',
18. cv2.getRotationMatrix
2D
Computes the affine matrix for rotating an image by a specified angle.
Usage:
import
cv2
# Read an image
image =
# Compute the rotation matrix

M = cv2.getRotationMatrix2D((image.shape[1]/2, image.shape[0]/2),
45, 1)
# Apply rotation
rotated_image = cv2.warpAffine(image, M, (image.shape[1],
image.shape[0]))

cv2.imshow('Rotated Image',
rotated_image) cv2.waitKey(0)
19. cv2.getAffineTransfo
rm
Computes the affine transformation matrix from three pairs of points.
Usage:
import cv2
import numpy as
np
# Read an image
image =
# Define the points for affine transformation

pts1 = np.float32([[50, 50], [200, 50], [50,
200]])
pts2 = np.float32([[10, 100], [200, 50], [100,
# Compute the affine transformation

matrix
M = cv2.getAffineTransform(pts1, pts2)
# Apply affine transformation

transformed_image = cv2.warpAffine(image, M, (image.shape[1],
image.shape[0]))

cv2.imshow('Affine Transformation',
20. cv2.getPerspectiveTransfo
rm
Computes the perspective transformation matrix from four pairs of points.
Usage:
import cv2
import numpy as
np
# Read an image
image =
# Define the points for perspective transformation

pts1 = np.float32([[50, 50], [200, 50], [50, 200], [200,
200]])
pts2 = np.float32([[10, 100], [200, 50], [100, 250], [300,
# Compute the perspective transformation

matrix
M = cv2.getPerspectiveTransform(pts1, pts2)
# Apply perspective
transformation
transformed_image = cv2
.warpPerspective(image, M, (image.shape[1],
image.shape[0]))

cv2.imshow('Perspective Transformation',
21. cv2.dilat
e
Applies the dilation operation to an image.
Usage:
import cv2
import numpy as
np
# Read an image
# Define the kernel

kernel = np.ones((5, 5),
np.uint8)
# Apply dilation
dilated_image = cv2.dilate(image, kernel,
iterations=1)

cv2.imshow('Dilated Image',
dilated_image) cv2.waitKey(0)
22. cv2.erod
e
Applies the erosion operation to an image.
Usage:
import cv2
import numpy as
np
# Read an image
# Define the kernel

np.uint8)
# Apply erosion
eroded_image = cv2.erode(image, kernel,
iterations=1)

cv2.imshow('Eroded Image',
eroded_image) cv2.waitKey(0)
23. cv2.morphologyE
x
Applies advanced morphological transformations to an image.
Usage:
import cv2
import numpy as
np
# Read an image
# Define the kernel

np.uint8)
# Apply morphological transformations

morph_image = cv2.morphologyEx(image, cv2.MORPH_OPEN,
kernel)

cv2.imshow('Morphological Transformations',
morph_image) cv2.waitKey(0)
24. cv2.threshol
d
Applies a fixed-level threshold to an image.
Usage:
import
cv2
# Read an image
# Apply threshold
_, thresh_image = cv2.threshold(image, 127, 255,
cv2.THRESH_BINARY)

cv2.imshow('Threshold Image',
thresh_image) cv2.waitKey(0)
25. cv2.adaptiveThresho
ld
Applies an adaptive threshold to an image.
Usage:
import
cv2
# Read an image
# Apply adaptive threshold

adaptive_thresh_image = cv2.adaptiveThreshold(image, 255,
cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, 11, 2)

cv2.imshow('Adaptive Threshold Image',
adaptive_thresh_image) cv2.waitKey(0)
26. cv2.equalizeHis
t
Equalizes the histogram of a grayscale image.
Usage:
import
cv2
# Read an image
# Equalize histogram
equalized_image =
cv2.equalizeHist(image)

cv2.imshow('Equalized Image',
equalized_image) cv2.waitKey(0)
27. cv2.calcHis
t
Computes the histogram of an image.
Usage:
import cv2
import matplotlib.pyplot as
plt
# Read an image
# Compute histogram
hist = cv2.calcHist([image], [0], None, [256], [0,
256])
# Plot
histogram
plt.plot(hist)
plt.show()
28. cv2.compareHis
t
Compares two histograms.
Usage:
import
cv2
# Read two images

image1 = cv2.imread('path/to/image1.jpg',
cv2.IMREAD_GRAYSCALE) image2 =
cv2.imread('path/to/image2.jpg', cv2.IMREAD_GRAYSCALE)
# Compute histograms
hist1 = cv2.calcHist([image1], [0], None, [256], [0,
256])
hist2 = cv2.calcHist([image2], [0], None, [256], [0,
# Compare histograms
comparison = cv2.compareHist(hist1, hist2,
cv2.HISTCMP_CORREL)
print('Histogram Comparison Result:',

comparison)
29. cv2.matchTemplat
e
Compares a template image with a source image using a specific method.
Usage:
import
cv2
# Read the source image

source_image =
cv2.imread('path/to/source_image.jpg')
# Read the template image

template_image =
cv2.imread('path/to/template_image.jpg')
# Perform template matching

result = cv2.matchTemplate(source_image, template_image,
cv2.TM_CCOEFF_NORMED)
# Get the location of the best match

min_val, max_val, min_loc, max_loc =
cv2.minMaxLoc(result)
# Draw a rectangle around the matched region

top_left = max_loc
bottom_right = (top_left[0] + template_image.shape[1], top_left[1] +
template_image.shape[0]) cv2.rectangle(source_image, top_left, bottom_right, (0, 255,
0), 2)
cv2.imshow('Matched Template',
source_image) cv2.waitKey(0)
30. cv2.VideoCaptur
e
Opens a video file or a capturing device.
Usage:
import
cv2
# Open a video file

cap =
cv2.VideoCapture('path/to/video.mp4')
while cap.isOpened():
ret, frame =
cap.read() if not ret:
break
cv2.imshow('Video', frame)
if cv2.waitKey(1) & 0xFF ==
ord('q'): break
cap.release()
cv2.destroyAllWindows
()
31. cv2.VideoWrite
r
Writes video frames to a video file.
Usage:
import
cv2
# Define the codec and create VideoWriter object

fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('output.avi', fourcc, 20.0, (640,
480))
# Open a video file

cap =
ret, frame =
break
out.write(frame)
cv2.imshow('Video', frame)
ord('q'): break
cap.release()
out.release()
32. cv2.calcOpticalFlowPyr
LK
Computes dense optical flow using the Lucas-Kanade method.
Usage:
import cv2
import numpy as np
# Read the first frame

cap =
cv2.VideoCapture('path/to/video.mp4') ret,
old_frame = cap.read()
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)
# Parameters for Lucas-Kanade optical flow

lk_params = dict(winSize=(15, 15),
maxLevel=2,
criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))
# Detect corners to track

feature_params = dict(maxCorners=100, qualityLevel=0.3, minDistance=7,
blockSize=7) p0 = cv2.goodFeaturesToTrack(old_gray, mask=None,
**feature_params)
# Create a mask image for drawing

purposes mask =
np.zeros_like(old_frame)
ret, frame =
break
frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# Calculate optical flow

p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params)
# Select good points

good_new = p1[st == 1]
good_old = p0[st == 1]
# Draw the tracks

for i, (new, old) in enumerate(zip(good_new,
good_old)): a, b = new.ravel()
c, d = old.ravel()
mask = cv2.line(mask, (a, b), (c, d), (0, 255, 0), 2)
frame = cv2.circle(frame, (a, b), 5, (0, 255, 0),
-1) img = cv2.add(frame, mask)
cv2.imshow('Optical Flow', img)

ord('q'): break
# Update the previous frame and previous
points old_gray = frame_gray.copy()
p0 = good
_new.reshape(-1, 1,
2)
cap.release()
()
33. cv2.calcOpticalFlowFarneba
ck
Computes dense optical flow using the Farneback method.
Usage:
import cv2
import numpy as np
# Open a video file

cap = cv2.VideoCapture('path/to/video.mp4')
ret, frame1 = cap.read()

prvs = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
ret, frame2 =
break
next = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
# Calculate optical flow

flow = cv2.calcOpticalFlowFarneback(prvs, next, None, 0.5, 3, 15, 3, 5, 1.2, 0)
# Convert the flow to HSV color

space hsv = np.zeros_like(frame1)
hsv[..., 1] = 255
mag, ang = cv2.cartToPolar(flow[..., 0], flow[...,
1]) hsv[..., 0] = ang * 180 / np.pi / 2
hsv[..., 2] = cv2.normalize(mag, None, 0, 255,
cv2.NORM_MINMAX) rgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
cv2.imshow('Optical Flow', rgb)

ord('q'): break
prvs = next
cap.release()
34. cv2.dnn.readNe
t
Reads a deep learning network model from a file.
Usage:
import
cv2
# Load a pre-trained model

net = cv2.dnn.readNet('path/to/model.caffemodel',
'path/to/model.prototxt')
# Read an image
image =
# Prepare the image for the model

blob = cv2.dnn.blobFromImage(image, scalefactor=1.0, size=(224, 224), mean=(104,
117, 123))
# Set the input to the

model
net.setInput(blob)
# Perform forward
pass
output =
print(output
)
35. cv2.dnn.blobFromIma
ge
Converts an image to a blob for input into a deep learning network.
Usage:
import
cv2
# Read an image
image =
# Convert the image to a blob

117, 123))
print(blob.shape
)
36. cv2.dnn_Net.forwa
rd
Runs a forward pass of the deep learning network.
Usage:
import
cv2
# Load a pre-trained model

net = cv2.dnn.readNet('path/to/model.caffemodel',
'path/to/model.prototxt')
# Read an image
image =
# Prepare the image for the model

117, 123))
# Set the input to the

model
net.setInput(blob)
# Perform forward
pass
output =
print(output
)
37. cv2.CascadeClassifi
er
Detects objects using a cascade classifier.
Usage:
import
cv2
# Load the cascade classifier

face_cascade =
cv2.CascadeClassifier('path/to/haarcascade_frontalface_default.xml')
# Read an image
image = cv2.imread('path/to/image.jpg')
gray_image = cv2.cvtColor(image,
cv2.COLOR_BGR2GRAY)
# Detect faces
faces = face_cascade.detectMultiScale(gray_image, scaleFactor=1.1,
minNeighbors=5)
# Draw rectangles around the faces

for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x+w, y+h), (255, 0,
0), 2)

cv2.imshow('Detected Faces',
38. cv2.face.LBPHFaceRecognizer_cre
ate
Creates an LBPH face recognizer.
Usage:
import
cv2
# Create an LBPH face recognizer

recognizer =
cv2.face.LBPHFaceRecognizer_create()
# Train the recognizer with training data

# recognizer.train(training_images,
training_labels)
# Save the trained model

#
recognizer.save('lbph_model.yml')
# Load the trained model

recognizer.read('lbph_model.yml
')
# Recognize faces
# label, confidence =
recognizer.predict(test_image)
39. cv2.face.FisherFaceRecognizer_cre
ate
Creates a Fisher face recognizer.
Usage:
import
cv2
# Create a Fisher face recognizer

recognizer =
cv2.face.FisherFaceRecognizer_create()

training_labels)

#
recognizer.save('fisher_model.yml')

recognizer.read('fisher_model.yml
')
# Recognize faces
40. cv2.face.EigenFaceRecognizer_cre
ate
Creates an Eigen face recognizer.
Usage:
import
cv2
# Create an Eigen face recognizer

recognizer =
cv2.face.EigenFaceRecognizer_create()

training_labels)

#
recognizer.save('eigen_model.yml')

recognizer.read('eigen_model.yml
')
# Recognize faces
41. cv2.bgsegm.createBackgroundSubtractor
MOG
Creates a MOG background subtractor.
Usage:
import
cv2
# Create a MOG background subtractor

background_subtractor =
cv2.bgsegm.createBackgroundSubtractorMOG()
# Open a video file

cap =
ret, frame =
break
fg_mask =
background_subtractor.apply(frame)
cv2.imshow('Foreground Mask',
fg_mask)
ord('q'): break
cap.release()
()
42. cv2.bgsegm.createBackgroundSubtractorM
OG2
Creates a MOG2 background subtractor.
Usage:
import
cv2
# Create a MOG2 background subtractor

cv2.createBackgroundSubtractorMOG2()
# Open a video file

cap =
ret, frame =
break
fg_mask =
fg_mask)
ord('q'): break
cap.release()
()
KNN
Creates a KNN background subtractor.
Usage:
import
cv2
# Create a KNN background subtractor

cv2.createBackgroundSubtractorKNN()
# Open a video file

cap =
ret, frame =
break
fg_mask =
fg_mask)
ord('q'): break
cap.release()
()
GMG
Creates a GMG background subtractor.
Usage:
import
cv2
# Create a GMG background subtractor

cv2.bgsegm.createBackgroundSubtractorGMG()
# Open a video file

cap =
ret, frame =
break
fg_mask =
fg_mask)
ord('q'): break
cap.release()
()
45. cv2.FastFeatureDetector_crea
te
Creates a FAST feature detector.
Usage:
import
cv2
# Create a FAST feature detector

fast =
cv2.FastFeatureDetector_create()
# Read an image
# Detect keypoints
keypoints = fast.detect(image,
None)
# Draw keypoints
image_with_keypoints =
cv
2.drawKeypoints(image, keypoints, None, color=(255,

0, 0))

cv2.imshow('FAST Keypoints',
image_with_keypoints) cv2.waitKey(0)
46. cv2.ORB_creat
e
Creates an ORB feature detector and descriptor extractor.
Usage:
import
cv2
# Create an ORB
detector
orb = cv2.ORB_create()
# Read an image
# Detect keypoints and descriptors

keypoints, descriptors = orb.detectAndCompute(image,
None)
# Draw keypoints
image_with_keypoints = cv2.drawKeypoints(image, keypoints, None, color=(255,
0, 0))

cv2.imshow('ORB Keypoints',
47. cv2.SIFT_creat
e
Creates a SIFT feature detector and descriptor extractor.
Usage:
import
cv2
# Create a SIFT
detector
sift =
# Read an image

keypoints, descriptors = sift.detectAndCompute(image,
None)
# Draw keypoints
0, 0))

cv2.imshow('SIFT Keypoints',
48. cv2.SURF_creat
e
Creates a SURF feature detector and descriptor extractor.
Usage:
import
cv2
# Create a SURF
detector
surf =
# Read an image

keypoints, descriptors = surf.detectAndCompute(image,
None)
# Draw keypoints
0, 0))

cv2.imshow('SURF Keypoints',
49. cv2.BRISK_creat
e
Creates a BRISK feature detector and descriptor extractor.
Usage:
import
cv2
# Create a BRISK
detector
brisk =
# Read an image

keypoints, descriptors = brisk.detectAndCompute(image,
None)
# Draw keypoints
0, 0))

cv2.imshow('BRISK Keypoints',
50. cv2.drawKeypoint
s
Draws keypoints on an image.
Usage:
import
cv2
# Read an image
# Create a feature
detector
orb = cv2.ORB_create()
# Detect keypoints
keypoints = orb.detect(image,
None)
# Draw keypoints
0, 0))

cv2.imshow('Keypoints',
Mini Computer Vision Project
Use Case 1: Object Detection using YOLO
import cv2
# Load YOLO
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")
layer_names = net.getLayerNames()
output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]
# Load image
img = cv2.imread("image.jpg")
height, width, channels =
img.shape
# Detecting objects
blob = cv2.dnn.blobFromImage(img, 0.00392, (416, 416), (0, 0, 0), True,
crop=False) net.setInput(blob)
outs = net.forward(output_layers)
# Showing information on the

screen class_ids = []
confidences = []
boxes = []
for out in outs:
for detection in out:
scores =
detection[5:]
class_id =
np.argmax(scores)
confidence =
scores[class_id] if
confidence > 0.5:
# Object detected
center_x = int(detection[0] *
width) center_y = int(detection[1]
* height) w = int(detection[2] *
width)
h = int(detection[3] * height)
# Rectangle coordinates
x = int(center_x - w /
2) y = int(center_y - h
/ 2)
boxes.append([x, y, w, h])
confidences.append(float(confidence))
class_ids.append(class_id)
indexes = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)

font = cv2.FONT_HERSHEY_PLAIN
for i in
range(len(boxes)): if
i in indexes:
x, y, w, h = boxes[i]
label = str(classes[class_ids[i]])
color = colors[i]
cv2.rectangle(img, (x, y), (x + w, y + h), color,
2)
cv2.imshow("Image",
img)
cv2.waitKey(0)
cv2.destroyAllWindows(
Use Case 2: Semantic Segmentation using DeepLabV3
import cv2
# Load DeepLabV3 model

net = cv2.dnn.readNetFromTensorflow("deeplabv3.pb")
# Load image
image = cv2.imread("image.jpg")
# Prepare the image

blob = cv2.dnn.blobFromImage(image, scalefactor=1.0, size=(513, 513), mean=(104.00698793,
116.6687
# Set the input

net.setInput(blob)
# Perform forward
pass output =
net.forward()
# Process the output

output = output.squeeze().argmax(axis=0)
output = cv2.resize(output, (image.shape[1], image.shape[0]))
# Apply color map

output_colored = cv2.applyColorMap(output.astype(np.uint8), cv2.COLORMAP_JET)

cv2.imshow("Semantic Segmentation", output_colored)
cv2.waitKey(0)
Use Case 3: Gesture Recognition using MediaPipe
import cv2
import mediapipe as mp
mp_hands = mp.solutions.hands
mp_drawing =
mp.solutions.drawing_utils
# Initialize MediaPipe Hands

hands = mp_hands.Hands(static_image_mode=False, max_num_hands=2,
min_detection_confidence=0.5, min
# Open video capture

cap = cv2.VideoCapture(0)
ret, frame =
break
# Convert the frame to RGB

rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# Process the frame

result = hands.process(rgb_frame)
# Draw hand landmarks

if result.multi_hand_landmarks:
for hand_landmarks in result.multi_hand_landmarks:
mp_drawing.draw_landmarks(frame, hand_landmarks,
mp_hands.HAND_CONNECTIONS)

cv2.imshow('Hand Gesture Recognition',
frame) if cv2.waitKey(1) & 0xFF ==
ord('q'):
break
cap.release()
Use Case 4: Image Recognition using InceptionV3
import
cv2
# Load InceptionV3 model

net =
cv2.dnn.readNetFromTensorflow("inceptionv3.pb")
# Load image
image =
cv2.imread("image.jpg")
# Prepare the image

117, 123))
# Set the input

net.setInput(blob
)
# Perform forward
pass
output =
# Get the predicted

class
class_id =

print("Predicted Class ID:",
class_id)
Use Case 5: Face Detection using Haar Cascades
import cv2

face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

ret, frame =
break
Convert the frame to grayscale

gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# Detect faces
faces = face_cascade.detectMultiScale(gray_frame, scaleFactor=1.1, minNeighbors=5)
# Draw rectangles around the

faces for (x, y, w, h) in faces:
cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)

cv2.imshow('Face Detection',
frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
Use Case 6: Real-time Object Tracking using GOTURN Tracker
import cv2
# Load the GOTURN tracker

tracker = cv2.TrackerGOTURN_create()

ret, frame = cap.read()
# Define the initial bounding

box bbox = cv2.selectROI(frame,
False)
# Initialize the tracker

tracker.init(frame, bbox)
ret, frame =
break
# Update the tracker

success, bbox = tracker.update(frame)
# Draw the bounding

box if success:
p1 = (int(bbox[0]), int(bbox[1]))
p2 = (int(bbox[0] + bbox[2]), int(bbox[1] +
bbox[3])) cv2.rectangle(frame, p1, p2, (0, 255,
0), 2, 1)
else:
cv2.putText(frame, "Tracking failure detected", (100, 80),
cv2.FONT_HERSHEY_SIMPLEX, 0.75,

cv2.imshow('Object Tracking',
ord('q'):
break
cap.release()
Use Case 7: Background Subtraction using KNN
import
cv2
# Create a KNN background subtractor

cv2.createBackgroundSubtractorKNN()

cap =
cv2.VideoCapture(0)
ret, frame =
cap.read() if not
ret:
# Apply background subtraction

fg_mask =

cv2.imshow('Background Subtraction',
fg_mask) if cv2.waitKey(1) & 0xFF ==
ord('q'):
cap.release()
()
Use Case 8: Lane Detection in a Video
import cv2
import numpy as np
def region_of_interest(img, vertices):

mask = np.zeros_like(img)
cv2.fillPoly(mask, vertices, 255)
masked = cv2.bitwise_and(img,
mask) return masked
def draw_lines(img, lines):

for line in lines:
for x1, y1, x2, y2 in line:
cv2.line(img, (x1, y1), (x2, y2), (0, 255, 0), 3)

cap = cv2.VideoCapture('path/to/video.mp4')
ret, frame =
break
# Convert the frame to grayscale

gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

blur = cv2.GaussianBlur(gray, (5, 5), 0)

edges = cv2.Canny(blur, 50,
150)
# Define region of interest

height, width =
frame.shape[:2]
roi_vertices = [(0, height), (width / 2, height / 2), (width,
height)] roi = region_of_interest(edges, np.array([roi_vertices],
np.int32))
# Detect lines using Hough Transform

lines = cv2.HoughLinesP(roi, 1, np.pi / 180, 100, minLineLength=40, maxLineGap=5)
# Draw the lines on the

frame if lines is not None:
draw_lines(frame, lines)
cv2.imshow('Lane Detection',
frame)
ord('q'):
break
cap.release()
()
Use Case 9: Real-time Face Recognition using LBPH
import cv2
# Load the LBPH face recognizer

recognizer = cv2.face.LBPHFaceRecognizer_create()
recognizer.read('lbph_model.yml')


ret, frame =
break

# Detect faces
for (x, y, w, h) in
faces: # Recognize
the face
label, confidence = recognizer.predict(gray_frame[y:y+h, x:x+w])
# Draw a rectangle around the face

cv2.putText(frame, f'ID: {label}, Confidence: {confidence}', (x, y-10),
cv2.FONT_HERSHEY_S

cv2.imshow('Face Recognition',
ord('q'):
break
cap.release()
Use Case 10: Real-time Emotion Detection using FER2013
import cv2
import numpy as np
from keras.models import load_model
# Load the pre-trained emotion detection

model emotion_model =
load_model('fer2013_model.h5')
emotion_labels = ['Angry', 'Disgust', 'Fear', 'Happy', 'Sad', 'Surprise', 'Neutral']


ret, frame =
break

# Detect faces

# Extract the face region of interest
roi_gray = gray_frame[y:y+h, x:x+w]
roi_gray = cv2.resize(roi_gray, (48,
48)) roi_gray = roi_gray / 255.0
roi_gray = np.expand_dims(roi_gray,
axis=0) roi_gray =
np.expand_dims(roi_gray, axis=-1)
# Predict the emotion

emotion_prediction =
emotion_model.predict(roi_gray) max_index =
np.argmax(emotion_prediction)
emotion = emotion_labels[max_index]
# Draw a rectangle around the face

cv2.putText(frame, emotion, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0),
2)
cv2.imshow('Emotion Detection',
ord('q'):
brea
k
cap.release()
()
Use Case 11: Road Sign Detection using HOG and SVM
import
cv2
# Load pre-trained HOG + SVM model for road sign

detection
hog = cv2.HOGDescriptor()
svm = cv2.ml.SVM_load('road_sign_svm_model.yml')
# Load image
image =
cv2.imread('road_sign.jpg')
# Convert image to grayscale

gray = cv2.cvtColor(image,
cv2.COLOR_BGR2GRAY)
# Detect road signs using HOG + SVM

_, hog_features = hog.compute(gray)
result = svm.predict(hog_features.reshape(1,
-1))
# Display result
if result[1][0] == 1:
cv2.putText(image, 'Road Sign Detected', (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,
255, 0), 2
cv2.imshow('Road Sign Detection',

image)
cv2.waitKey(0)
Use Case 12: Person Re-identification using Deep Learning
import cv2
import numpy as np
# Load pre-trained deep learning model for person re-

identification net = cv2.dnn.readNet('person_reid_model.onnx')
# Load images of the person to be re-identified

image1 = cv2.imread('person1.jpg')
image2 = cv2.imread('person2.jpg')
# Prepare images for the model

blob1 = cv2.dnn.blobFromImage(image1, scalefactor=1.0, size=(128, 256), mean=(0, 0, 0),
swapRB=Tru blob2 = cv2.dnn.blobFromImage(image2, scalefactor=1.0, size=(128, 256), mean=(0,
0, 0), swapRB=Tru
# Set the inputs

net.setInput(blob1)
output1 = net.forward()
net.setInput(blob2)
output2 = net.forward()
# Compute the cosine similarity between the two feature vectors

similarity = np.dot(output1, output2.T) / (np.linalg.norm(output1) *
np.linalg.norm(output2))

print('Similarity:', similarity)
Use Case 13: Scene Text Detection using EAST Detector
import cv2
# Load the pre-trained EAST text detector

net = cv2.dnn.readNet('frozen_east_text_detection.pb')
# Load image
image =
cv2.imread('scene_text.jpg') orig
= image.copy()
(H, W) = image.shape[:2]
# Prepare the image

blob = cv2.dnn.blobFromImage(image, 1.0, (W, H), (123.68, 116.78, 103.94), swapRB=True,
crop=False net.setInput(blob)
(scores, geometry) = net.forward(['feature_fusion/Conv_7/Sigmoid',
'feature_fusion/concat_3'])
# Decode the results

(num_rows, num_cols) =
scores.shape[2:4] rects = []
confidences = []
for y in range(0, num_rows):

scores_data = scores[0, 0, y]
x_data0 = geometry[0, 0, y]
angles_data = geometry[0, 4,
y]
for x in range(0,
num_cols): if
scores_data[x] < 0.5:
continue
(offset_x, offset_y) = (x * 4.0, y *

4.0) angle = angles_data[x]
cos =
np.cos(angle) sin
= np.sin(angle)
h = x_data0[x] +
x_data2[x] w = x_data1[x]
+ x_data3[x]
end_x = int(offset_x + (cos * x_data1[x]) + (sin *
x_data2[x])) end_y = int(offset_y - (sin * x_data1[x]) +
(cos * x_data2[x])) start_x = int(end_x - w)
start_y = int(end_y - h)
rects.append((start_x, start_y, end_x, end_y))

confidences.append(scores_data[x])
# Apply non-maxima suppression to suppress weak, overlapping
bounding boxes
boxes = non_max_suppression(np.array(rects), probs=confidences)
# Draw the bounding boxes

for (start_x, start_y, end_x, end_y) in boxes:
cv2.rectangle(orig, (start_x, start_y), (end_x, end_y), (0, 255,
0), 2)

cv2.imshow('Text Detection',
orig) cv2.waitKey(0)
Use Case 14: Real-time Head Pose Estimation
import cv2
import numpy as np
# Load the pre-trained face detection model

# Load the pre-trained head pose estimation

model net =
cv2.dnn.readNet('head_pose_estimation.onnx')

ret, frame =
break

# Detect faces

# Extract the face region of
interest roi = frame[y:y+h, x:x+w]
blob = cv2.dnn.blobFromImage(roi, 1.0, (64, 64), (0, 0, 0), swapRB=True,
crop=False)
# Perform head pose estimation

net.setInput(blob)
output = net.forward()
yaw, pitch, roll = output[0]
# Draw the head pose on the frame

cv2.putText(frame, f'Yaw: {yaw:.2f}, Pitch: {pitch:.2f}, Roll: {roll:.2f}', (x, y-
10), cv2 cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)

cv2.imshow('Head Pose Estimation',
ord('q'):
break
cap.release()
Use Case 15: Image Inpainting using Deep Learning
import cv2
import numpy as np
# Load the pre-trained inpainting model

net = cv2.dnn.readNet('image_inpainting.onnx')
# Load image with damaged areas

image = cv2.imread('damaged_image.jpg')
mask = cv2.imread('mask.jpg', 0)
# Prepare the image and mask for the model

blob_image = cv2.dnn.blobFromImage(image, 1.0, (512, 512), (0, 0, 0), swapRB=True,
crop=False)
blob_mask = cv2.dnn.blobFromImage(mask, 1.0, (512, 512), (0, 0, 0), swapRB=True,
crop=False)
# Set the inputs

net.setInput(blob_image,
'input_image')
net.setInput(blob_mask,
'input_mask')
# Perform inpainting
output =
net.forward()
# Post-process the output

output = output.squeeze().transpose(1, 2, 0)
output = np.clip(output, 0,
255).astype(np.uint8)

cv2.imshow('Inpainted Image',
output) cv2.waitKey(0)
Use Case 16: Optical Character Recognition (OCR) using
Tesseract
import cv2
import
pytesseract
# Load image
image =
cv2.imread('document.jpg')
# Convert image to grayscale

gray = cv2.cvtColor(image,
cv2.COLOR_BGR2GRAY)
# Apply thresholding
_, thresh = cv2.threshold(gray, 150, 255,
cv2.THRESH_BINARY_INV)
# Apply dilation
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3,
3)) dilated = cv2.dilate(thresh, kernel, iterations=1)
# Extract text using Tesseract OCR

text =
pytesseract.image_to_string(dilated)
print('Extracted Text:',
text)
Use Case 17: Real-time Drowsiness Detection using Eye Aspect
Ratio
import cv2
import dlib
from scipy.spatial import distance
def eye_aspect_ratio(eye):
A = distance.euclidean(eye[1], eye[5])
B = distance.euclidean(eye[2], eye[4])
C = distance.euclidean(eye[0],
eye[3]) ear = (A + B) / (2.0 * C)
return ear
# Load pre-trained models

detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')
# Define thresholds
EYE_AR_THRESH = 0.3
EYE_AR_CONSEC_FRAMES = 48
# Initialize
counters counter = 0

ret, frame =
break
gray = cv2.cvtColor(frame,
cv2.COLOR_BGR2GRAY) faces = detector(gray)
for face in faces:

landmarks = predictor(gray, face)
left_eye = []
right_eye = []
for i in range(36, 42):
left_eye.append((landmarks.part(i).x,
landmarks.part(i).y)) for i in range(42, 48):
right_eye.append((landmarks.part(i).x, landmarks.part(i).y))
left_ear = eye_aspect_ratio(left_eye)
right_ear = eye_aspect_ratio(right_eye)
ear = (left_ear + right_ear) /
2.0
if ear < EYE_AR_THRESH:

counter += 1
if counter >= EYE_AR_CONSEC_FRAMES:
cv2.putText(frame, "DROWSINESS DETECTED", (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 1, (
else:
counter = 0
cv2.imshow('Drowsiness Detection',
frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
()
Use Case 18: Real-time Fire Detection using Color Thresholding
import cv2
import numpy as np

cap = cv2.VideoCapture('fire_video.mp4')
ret, frame =
break
# Convert the frame to HSV color space

hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# Define fire color range in HSV

lower_fire = np.array([18, 50, 50])
upper_fire = np.array([35, 255, 255])
# Apply color thresholding

mask = cv2.inRange(hsv, lower_fire, upper_fire)

cv2.imshow('Fire Detection',
mask)
ord('q'): break
cap.release()
Use Case 19: Real-time Smoke Detection using Color and Motion
import cv2
import numpy as np

cap = cv2.VideoCapture('smoke_video.mp4')
# Initialize background subtractor

background_subtractor = cv2.createBackgroundSubtractorMOG2()
ret, frame =
break

# Apply background subtraction

fg_mask = background_subtractor.apply(gray)
# Define smoke color range in

grayscale lower_smoke =
np.array([100]) upper_smoke =
np.array([255])
# Apply color thresholding

mask = cv2.inRange(fg_mask, lower_smoke, upper_smoke)

cv2.imshow('Smoke Detection',
mask) if cv2.waitKey(1) & 0xFF ==
ord('q'):
break
cap.release()
Use Case 20: Real-time Vehicle Detection using HOG and SVM
import cv2
# Load pre-trained HOG + SVM model for vehicle

detection hog = cv2.HOGDescriptor()
svm = cv2.ml.SVM_load('vehicle_svm_model.yml')

cap = cv2.VideoCapture('vehicle_video.mp4')
ret, frame =
break

# Detect vehicles using HOG + SVM

_, hog_features = hog.compute(gray)
result = svm.predict(hog_features.reshape(1, -1))
# Draw bounding box around detected

vehicles if result[1][0] == 1:
cv2.putText(frame, 'Vehicle Detected', (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,
255, 0),

cv2.imshow('Vehicle Detection',
ord('q'):
break
cap.release()
Follow me on
Sumit Khanna for more updates

opencv cheatsheet

Uploaded by

Copyright:

Available Formats

opencv cheatsheet

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

opencv cheatsheet

Uploaded by

Copyright:

Available Formats

Python

Sumit Khanna for more updates

OpenCV CheatSheet & Comprehensive

Cheat Sheet Table

Method Name Definition

cv2.imread Reads an image from a file.

cv2.imwrite Writes an image to a file.

cv2.imshow Displays an image in a window.

cv2.cvtColor Converts an image from one color space to

cv2.Canny Applies the Canny edge detector to an image.

Detects lines in a binary image using the Hough

Detects circles in a binary image using the

cv2.findContours Finds contours in a binary image.

cv2.drawContours Draws contours on an image.

cv2.rectangle Draws a rectangle on an image.

cv2.circle Draws a circle on an image.

cv2.line Draws a line on an image.

cv2.putText Puts text on an image.

cv2.resize Resizes an image to the specified dimensions.

cv2.warpAffine Applies an affine transformation to an image.

cv2.warpPerspective Applies a perspective transformation to an

Computes the affine transformation matrix from

Computes the perspective transformation

cv2.dilate Applies the dilation operation to an image.

cv2.erode Applies the erosion operation to an image.

Applies advanced morphological

cv2.threshold Applies a fixed-level threshold to an image.

cv2.adaptiveThreshold Applies an adaptive threshold to an image.

cv2.equalizeHist Equalizes the histogram of a grayscale image.

cv2.calcHist Computes the histogram of an image.

cv2.compareHist Compares two histograms.

Compares a template image with a source

cv2.VideoCapture Opens a video file or a capturing device.

cv2.VideoWriter Writes video frames to a video file.

Computes dense optical flow using the Lucas-

Computes dense optical flow using the

cv2.dnn.readNet Reads a deep learning network model from a

cv2.dnn_Net.forward Runs a forward pass of the deep learning

cv2.face.LBPHFaceRecognizer_create Creates an LBPH face recognizer.

cv2.face.FisherFaceRecognizer_create Creates a Fisher face recognizer.

cv2.face.EigenFaceRecognizer_create Creates an Eigen face recognizer.

cv2.bgsegm.createBackgroundSubtractorMOG Creates a MOG background subtractor.

cv2.bgsegm.createBackgroundSubtractorMOG Creates a MOG2 background subtractor.

cv2.bgsegm.createBackgroundSubtractorKNN Creates a KNN background subtractor.

cv2.bgsegm.createBackgroundSubtractorGMG Creates a GMG background subtractor.

cv2.FastFeatureDetector_create Creates a FAST feature detector.

Creates an ORB feature detector and descriptor

Creates a SIFT feature detector and

Creates a SURF feature detector and descriptor

Creates a BRISK feature detector and descriptor

cv2.drawKeypoints Draws keypoints on an image.

# Display the image

# Write the image to a new file

# Display the image

# Convert the image to grayscale

# Display the grayscale image

# Apply Gaussian blur

# Display the blurred image

# Apply Canny edge detector

# Display the edges