OpenCV 4.

x Cheat Sheet (Python version) Filtering

A summary of: https://docs.opencv.org/master/ i = blur(i, (5, 5)) Filters I with 5 × 5 box filter (i.e. average filter)
i = GaussianBlur(i, (5,5), sigmaX=0, sigmaY=0) Filters I with 5 × 5 Gaussian; auto σs; (I is float)
i = GaussianBlur(i, None, sigmaX=2, sigmaY=2) Blurs, auto kernel dimension
I/O i = filter2D(i, -1, k) Filters with 2D kernel using cross-correlation
kx = getGaussianKernel(5, -1) 1D Gaussian kernel with length 5 (auto StDev)
i = imread("name.png") Loads image as BGR (if grayscale, B=G=R) i = sepFilter2D(i, -1, kx, ky) Filter using separable kernel (same output type)
i = imread("name.png", IMREAD_UNCHANGED) Loads image as is (inc. transparency if available) i = medianBlur(i, 3) Median filter with size=3 (size ≥ 3)
i = imread("name.png", IMREAD_GRAYSCALE) Loads image as grayscale i = bilateralFilter(i, -1, 10, 50) Bilateral filter with σr = 10, σs = 50, auto size
imshow("Title", i) Displays image I
imwrite("name.png", i) Saves image I
Borders
waitKey(500) Wait 0.5 seconds for keypress (0 waits forever) All filtering operations have parameter borderType which can be set to:
destroyAllWindows() Releases and closes all windows BORDER_CONSTANT Pads with constant border (requires additional parameter value)
BORDER_REPLICATE Replicates the first/last row and column onto the padding
Color/Intensity BORDER_REFLECT Reflects the image borders onto the padding
BORDER_REFLECT_101 Same as previous, but doesn’t include the pixel at the border (the default)
i_gray = cvtColor(i, COLOR_BGR2GRAY) BGR to gray conversion BORDER_WRAP Wraps around the image borders to build the padding
i_rgb = cvtColor(i, COLOR_BGR2RGB) BGR to RGB (useful for matplotlib) Borders can also be added with custom widths:
i = cvtColor(i, COLOR_GRAY2RGB) Converts grayscale to RGB (R=G=B) i = copyMakeBorder(i, 2, 2, 3, 1, borderType=BORDER_WRAP) Widths: top, bottom, left, right
i = equalizeHist(i) Histogram equalization
i = normalize(i, None, 0, 255, NORM_MINMAX, CV_8U) Normalizes I between 0 and 255
i = normalize(i, None, 0, 1, NORM_MINMAX, CV_32F) Normalizes I between 0 and 1 Differential operators
∂
i_x = Sobel(i, CV_32F, 1, 0) Sobel in the x-direction: Ix = ∂x I
Other useful color spaces i_y = Sobel(i, CV_32F, 0, 1) Sobel in the y-direction: Iy = ∂y∂
I
i_x, i_y = spatialGradient(i, 3) The gradient: ∇I (using 3 × 3 Sobel): needs uint8 image
COLOR_BGR2HSV BGR to HSV (Hue, Saturation, Value)
m = magnitude(i_x, i_y) ∥∇I∥; Ix , Iy must be float (for conversion, see np.astype())
COLOR_BGR2LAB BGR to Lab (Lightness, Green/Magenta, Blue/Yellow)
m, d = cartToPolar(i_x, i_y) ∥∇I∥; θ ∈ [0, 2π]; angleInDegrees=False; needs float32 Ix , Iy
COLOR_BGR2LUV BGR to Luv (≈ Lab, but different normalization)
l = Laplacian(i, CV_32F, ksize=5) ∆I, Laplacian with kernel size of 5
COLOR_BGR2YCrCb BGR to YCrCb (Luma, Blue-Luma, Red-Luma)
Geometric transforms
Channel manipulation i = resize(i, (width, height)) Resizes image to width×height
i = resize(i, None, fx=0.2, fy=0.1) Scales image to 20% width and 10% height
b, g, r = split(i) Splits the image I into channels
M = getRotationMatrix2D((xc, yc), deg, Returns 2 × 3 rotation matrix M, arbitrary (xc , yc )
b, g, r, a = split(i) Same as above, but I has alpha channel
scale)
i = merge((b, g, r)) Merges channels into image
M = getAffineTransform(pts1,pts2) Affine transform matrix M from 3 correspondences
i = warpAffine(i, M, (cols,rows)) Applies Affine transform M to I, output size=(cols, rows)
Arithmetic operations M = getPerspectiveTransform(pts1,pts2) Perspective transform matrix M from 4 correspondences
i = add(i1, i2) min(I1 + I2 , 255), i.e. saturated addition if uint8 M, s = findHomography(pts1, pts2) Persp transf mx M from all ≫ 4 corresps (Least squares)
i = addWeighted(i1, alpha, i2, beta, gamma) min(αI1 + βI2 + γ, 255), i.e. image blending M, s = findHomography(pts1, pts2, RANSAC) Persp transf mx M from best ≫ 4 corresps (RANSAC)
i = subtract(i1, i2) max(I1 − I2 , 0), i.e. saturated subtraction if uint8 i = warpPerspective(i, M, (cols, rows)) Applies perspective transform M to image I
i = absdiff(i1, i2) |I1 − I2 |, i.e. absolute difference Interpolation methods
Note: one of the images can be replaced by a scalar.
resize, warpAffine and warpPerspective use bilinear interpolation by default. It can be changed by
parameter interpolation for resize, and flags for the others:
Logical operations flags=INTER_NEAREST Simplest, fastest (or interpolation=INTER_NEAREST)
i = bitwise_not(i) Inverts every bit in I (e.g. mask inversion) flags=INTER_LINEAR Bilinear interpolation: Default
i = bitwise_and(i1, i2) Logical and between I1 and I2 (e.g. mask image) flags=INTER_CUBIC Bicubic interpolation
i = bitwise_or(i1, i2) Logical or between I1 and I2 (e.g. merge 2 masks) Segmentation
i = bitwise_xor(i1, i2) Exclusive or between I1 and I2
_, i_t = threshold(i, t, 255, THRESH_BINARY) Manually thresholds image I given threshold level t
t, i_t = threshold(i, 0, 255, THRESH_OTSU) Returns thresh level and thresholded image using Otsu
Statistics i_t = adaptiveThreshold(i, 255,
mB, mG, mR, mA = mean(i) Average of each channel (i.e. BGRA) ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, b, c) Adaptive mean-c with block size b and constant c
ms, sds = meanStdDev(i) Mean and SDev p/channel (3 or 4 rows each) bp = calcBackProject([i_hsv], [0,1], h, Back-projects histogram h onto the image i_hsv
h = calcHist([i], [c], None, [256], [0,256]) Histogram of channel c, no mask, 256 bins (0-255) [0,180, 0,256], 1) using only hue and saturation; no scaling (i.e. 1)
h = calcHist([i], [0,1], None, [256,256], 2D histogram using channels 0 and 1, with cp, la, ct = kmeans(feats, K, None, crit, 10, Returns the labels la and centers ct of K clusters,
[0,256, 0,256]) “resolution” 256 in each dimension KMEANS_RANDOM_CENTERS) best compactness cp out of 10; 1 feat/column
Features Calibration and Stereo
e = Canny(i, tl, th) Returns the Canny edges (e is binary) r, crns = findChessboardCorners(i, (n_x,n_y)) 2D coords of detected corners; i is gray; r is
l = HoughLines(e, 1, pi/180, 150) Returns all (ρ, θ) ≥ 150 votes, Bin res: ρ = 1 pix, θ = 1 deg the status; (n_x, n_y) is size of calib target
l = HoughLinesP(e, 1, pi/180, 150, crnrs = cornerSubPix(i, crns, (5,5), (-1,-1), crit) Improves coordinates with sub-pixel accuracy
None, 100, 20) Probabilistic Hough, min length=100, max gap=20 r, K, D, ExRs, ExTs = calibrateCamera(crns_3D, Calculates intrinsics (inc. distortion coeffs), &
c = HoughCircles(i, HOUGH_GRADIENT, 1, Returns all (xc , yc , r) with at least 18 votes, bin resolution=1, crns_2D, i.shape[:2], None, None) extrinsics (i.e. 1 R+T per target view); crns_3D
minDist=50, param1=200, param2=18, param1 is the th of Canny, and the centers must be at least contains 1 array of 3D corner coords p/target
minRadius=20, maxRadius=60) 50 pixels away from each other view; crns_2D contains the respective arrays of
r = cornerHarris(i, 3, 5, 0.04) Harris corners’ Rs per pixel, window=3, Sobel=5, α = 0.04 2D corner coordinates (i.e. 1 crns p/target view)
f = FastFeatureDetector_create() Instantiates the Star feature detector drawChessboardCorners(i, (n_x, n_y), crns, r) Draws corners on I (may be color); r is status
k = f.detect(i, None) Detects keypoints on grayscale image I from corner detection
i_k = drawKeypoints(i, k, None) Draws keypoints k on color image I u = undistort(i, K, D) Undistorts I using the intrinsics
d = xfeatures2d.BriefDescriptorExtractor_create() Instantiates a BRIEF descriptor s = StereoSGBM_create(minDisparity = 0,
k, ds = d.compute(i, k) Computes the descriptors of keypoints k over I numDisparities = 32, blockSize = 11) Instantiates Semi-Global Block Matching method
dd = AKAZE_create() Instantiates the AKAZE detector/descriptor s = StereoBM_create(32, 11) Instantiates a simpler block matching method
m = BFMatcher.create(NORM_HAMMING, Instantiates a brute-force matcher, d = s.compute(i_L, i_R) Computes disparity map (∝−1 depth map)
crossCheck=True) with x-checking, and Hamming distance Termination criteria (used in e.g. K-Means, Camera calibration)
ms = m.match(ds_l, ds_r) Matches the left and right descriptors
crit = (TERM_CRITERIA_MAX_ITER, 20, 0) Stops after 20 iterations
i_m = drawMatches(i_l, k_l, i_r, k_r, ms, None) Draws matches from the left keypoints k_l on
crit = (TERM_CRITERIA_EPS, 0, 1.0) Stop if “movement” is less than 1.0
left image Il to right Ir , using matches ms
crit = (TERM_CRITERIA_MAX_ITER | TERM_CRITERIA_EPS, 20, 1.0) Stops whatever happens first
Detection Useful stuff
ccs = matchTemplate(i, t, TM_CCORR_NORMED) Matches template T to image I (normalized X-correl) Numpy (np.)
m, M, m_l, M_l = minMaxLoc(ccs) Min, max values and respective coordinates in ccs
c = CascadeClassifier() Creates an instance of an “empty” cascade classifier m = mean(i) Mean/average of array I
r = c.load("file.xml") Loads a pre-trained model from file; r is True/False m = average(i, weights) Weighted mean/average of array I
objs = c.detectMultiScale(i) Returns 1 tuple (x, y, w, h) per detected object v = var(i) Variance of array/image I
s = std(i) Standard deviation of array/image I
Motion and Tracking h,b = histogram(i.ravel(),256,[0,256]) numpy histogram also returns the bins b
i = clip(i, 0, 255) numpy’s saturation/clamping function
pts = goodFeaturesToTrack(i, 100, 0.5, 10) Returns 100 Shi-Tomasi corners with, at least, 0.5 i = i.astype(np.float32) Converts the image type to float32 (vs. uint8, float64)
quality, and 10 pixels away from each other x, _, _, _ = linalg.lstsq(A, b) Solves the least squares problem 12 ∥Ax − b∥2
pts1, st, e = calcOpticalFlowPyrLK(i0, i1, New positions of pts from estimated optical i = hstack((i1, i2)) Merges I1 and I2 side-by-side
pts0, None) flow between I0 and I1 ; st[i] is 1 if flow i = vstack((i1, i2)) Merges I1 above I2
for point i was found, or 0 otherwise i = fliplr(i) Flips image left-right
t = TrackerCSRT_create() Instantiates the CSRT tracker i = flipud(i) Flips image up-down
r = t.init(f, bbox) Initializes tracker with frame and bounding box i = pad(i, ((1, 1), (3, 3)), 'reflect') Alternative to copyMakeBorder (also top, bottom, left, right)
r, bbox = t.update(f) Returns new bounding box, given next frame idx = argmax(i) Linear index of maximum in I (i.e. index of flattened I)
r, c = unravel_index(idx, i.shape) 2D coordinate of the index with respect to shape of i
Drawing on the image b = any(M > 5) Returns True if any element in array M is greater than 5
line(i,(x0, y0),(x1, y1), (b, g, r), t) Line b = all(M > 5) Returns True if all elements in array M are greater than 5
rectangle(i, (x0, y0), (x1, y1), (b, g, r), t) Rectangle rows, cols = where(M > 5) Returns indices of the rows and cols where elems in M are >5
circle(i,(x0, y0), radius, (b, g, r), t) Circle coords = list(zip(rows, cols)) Creates a list with the elements of rows and cols paired
polylines(i,[pts], True, (b, g, r), t) Closed (True) polygon (pts is array of points) M_inv = linalg.inv(M) Inverse of M
putText(i, "Hi", (x,y), FONT_HERSHEY_SIMPLEX, rad = deg2rad(deg) Converts degrees into radians
1, (r,g,b), 2, LINE_AA) Writes “Hi” at (x, y), font size=1, thickness=2
Matplotlib.pyplot (plt.)
Parameters imshow(i, cmap="gray", vmin=0, vmax=255) matplotlib’s imshow preventing auto-normalization
(x0, y0) Origin/Start/Top left corner (note that it’s not (row,column)) quiver(xx, yy, i_x, -i_y, color="green") Plots the gradient direction at positions xx, yy
(x1, y1) End/Bottom right corner savefig("name.png") Saves the plot as an image
(b, g, r) Line color (uint8) Copyright © 2019 António Anjos (Rev: 2020-07-01)
t Line thickness (fills, if negative) Most up-to-date version: https://github.com/a-anjos/python-opencv