Computer Vision Interview Questions – Core Concepts to Advanced Techniques

This is one of the most common practical gotchas in OpenCV: for historical reasons, cv2.imread (and the rest of OpenCV's I/O and drawing functions) represent color images as BGR, not RGB, while essentially every other Python imaging tool — matplotlib, PIL, most deep learning frameworks' preprocessing — expects RGB. The pixel data itself is correct; only the channel order disagrees with what the consumer expects, so red and blue visually swap wherever the true color would show red or blue. The fix is a single cv2.cvtColor(img, cv2.COLOR_BGR2RGB) before handing the array to anything BGR-unaware. imshow performs no image inversion or forced grayscale (b, c, d are invented), and JPEG channel order is fixed by the format, not randomized (b).

The pinhole camera model is the most basic image-formation model: light from a scene passes through a single infinitesimal aperture (the pinhole) and projects onto an image plane, producing an inverted image. Because the aperture is a point, no lens-based focusing, blur, or lens distortion is involved — every scene point maps to exactly one image-plane point along a straight ray.

The kernel [[1,0],[0,-1]] subtracts the bottom-right element of each 2×2 patch from the top-left element. For every patch: (0,0)→1−5=−4, (0,1)→2−6=−4, (1,0)→4−8=−4, (1,1)→5−9=−4. The 2×2 output is all −4.

This design exercise tests foundational knowledge of data augmentation for CNN image classification. The rubric rewards selecting appropriate techniques with per-technique justification, understanding pipeline structure, justifying exclusions, and connecting augmentation to overfitting reduction.

This exercise tests whether a candidate can reason about data augmentation in a domain-specific way, recognizing that techniques valid for natural images (flips, color jitter) can be inappropriate or even label-changing for handwritten digits, and that even appropriate augmentations carry digit-specific risks (such as 6/9 confusion under rotation) that require concrete mitigations.

Semantic segmentation is a dense per-pixel classification task: every pixel gets a class label ('person', 'road', 'sky'), and every pixel belonging to the same class looks identical in the output regardless of which specific object it belongs to — three overlapping people all just become one connected blob of 'person' pixels. Instance segmentation adds object-level identity on top of that: it produces a separate mask per detected object instance, so the three people come out as three distinct masks even though they're all the same class and standing next to each other. Architectures like Mask R-CNN do this by first detecting individual object instances (like an object detector) and then predicting a segmentation mask within each detected box, rather than segmenting the whole image at once. Neither task is inherently tied to image color mode or resolution (b, c are invented), and the distinction between 'what class' and 'which specific instance' is a real, load-bearing one in both research and interviews (d is false).

True. Canny edge detection works by finding pixels where intensity changes sharply — computing gradients and thresholding them. Raw sensor noise creates small, random intensity fluctuations that look like sharp local gradients too, so an unblurred image produces a scattering of tiny false edges wherever noise happens to spike. A Gaussian blur smooths those small fluctuations out before the gradient computation runs, so the edges that survive are the genuine, larger-scale structural boundaries in the scene rather than noise. This is exactly why Canny's own classic formulation includes a Gaussian smoothing step as its first stage, and why OpenCV tutorials on edge detection routinely blur first.

cv2.imread and cv2.rectangle both operate in OpenCV's BGR channel order, so after line 5 img is a correctly-drawn image whose pixel data is still BGR. plt.imshow — like nearly every other Python imaging tool — assumes RGB input, so it interprets the blue channel's values as if they were red and vice versa, which is exactly the blue-skin-tone symptom described: the actual red channel gets displayed in blue's position. The fix is img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) before line 6 (drawing with cv2.rectangle can happen on either the BGR or converted array, since the color tuple would just need swapping too, but converting once right before display is simplest). cv2.rectangle accepts a BGR tuple exactly as written, not a hex string (b is invented); cv2.imread reads .jpg files natively — it's one of the most common formats it supports (c is invented); and plt.savefig writes whatever colors imshow is currently displaying, performing no automatic grayscale conversion (d is invented).

IoU is the shared vocabulary underneath both detection evaluation (mAP) and detection post-processing (NMS), which is why it's foundational rather than a niche metric.

Intrinsic parameters describe the camera's internal imaging geometry and remain fixed regardless of where the camera is in the world. This includes the focal lengths (fx, fy), the principal point (cx, cy), and lens distortion coefficients such as the radial terms k1, k2, k3. The rotation matrix R and translation vector t relate the world coordinate frame to the camera coordinate frame and vary with camera pose — they are extrinsic, not intrinsic.

Max pooling must select the maximum value within each pooling window. Line 12, out[i, j] = np.min(region), calls np.min(region), which returns the minimum value instead of the maximum. Every other line — output dimension calculation (lines 5–6), window slicing (lines 10–11), and iteration (lines 8–9) — is correct. Changing np.min to np.max on line 12 fixes the function.

The Sobel-x kernel detects vertical edges by differencing the right column from the left column, with the center row weighted twice as heavily. Computing the element-wise product and summing: the left column contributes (-1·10) + (-2·10) + (-1·10) = -40, and the right column contributes (1·50) + (2·50) + (1·50) = 200. The middle column is all zeros in the kernel. So the result is -40 + 200 = 160. This large positive value correctly signals a strong vertical edge (intensity jumps from 10 to 50) in the patch.

A detector's raw output routinely contains many boxes around the same object, because nearby anchors or regions all fire on it. NMS resolves this by sorting candidate boxes by confidence, keeping the top one, computing IoU between it and every remaining box, discarding any whose IoU exceeds the threshold (they're judged to be describing the same object), and repeating with the next-highest surviving box until none are left. This produces one detection per real object instead of a cluster of near-duplicates. Averaging boxes together (b) would blur a tight prediction with looser ones and ignore confidence entirely; discarding the most confident box (c) inverts the actual logic — high confidence is evidence for keeping a box, not against it; and NMS never changes confidence scores (d) — it only decides which boxes to keep or drop.

The core architectural split is real: two-stage detectors like Faster R-CNN separate 'where might an object be' (region proposals) from 'what is it, exactly' (per-proposal classification and box refinement), while one-stage detectors like YOLO and SSD collapse both into one dense pass over a feature grid (a). That extra stage costs time, which is why one-stage detectors have historically been the default choice when real-time inference matters (b), and why two-stage detectors have historically tended to edge out one-stage detectors on localization accuracy, since each proposal gets dedicated refinement computation rather than sharing a single dense prediction pass (e) — though modern one-stage architectures have narrowed that gap considerably. Both families train end-to-end with backpropagation; the region proposal network in a two-stage detector is itself a trainable CNN component, not a hand-coded step outside the gradient (c is false). And nothing about a single dense prediction pass limits a one-stage detector to one class — YOLO and SSD both predict a full class distribution per anchor/cell, handling arbitrarily many classes (d is false).

False, as of current OpenCV. SIFT's original patent expired in March 2020, and OpenCV moved the SIFT implementation out of the patent-gated opencv_contrib/xfeatures2d module and into the main features2d module starting with the 4.4.0 release. Since then, cv2.SIFT_create() is available in the standard opencv-python package with no special non-free build flag required — the restriction this question describes was real, but only for OpenCV releases before 4.4.0. This is a good example of why version-pinning matters for anything patent- or license-adjacent: advice that was correct a few years ago ('SIFT needs the non-free contrib build') is now actively wrong guidance if followed against a current release.

The mechanism is that labeled training data is finite and augmentation is a cheap way to synthetically expand its effective diversity without collecting or labeling anything new: every augmented copy of an image is a free additional training example that teaches the model the same class label under slightly different conditions. This directly targets overfitting — a model trained only on a narrow slice of poses/lighting/crops can latch onto incidental patterns specific to that slice rather than the actual class-defining features, and augmentation forces it to find features that survive the perturbation. Strong answers name augmentations appropriate to the actual task and domain (flips are fine for most photos but wrong for, say, digit or text recognition, where a flipped '6' becomes a '9' or flipped text becomes unreadable) — that judgment call is itself a signal of real understanding versus rote recall.

Radial (and tangential) distortion coefficients describe a physical property of the lens, not the scene geometry or camera pose. In standard calibration pipelines (e.g., Zhang's method as implemented in OpenCV), they are treated as additional intrinsic parameters and jointly optimized alongside the focal length, principal point, and skew term.

Standard camera calibration solves for the camera's intrinsic matrix — focal length (fx, fy) and principal point (cx, cy) that describe how the lens projects 3D points onto the 2D sensor (a) — and the lens distortion coefficients that model radial and tangential distortion, which is exactly what lets cv2.undistort correct future frames (b). Because the calibration routine doesn't know the checkerboard's real-world pose in advance, it also solves for per-image extrinsics: the rotation and translation that would place the checkerboard where it actually was relative to the camera in each calibration shot (c). What it does not give you is the real-world size of an arbitrary unknown object later photographed with no other reference — a single monocular image has an inherent scale ambiguity, since an object could be twice as big and twice as far away and produce an identical projection; recovering true physical scale needs either a known reference object in the scene, stereo/multi-view geometry, or a depth sensor, none of which calibration alone provides (d is false). And 'distortion-free with zero post-processing' also isn't what calibration gives you — the distortion coefficients let you correct an image after the fact via cv2.undistort, they don't make the raw sensor output itself already distortion-free (e is false).

The intersection rectangle's corners are computed correctly (the inner-max/inner-min logic in lines 5-8 is exactly right for finding where two rectangles overlap), but the code never guards against the case where the boxes don't actually overlap at all. When they don't, inter_x2 ends up smaller than inter_x1 (or the y-equivalent), which makes inter_width or inter_height negative — and multiplying two negative-capable values without clamping produces a negative inter_area, which is nonsensical for boxes that share no pixels and should have an intersection of exactly 0. The standard fix is inter_width = max(0, inter_x2 - inter_x1) and the same for height, so a non-overlapping pair correctly yields inter_area = 0 and iou = 0.0 instead of a negative number. Union is correctly computed by adding both box areas and subtracting the intersection once, since otherwise the overlapping region would be double-counted — subtracting it is required, not a bug (b is backwards). The min/max assignment in lines 5-8 is standard and correct for finding a rectangle intersection, not swapped (c). And IoU is defined as intersection over union, not intersection alone — dividing by intersection area alone would always return 1.0 for any overlap, however small, which defeats the entire point of the metric (d is false).

Each stage's input is the previous stage's output, which is what makes this a pipeline rather than a set of independent steps. The backbone runs first because every later stage operates on its extracted features rather than raw pixels. The RPN needs that feature map to propose 'where an object might be,' since it can't propose regions before there's anything to scan. RoI pooling/align only makes sense once actual proposals exist — it's the operation that turns each variable-sized proposed region into a fixed-size feature vector the classification head can consume. The classification/box-regression head then runs per-region, predicting what each proposal actually is and refining its box. Only after every region has a class and a (possibly overlapping) box does NMS have anything to deduplicate — it's the final cleanup step that turns a dense, redundant set of per-region predictions into the clean, one-box-per-object list the detector actually reports.

The standard camera model (e.g., Zhang 2000, OpenCV's projectPoints) proceeds in a fixed order: (1) the extrinsic parameters R and t convert a world point to the camera coordinate frame; (2) perspective division by the depth Z projects the 3D camera-frame point onto the normalized image plane (x = X/Z, y = Y/Z); (3) the lens distortion model — radial (k1, k2, k5…) and tangential (p1, p2) — is applied to these normalized coordinates, because distortion is naturally expressed in the normalized plane before any scaling by focal length; (4) the intrinsic matrix K (focal length, principal point, skew) maps the undistorted normalized coordinates to final pixel values (u, v). Each stage's input is the output of the preceding stage, so the order is strict and universally agreed upon in the camera-calibration literature.

This is a staff-level question because it requires reasoning about why an architectural choice exists, not just naming it. The core tension: classification wants abstraction (throw away spatial detail, keep semantic meaning), segmentation wants both abstraction and precise spatial localization, and a plain deep CNN's downsampling path only optimizes for the former. U-Net's skip connections are the direct fix — they let information that would otherwise be permanently lost at each downsampling step re-enter the decoder at the matching resolution, so the final full-resolution prediction has access to both 'what' (from deep features) and 'where, precisely' (from shallow features carried across the skip connection). A strong answer explicitly connects the downsampling-loses-detail problem to the skip-connection mechanism that restores it, rather than treating them as two unrelated facts about U-Net.

Trace the receptive field incrementally. Start: RF = 1, jump = 1. Layer 1 (k=3, d=1, s=1): RF = 1 + (3−1)·1·1 = 3, jump = 1·1 = 1. Layer 2 (k=3, d=2, s=1): RF = 3 + (3−1)·2·1 = 3 + 4 = 7, jump = 1. Layer 3 (k=3, d=4, s=1): RF = 7 + (3−1)·4·1 = 7 + 8 = 15. Because all strides are 1, the cumulative jump factor stays 1, so only the dilation rates drive the incremental growth. The doubling dilation pattern causes the receptive field to grow exponentially with the number of layers — the key motivation behind dilated (atrous) convolutions in architectures like DeepLab, which achieve large context windows without increasing parameter count or sacrificing spatial resolution.

Luo et al. (2016, NeurIPS) analyzed the ERF of randomly initialized CNNs and showed that the influence of input pixels on a given output pixel follows a Gaussian (normal) distribution centered at the output's spatial location. The standard deviation of this Gaussian grows as O(√d), where d is the network depth, meaning the ERF — the region that actually matters in practice — grows far more slowly than the theoretical RF (which grows linearly as O(d·w)). Concretely, doubling the depth only increases the ERF width by a factor of √2, not 2. This sub-linear growth motivates techniques like dilated convolutions, global average pooling, skip connections, and self-attention, all of which enlarge the effective context more efficiently than naively stacking more convolutional layers.

In Zhang's method the homography H = [h₁ h₂ h₃] = K[r₁ r₂ t] relates the planar pattern to the image. Because r₁ and r₂ are orthonormal columns of a rotation matrix, we get r₁ᵀr₂ = 0 and ‖r₁‖ = ‖r₂‖. Substituting r₁ = λK⁻¹h₁ and r₂ = λK⁻¹h₂ yields h₁ᵀK⁻ᵀK⁻¹h₂ = 0 and h₁ᵀK⁻ᵀK⁻¹h₁ = h₂ᵀK⁻ᵀK⁻¹h₂. The matrix ω = K⁻ᵀK⁻¹ is the image of the absolute conic (IAC), which is invariant across all views since it depends only on intrinsics. Solving the linear system for ω and then applying Cholesky decomposition to ω⁻¹ recovers K.