Computer Vision Engineer interview questions

A color image is usually a height by width by channels array whose dtype defines how pixel values are stored.

• A 480 by 640 RGB image commonly has shape (480, 640, 3), with one value per red, green, and blue channel at each pixel.
• uint8 images normally use integers from 0 to 255, while model inputs often use float32 values from 0 to 1.
• Converting to float without scaling leaves values up to 255, and converting out-of-range floats to uint8 can clip or wrap values.

HSV or Lab can be more useful than RGB when the task benefits from separating brightness from chromatic information.

• HSV separates hue and saturation from value, so saturated-color rules can tolerate moderate brightness changes better than raw RGB channel cutoffs.
• Lab separates lightness in L from the opponent-color channels a and b, which helps with color-distance comparisons or lightness normalization.
• Neither space is automatically illumination invariant: hue is unstable at low saturation and strong color casts still shift values, so I validate the choice under target lighting.

I preserve the aspect ratio and choose interpolation based on whether I am shrinking or enlarging.

• For a fixed model input, I can letterbox the image with padding or resize then center-crop instead of stretching it.
• Area interpolation is a good default for shrinking, while bilinear or bicubic interpolation is typical for enlarging photographs.
• Bounding boxes, masks, and keypoints must receive the same scale and crop, with nearest-neighbor interpolation used for class masks.

Image coordinates usually start at the top-left, with x increasing right and y increasing downward.

• NumPy indexes a pixel as image[y, x], so swapping x and y is a common source of incorrect crops.
• An affine transform preserves parallel lines and covers translation, rotation, scaling, and shear using three point pairs.
• A perspective transform uses four point pairs and can rectify a tilted document, and its matrix must also be applied to annotations.

CNN and OpenCV APIs commonly call this operation convolution, although they usually slide the kernel without flipping it, which is mathematical cross-correlation.

• At each position, the kernel weights produce a local weighted sum that can smooth the image or respond to patterns such as edges.
• True mathematical convolution flips the kernel across both spatial axes before sliding it; the distinction disappears for symmetric kernels.
• In a CNN, kernel weights are learned from data, so the network can learn the needed orientation, unlike a fixed filter whose convention must be known.

Blur kernels average nearby pixels, while edge kernels respond to rapid intensity changes.

• A Gaussian blur uses larger weights near the center and can reduce sensor noise before thresholding or edge detection.
• Sobel kernels estimate horizontal and vertical gradients, whose magnitude highlights likely boundaries.
• Stronger blur suppresses fine edges too, so kernel size and sigma should match the scale of noise and details.

An image histogram counts how many pixels fall into each intensity or color-value bin.

• A grayscale histogram concentrated near zero indicates a mostly dark image, while a wide distribution usually means more tonal contrast.
• Color images can have separate channel histograms, but those counts do not preserve where pixels occur.
• Histogram equalization can spread intensities to improve contrast, although it may amplify noise or alter an already good image.

I would start with a global threshold and move to data-driven or local thresholds when lighting makes one cutoff unreliable.

• A global threshold marks pixels above one fixed value, which works for a bright object on a uniform dark background.
• Otsu's method selects a global cutoff from the histogram when foreground and background form two useful groups.
• Adaptive thresholding computes cutoffs over local neighborhoods and is often better for a document with uneven illumination.

Morphological operations reshape binary regions using a small structuring element.

• Erosion removes boundary pixels and can eliminate tiny white specks, while dilation expands white regions and can bridge small gaps.
• Opening applies erosion then dilation to remove small foreground noise without permanently shrinking larger objects as much.
• Closing applies dilation then erosion to fill small holes or breaks, with the kernel shape setting which structures are affected.

Contours are ordered boundary points extracted from connected shapes, usually in a binary image.

• I first threshold or segment the image because contour extraction expects a clear foreground mask.
• From a contour I can compute area, perimeter, centroid, or an axis-aligned bounding rectangle.
• Filtering contours by area can remove small noise, but touching objects may appear as one contour unless separated first.

A keypoint is a repeatable image location, while a descriptor encodes the appearance around that location for matching.

• Corners and blobs make useful keypoints because they are easier to localize than a flat patch or a straight edge.
• ORB produces binary descriptors that can be compared with Hamming distance, while SIFT descriptors use floating-point vectors.
• Matching descriptors between two images can support alignment, but weak matches should be filtered with distance or ratio tests.

The intrinsic matrix K maps normalized camera coordinates (X/Z, Y/Z, 1) to homogeneous pixel coordinates: u = fx·X/Z + cx and v = fy·Y/Z + cy.

• fx and fy express focal length in pixel units, while cx and cy locate the principal point, usually near the image center.
• Lens distortion coefficients are estimated alongside intrinsics but are not entries in the 3 by 3 intrinsic matrix.
• Photographing a known checkerboard from several angles lets OpenCV estimate these values for undistortion or pose work.

Broadcasting lets NumPy apply compatible smaller arrays across image dimensions without explicit Python loops.

• Subtracting an array of shape (3,) from an image of shape (H, W, 3) subtracts one mean per channel.
• Dimensions are compatible when they are equal or one of them is 1, compared from the trailing axis backward.
• I inspect shapes before arithmetic because an accidental (H, W) versus (H, W, 1) mismatch can fail or produce an unintended result.

Tensor strides describe how memory addresses change along each axis, while a contiguous tensor stores values in the standard packed order for its shape.

• Operations such as transpose or permute often return a view with changed strides instead of copying data, so the result may be non-contiguous.
• View and native CPU or GPU code that assumes packed memory may require a contiguous tensor; reshape may return a view or make a copy when needed.
• I inspect strides and contiguity at an API boundary and call contiguous only when required because the copy costs time and memory.

Normalization puts input values on the scale and distribution expected during training.

• A basic pipeline converts uint8 values from 0 to 255 into float32 values from 0 to 1.
• Many pretrained PyTorch models then subtract a channel mean and divide by a channel standard deviation supplied with the weights.
• Training and inference must use the same channel order and normalization, or predictions can degrade even though tensor shapes are correct.

The three splits separate parameter fitting, model selection, and final unbiased evaluation.

• The training set updates weights, while the validation set guides choices such as learning rate, augmentation, and stopping epoch.
• The test set should remain untouched until the approach is fixed, otherwise repeated decisions indirectly tune to it.
• I keep related samples such as frames from one video or images from one patient in the same split.

The label format depends on whether the task predicts classes, boxes, masks, or points.

• Classification may use a CSV mapping image paths to class IDs or one directory per class.
• Detection commonly uses COCO JSON, Pascal VOC XML, or YOLO text files with class and box coordinates.
• Segmentation uses per-pixel mask images or polygons, and I visualize parsed labels over images before training to catch coordinate errors.

I would measure per-class counts and metrics first, then rebalance training without changing the validation distribution.

• A weighted loss can make mistakes on a rare class contribute more than mistakes on a frequent class.
• A weighted sampler or targeted augmentation can show rare examples more often, but heavy duplication may overfit those images.
• I report per-class precision and recall because high overall accuracy can hide failure on the minority class.

I reject an augmentation when it creates an implausible sample or changes the target meaning in a way the labels cannot represent.

• For OCR, a horizontal flip usually creates mirrored text, while a rotation is valid only if that orientation can occur and the recognition target remains defined.
• For directional classes such as left-turn and right-turn signs, a horizontal flip must swap the class; if the pipeline cannot do that reliably, I disable the flip.
• For pose data, a flip must transform coordinates and swap left and right keypoint identities and handedness labels; otherwise it teaches contradictory semantics.

Data leakage occurs when evaluation data or information derived from it influences training.

• Randomly splitting adjacent video frames can put nearly identical images in train and validation, inflating the score.
• Duplicate images, crops from the same source, or photos of the same subject should be grouped before splitting.
• Normalization statistics and preprocessing thresholds learned from data must be fitted on the training split only.