Top 9 Most Tricky Interview Questions on OpenCV for Computer Vision in 2026

If you‘re interviewing for a computer vision developer or engineer role in 2024, chances are you‘ll be asked about your experience with OpenCV. OpenCV (Open Source Computer Vision Library) is an open-source library of programming functions primarily aimed at real-time computer vision. It‘s used extensively in companies, research groups and governmental bodies for applications like facial recognition, object detection, motion tracking, and more.

As computer vision continues to advance and find new use cases, from self-driving cars to medical imaging to robotics, demand for OpenCV skills will only grow. Whether you‘re a new graduate or an experienced developer, brushing up on these commonly asked OpenCV interview questions will help you prepare and stand out.

Let‘s dive in to the top 9 questions!

1. What are the most commonly used image filters in OpenCV and how do they work?

OpenCV provides several built-in image filter functions to smooth, blur, sharpen or otherwise transform an image. Understanding how these filters work and when to use them is a fundamental OpenCV skill. The most common filters are:

• Averaging (Box Blur): Takes the average of all the pixels under the kernel area and replaces the central element. Useful for removing noise.
• Gaussian Blur: Uses a Gaussian kernel to convolve the image. Removes high frequency components and noise while preserving edges better than averaging.
• Median Blur: Computes the median of all the pixels under the kernel window and the central pixel is replaced with this median value. Highly effective at removing salt-and-pepper style noise.
• Bilateral Filter: Combines range and domain filtering to average pixels based on both spatial closeness and intensity similarity. Smooths images while preserving edges.

Here‘s a code example showing how to apply each filter in OpenCV:

import cv2

img = cv2.imread(‘image.jpg‘)

# Averaging
blur = cv2.blur(img,(5,5))

# Gaussian Blur 
gblur = cv2.GaussianBlur(img,(5,5),0)

# Median Blur
median = cv2.medianBlur(img,5)

# Bilateral Filter
bfilter = cv2.bilateralFilter(img,9,75,75)

2. What are some common video analysis tasks in OpenCV?

In addition to working with static images, OpenCV provides functions for video stream processing. Some common video analysis tasks include:

Frame differencing – compare adjacent frames to detect motion or changes
Background subtraction – separate moving foreground objects from static background
Optical flow – estimate motion of objects between frames
Object tracking – localize and follow moving objects across frames
Face/pedestrian detection – identify and count humans

Here‘s an example of frame differencing to detect motion:

import cv2

cap = cv2.VideoCapture("video.mp4")

ret, frame1 = cap.read()
ret, frame2 = cap.read()

while cap.isOpened():

    diff = cv2.absdiff(frame1, frame2)
    gray = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)
    blur = cv2.GaussianBlur(gray, (5,5), 0)
    _, thresh = cv2.threshold(blur, 20, 255, cv2.THRESH_BINARY)
    dilated = cv2.dilate(thresh, None, iterations=3)
    contours, _ = cv2.findContours(dilated, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

    for contour in contours:
        (x, y, w, h) = cv2.boundingRect(contour)
        if cv2.contourArea(contour) < 900:
            continue
        cv2.rectangle(frame1, (x, y), (x+w, y+h), (0, 255, 0), 2)

    cv2.imshow("Video", frame1)
    frame1 = frame2
    ret, frame2 = cap.read()

    if cv2.waitKey(40) == 27:
        break

cv2.destroyAllWindows()
cap.release()

This detects contours of moving objects and draws bounding boxes around them.

3. What does cv_8uc1 mean in OpenCV?

cv_8uc1 is one of OpenCV‘s type codes that specify the color depth and number of channels in an image. It stands for:

8u: unsigned 8-bit integers (0-255)
c1: 1 channel (grayscale)
So an image loaded as cv_8uc1 will be represented as a 2D array of bytes with values between 0-255, with a single channel.

Other common type codes are:

• cv_8uc3: unsigned 8-bit integers with 3 channels (BGR color image)
• cv_32fc1: 32-bit floating point with 1 channel
• cv_64fc1: 64-bit floating point with 1 channel

You can check the type and shape of a loaded image like:

img = cv2.imread(‘image.jpg‘, cv2.IMREAD_GRAYSCALE)
print(img.dtype) # uint8
print(img.shape) # (480, 640) for 640x480 grayscale

color_img = cv2.imread(‘image.jpg‘)
print(color_img.shape) # (480, 640, 3) for 640x480 color

4. How can you enhance the quality of images using OpenCV?

Image enhancement aims to improve an image‘s quality, visual appearance, or suitability for further processing. The specific techniques depend on the issue you‘re trying to correct, like noise, blur, low contrast, etc. Some common enhancement methods in OpenCV are:

Histogram equalization – improves contrast by spreading out intensity values over the full range
Noise removal – remove noise with blurring techniques like gaussian blur, median blur or non-local means denoising
Sharpening – highlight edges with filters like unsharp mask or Laplacian
Color correction – adjust white balance, saturation, etc.
Super resolution – use deep learning models like ESPCN to increase resolution

For example, here‘s how to apply histogram equalization:

img = cv2.imread(‘low_contrast_image.jpg‘, cv2.IMREAD_GRAYSCALE)

eq_hist = cv2.equalizeHist(img)

cv2.imshow(‘Original‘, img) 
cv2.imshow(‘Histogram equalized‘, eq_hist)

5. Why is image transformation an important step in computer vision tasks?

Image transformation is the process of changing an image‘s geometry – rotating, scaling, skewing, or otherwise distorting it. Transformations are a critical preprocessing step in many computer vision pipelines in order to:

Correct for distortions from the camera lens or viewing angle
Align or register multiple images
Fit images to a canonical size for CNN input
Augment training data (rotate, flip, scale images)

Some common OpenCV functions for transformations are:

• resize() for scaling
• rotate() for rotation
• warpAffine() for general affine transformations like translate, rotate, scale, shear
• warpPerspective() for perspective transformations
• remap() for applying a custom mapping to each pixel

For example, you can correct perspective distortion like this:

import numpy as np 
import cv2

img = cv2.imread("receipt.jpg")

points1 = np.float32([[325,50], [760,50], [325,470], [760,470]]) 
points2 = np.float32([[0,0], [400,0], [0,600], [400,600]])

matrix = cv2.getPerspectiveTransform(points1, points2)
result = cv2.warpPerspective(img, matrix, (400,600))

cv2.imshow("Original", img)
cv2.imshow("Perspective Transform", result)

6. What is image rectification and what are some use cases?

Image rectification is the process of transforming multiple images onto a common image plane and scaling, as if they were captured by the same camera. It‘s commonly used in stereo vision to align left and right camera views for depth estimation.

The key steps are:

1. Find corresponding feature points between the two views
2. Estimate the fundamental matrix that relates the two views
3. Estimate homographies to warp each view to the common plane
4. Re-project images onto the new plane and crop to overlapping FOV

Some applications of rectification are:

Stereo depth mapping for 3D reconstruction
Multi-view stitching and 3D panoramas
Satellite/aerial imagery alignment

OpenCV provides a stereoRectify() function to compute the transforms and initUndistortRectifyMap()/remap() to apply them.

7. How do you train a custom Haar Cascade classifier?

While OpenCV comes with pre-trained classifiers for faces, eyes, smiles, etc., you can also train your own custom object detector using the Haar Cascade method. The key steps are:

1. Gather "positive" images containing the object and "negative" images without it. Positives all need to be the same size.
2. Create a text file listing the paths to all positive images.
3. Use the opencv_createsamples tool to generate a positive vector file from your images.
4. Train the classifier with opencv_traincascade, passing it the positive vector file, negative images, and other parameters.
5. Test your classifier with opencv_visualisation or a custom script.

The training process can be quite involved, requiring thousands of labeled images and significant processing time. There are also many parameters to tune, like the number of training stages, feature types, and sizes.

However, the resulting classifier will be able to detect your custom object in new images very quickly using Haar-like features and a cascade of boosted classifiers.

8. How does the Viola-Jones face detection algorithm work?

Published in 2001, the Viola-Jones algorithm was a pioneering approach that enabled real-time face detection. It uses Haar-like features and a cascade of increasingly complex classifiers to quickly discard non-face regions and hone in on face rectangles.

The key insights were:

1. Haar-like features (edge, line, center-surround patterns) could effectively encode facial structure
2. These features can be computed very quickly using an integral image
3. Using AdaBoost to select the best features and training a cascade of classifiers allows quickly discarding non-faces

At each stage in the cascade, a classifier is trained to detect almost all faces while rejecting a certain fraction of non-faces. Positive results from the first classifier trigger the second classifier and so on. Objects that pass through all stages are classified as faces.

While more modern face detectors using deep learning have surpassed Viola-Jones in accuracy, the core concepts of feature selection, boosting, and cascading are still relevant today.

9. What‘s the difference between erosion and dilation in image morphology?

Erosion and dilation are two fundamental operations in morphological image processing, used for tasks like removing noise, isolating individual elements, and finding intensity bumps or holes.

Erosion erodes away the boundaries of foreground objects, removing small white noises and detaching connected objects. The value of the output pixel is the minimum value of all the pixels in the neighborhood.

Dilation is the opposite – it increases the white region and tends to smooth concavities in objects. The value of the output pixel is the maximum value of all the pixels in the neighborhood.

The amount of erosion or dilation is controlled by the size and shape of the structuring element (kernel) and the number of iterations.

Here‘s an example of applying erosion and dilation to a binary image:

import cv2
import numpy as np

img = cv2.imread(‘binary_image.jpg‘, cv2.IMREAD_GRAYSCALE)

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

erosion = cv2.erode(img, kernel, iterations=1) 
dilation = cv2.dilate(img, kernel, iterations=1)

cv2.imshow(‘Original‘, img) 
cv2.imshow(‘Erosion‘, erosion) 
cv2.imshow(‘Dilation‘, dilation)

Erosion shrinks the foreground (white) regions while dilation expands them. Opening (erosion followed by dilation) can remove small noise while closing (dilation followed by erosion) can fill small holes.

Bonus: General Interview Tips

In addition to brushing up on these specific OpenCV concepts, here are a few general tips to ace your computer vision interview:

1. Practice coding on a whiteboard or in a simple text editor without autocomplete. Be prepared to write syntactically correct code without the help of an IDE.

2. Always explain your thought process out loud as you work through a problem. Even if you don‘t arrive at a complete solution, the interviewer wants to understand your approach.

3. Don‘t be afraid to ask clarifying questions if a problem seems vague or if you need more context. It shows you can think critically and gather requirements.

4. Take time to consider edge cases, error handling, and performance for your solution. How would it scale to larger inputs? How robust is it?

5. Have a couple of substantial computer vision projects in your portfolio that you can discuss in depth. Be ready to explain your design choices and results.

6. Familiarize yourself with other relevant libraries beyond just OpenCV like TensorFlow, PyTorch, dlib, scikit-image, etc. and when you might choose one over another.

Armed with a solid foundation in these OpenCV concepts and techniques, plenty of hands-on practice, and a passion for the field, you‘ll be well-prepared for your next computer vision interview. Best of luck!