The Computer Vision Engineer Roadmap

Computer vision is one of the most technically demanding disciplines in software engineering. It sits at the intersection of mathematics, signal processing, machine learning, systems programming, and product engineering. Unlike web development or backend services, where the problem domain is relatively stable, computer vision is a field that has been fundamentally reinvented twice in the last fifteen years — first by deep convolutional networks in 2012, and again by vision transformers and large-scale pretraining after 2020. Engineers who entered the field in 2018 found that half their toolkit had been superseded by 2023.

This roadmap is honest about that instability. It distinguishes between foundational knowledge that has remained stable for decades and framework-level knowledge that changes with every major model release. It is structured as a progression — not because you must complete each stage before touching the next, but because understanding where a concept sits in the stack helps you know how much time to invest in it and how to build on it.

No part of this roadmap will serve you well without a working command of the mathematics that underpins every computer vision algorithm, classical or learned. This is not about academic completeness. It is about having the mental models to debug a model that is not converging, understand why a convolution behaves differently at image borders, or reason about what a matrix decomposition is actually doing to your feature data.

Linear Algebra

Linear algebra is the language of computer vision. Images are matrices. Color channels are vectors. Transformations — rotation, scaling, projection — are matrix multiplications. Neural network layers are compositions of linear maps and nonlinearities. You do not need to be a mathematician, but you need to own these concepts deeply enough to apply them intuitively, not just recall their definitions.

Matrix multiplication should feel like a transformation of space, not just a calculation. When a homography matrix maps one camera view to another, you need to intuit what is happening geometrically — not just know the formula. This intuition is what lets you spot bugs in geometric pipelines without running the code.

Eigenvalues and eigenvectors are the foundation of dimensionality reduction. When you compress a high-dimensional feature space into something manageable, you are finding the directions of maximum variance in your data. Understanding this tells you when compression will preserve discriminative information and when it will destroy it.

Singular Value Decomposition appears everywhere in computer vision: computing the geometric relationship between two camera views, approximating large weight matrices, solving calibration problems. You do not need to implement it from scratch. You need to understand what the decomposition reveals about the structure of your data.

Dot products and cosine similarity are the core operations behind feature matching, similarity search, and the attention mechanism inside every modern vision transformer. If you understand the dot product as measuring alignment between two vectors, the way transformers compute attention scores becomes immediately intuitive.

Calculus and Optimization

Modern computer vision is optimization. Training a neural network is minimizing a loss function over millions of parameters across thousands of iterations. Understanding what gradient descent is actually doing — following the direction of steepest descent on the loss surface — is the difference between an engineer who can diagnose a broken training run and one who can only copy hyperparameters from a paper.

The chain rule is the mechanical basis of backpropagation. You do not need to derive gradients for every layer type by hand, but you should understand why gradients vanish in very deep networks with certain activation functions, and why architectural choices like residual connections were specifically designed to address that.

Convexity and local minima matter because the loss surfaces of deep networks are not bowl-shaped. They are complex, high-dimensional landscapes with many local minima, saddle points, and flat regions. Techniques like batch normalization, weight initialization strategies, and learning rate warmup all exist to make this landscape easier to navigate.

Learning rate schedules are applied optimization theory. A warmup phase prevents early divergence when gradients are noisy and large on randomly initialized weights. Cosine annealing helps escape shallow local minima as training converges. Understanding the intuition behind each schedule lets you make principled choices rather than copying configurations blindly.

Probability and Statistics

Probability distributions underlie every generative model in computer vision. A diffusion model — the technology behind modern image generation — is a learned reversal of a process that progressively adds Gaussian noise to an image. You cannot reason about these architectures without a working model of what a distribution is and what it means to sample from one.

Bayes' theorem is the conceptual foundation of object detection confidence scores. When a detector outputs 90% confidence for a car, that number is an approximation of the posterior probability of the car class given the observed visual features. Understanding this helps you reason about why confidence scores are often poorly calibrated in practice — and what calibration even means.

Information theory basics — entropy, cross-entropy, KL divergence — explain why the loss functions used in computer vision models are the right choices, not arbitrary ones. Cross-entropy loss for classification is the maximum likelihood estimator for a categorical distribution. Understanding this tells you when to use it and when a different loss function is more appropriate for your problem.

The rise of deep learning did not eliminate classical computer vision. It shifted where classical techniques are applied. Today, classical methods handle preprocessing, geometric reasoning, real-time constraints, and edge deployment scenarios where deep models are too slow or too large. An engineer who skipped classical CV to jump straight to deep learning has systematic blind spots that surface at the worst moments in production.

Image Representation and Color Spaces

An image is a three-dimensional array: height × width × channels. Understanding this representation concretely means understanding that a single pixel in an RGB image is a vector of three numbers, that the order of dimensions matters for memory layout and performance, and that pixel values are bounded integers that can silently overflow if you are not careful.

Color space conversions are a surprisingly common source of subtle production bugs. The two traps that catch almost every engineer at least once:

The first is that OpenCV — the most widely used computer vision library — loads images in BGR channel order, not RGB. Every deep learning model trained on standard datasets expects RGB. Feeding a BGR image to an RGB-trained model produces wrong predictions silently, with no error message. The second is that HSV color space separates color (hue) from brightness (value), which makes it useful for color-based detection in varying lighting conditions — but converting to HSV and forgetting to convert back before saving or displaying will produce visually bizarre results that are hard to trace.

Knowing when to use each color space — RGB for model input, HSV for color filtering, grayscale for structure analysis, LAB for perceptual color distance — is a practical skill that saves hours of debugging.

Filtering and Convolution

Convolution is the core operation of both classical image processing and convolutional neural networks. Understanding it in the classical context makes the deep learning version intuitive rather than magical.

Conceptually, a convolution slides a small pattern detector (called a kernel or filter) over an image and computes how strongly that pattern matches the image content at each location. The kernel encodes what the operation detects. A Gaussian kernel smooths the image by averaging nearby pixels, weighted toward the center — useful for reducing noise before edge detection. A Sobel kernel computes the image gradient in a specific direction — it responds strongly where pixel values change rapidly, which is where edges are.

When a convolutional neural network learns a filter in its first layer that activates on horizontal edges, it has discovered something very close to the hand-designed Sobel filter. The difference is that the CNN learned the filter values from data. The conceptual operation is identical. Understanding classical filtering gives you immediate intuition about what learned CNN filters are doing and why the first layers of any vision network respond to edges, textures, and color blobs.

Feature Detection and Description

Classical feature detection solves a fundamental problem: given two photographs of the same scene taken from different angles, at different scales, and under different lighting, how do you find the same physical points in both images?

The answer is to find distinctive image locations — corners, blobs, junctions — that are geometrically stable and to describe the local appearance around each location in a way that is invariant to rotation and scale changes. Algorithms like SIFT, SURF, and ORB each make different tradeoffs between accuracy, speed, and patent restrictions (SIFT and SURF were patented for years, which drove adoption of ORB as a free alternative).

Understanding classical feature descriptors directly prepares you for modern deep learning embeddings. The concept is identical: a compact representation of visual appearance that is invariant to certain transformations. Classical descriptors are hand-engineered to be invariant to rotation and scale. Deep embeddings learn their invariances from data, which makes them more flexible and more powerful — but also more opaque when they fail.

Camera Geometry and Calibration

Camera geometry is the mathematical framework for reasoning about the relationship between the 3D physical world and 2D image coordinates. It is essential for depth estimation, 3D reconstruction, augmented reality, autonomous vehicles, and robotics — essentially any application where understanding spatial structure matters.

The core concept is the camera intrinsic matrix: a compact mathematical object that encodes the focal length of the lens and the position of the image center. Every physical camera has a unique intrinsic matrix. Camera calibration is the process of estimating this matrix from a set of images of a known pattern — typically a checkerboard — by finding the mathematical relationship that best explains how the 3D checkerboard corners project onto 2D image coordinates.

Real lenses also introduce distortion. Wide-angle lenses cause barrel distortion, where straight lines in the world appear curved in the image. Failing to correct for distortion before running a geometric computation introduces systematic errors that accumulate in unpredictable ways. Any pipeline that involves measuring distances, estimating 3D structure, or combining information from multiple cameras must start with calibrated, undistorted images.

This is where the majority of modern computer vision capability lives. Deep learning did not replace the need for classical understanding — it built on top of it. The engineer who understands convolution classically will understand why padding, stride, and dilation work the way they do. The engineer who understands camera geometry classically will understand why monocular depth estimation is a fundamentally ambiguous problem that neural networks can only partially resolve.

Convolutional Neural Networks

The convolutional neural network (CNN) is still the workhorse of production computer vision in constrained environments. It is faster than transformer architectures, more interpretable, better understood in terms of failure modes, and more suitable for deployment on edge hardware with limited memory and compute.

A CNN is organized as a series of layers. The early layers detect simple local patterns — edges, colors, textures. Deeper layers combine those simple detections into increasingly complex structures — shapes, object parts, whole objects. This hierarchical feature extraction is not a design choice specific to any particular CNN architecture. It is an emergent property observed consistently across all CNNs trained on visual data, and it mirrors how neuroscientists understand the visual cortex to process information.

The key architectural choices that determine a CNN's character are backbone depth (how many layers), width (how many filters per layer), and the use of skip connections (direct paths that let gradients flow from deep layers back to early layers without passing through every intermediate layer). ResNet — which introduced skip connections — was the architecture that made very deep networks trainable in practice, and the skip connection pattern has been adopted in virtually every subsequent architecture.

Transfer Learning and Pretrained Backbones

Training a vision model from scratch requires large datasets, significant compute, and weeks of time. Transfer learning short-circuits this by starting from a model that was already trained on a large general dataset — typically ImageNet — and adapting it to your specific task.

The practical workflow is to take a pretrained backbone, freeze its early layers (which contain general-purpose feature detectors that work across tasks), replace the final classification layer with one sized for your number of classes, and fine-tune the whole system on your data with a small learning rate.

The most important decision in transfer learning is how much to freeze. If your target domain looks like natural photographs — which is most product, retail, and consumer applications — you can freeze most of the backbone and fine-tune only the head. If your target domain looks very different from ImageNet — medical imaging, satellite imagery, industrial inspection — the early learned features are less transferable and you benefit from fine-tuning more of the network, or in extreme cases training from scratch on domain-specific data.

Object Detection Architectures

Object detection extends classification by predicting both the class and the bounding box location of every object instance in an image. This seemingly small extension — adding coordinates to the output — requires significant architectural changes and a much more complex training setup.

Modern detectors divide into two families based on how they approach the prediction problem. Two-stage detectors first propose candidate regions of interest, then classify each region independently. This two-pass approach produces higher accuracy but at the cost of speed. Single-stage detectors predict boxes and class probabilities in a single forward pass over the whole image, which makes them faster and simpler to deploy. YOLO and its descendants dominate real-time detection applications. Faster R-CNN and its descendants dominate high-accuracy offline applications.

Understanding detection metrics is as important as understanding the architectures. Mean Average Precision (mAP) is the standard benchmark number, but it is a composite that hides important information. A model with strong overall mAP might have poor recall on small objects, might fail on crowded scenes, or might be well-calibrated at loose overlap thresholds but poor at tight ones. Always evaluate at multiple thresholds and break down performance by object size and class before declaring a model production-ready.

Segmentation

Segmentation assigns a class label to every pixel in an image rather than to the image as a whole. Semantic segmentation labels every pixel with a category — road, sky, pedestrian, vehicle. Instance segmentation goes further and distinguishes between individual object instances — this pixel belongs to pedestrian #1, this pixel belongs to pedestrian #2.

The architectural insight that makes segmentation work is the encoder-decoder structure. The encoder is essentially a CNN backbone that progressively compresses the image into a compact, semantically rich representation — it knows what is in the image but has lost spatial precision. The decoder reverses this process, progressively restoring spatial resolution while using skip connections from the encoder to recover fine-grained boundary information that was lost during compression.

This pattern — deep features for understanding what something is, shallow features for understanding exactly where it is — appears in virtually every modern segmentation architecture. U-Net, introduced for medical image segmentation, popularized this design and remains one of the most widely used architectures in production segmentation systems.

Vision Transformers

The Vision Transformer (ViT) replaced the inductive bias of convolution with the global attention mechanism of the transformer architecture. Instead of processing small local patches with shared filters, ViT divides an image into a grid of patches, treats each patch as a token, and applies self-attention so that every patch can directly attend to every other patch in the image.

This global attention is the key difference. A CNN can only capture long-range spatial relationships by stacking many layers, because each layer only looks at a local neighborhood. A vision transformer captures long-range relationships in every layer, from the first one. This makes ViT particularly strong on tasks where global context matters — understanding the relationship between distant objects, reasoning about scene layout, recognizing objects that are partially occluded.

The tradeoff is data hunger. CNNs have translation equivariance built into their architecture by design — they know that a cat in the top-left corner and a cat in the bottom-right corner are the same kind of object. Vision transformers have no such prior. They must learn spatial regularities entirely from training data, which means they need significantly more data and more compute to reach the same level as a CNN, but they often surpass CNNs given enough of both.

Once you have the foundations and the core deep learning toolkit, you can specialize. Each of the following domains has its own literature, benchmark datasets, and engineering challenges — but all build directly on the prior stages.

Depth Estimation and 3D Vision

Monocular depth estimation — predicting depth from a single RGB image — is fundamentally ambiguous. A small nearby object and a large distant object can project to identical image patches. Deep networks resolve this ambiguity by learning statistical regularities from training data: the sky is usually far away, texture gradients indicate receding surfaces, defocus blur correlates with distance from the focal plane.

Modern monocular depth models like Depth Anything V2 produce impressive relative depth maps — they correctly rank which objects are closer and which are farther — but they cannot produce accurate metric depth (actual distances in meters) without additional calibration information. This distinction matters enormously for applications like autonomous navigation, where the robot needs to know it is 0.8 meters from an obstacle, not just that the obstacle is closer than the wall behind it.

Stereo depth estimation uses two cameras with a known physical separation to compute geometric depth. Because the baseline between cameras is known, depth can be computed from the disparity (pixel offset) between the two views using basic trigonometry. This produces metric depth without any learned priors, at the cost of needing calibrated stereo hardware. LiDAR takes this further by using laser ranging to produce accurate sparse depth measurements, which can then be fused with camera data for dense metric reconstruction.

Face Recognition and Biometrics

Face recognition is a mature deployment domain with a well-established pipeline. Every production face recognition system, regardless of the specific models used, follows the same four steps: detect all faces in the image, align each face to a canonical frontal pose, extract a compact embedding vector that encodes identity, then compare embeddings using cosine similarity to determine whether two faces belong to the same person.

The key training insight behind modern face recognition models is the loss function. Standard cross-entropy loss trains a model to classify training identities, but the resulting embeddings do not generalize well to new identities not seen during training. Metric learning losses — ArcFace, CosFace, AdaFace — explicitly train the embedding space so that same-identity embeddings cluster tightly together and different-identity embeddings are pushed apart. The practical result is dramatically better generalization to unseen faces.

The decision threshold between "same person" and "different person" directly controls the tradeoff between false accepts (claiming two different people are the same) and false rejects (failing to recognize a legitimate user). The right threshold is entirely determined by your application's risk tolerance, not by the model's architecture.

Video Understanding

Video understanding extends image models to the temporal dimension. The core challenge is that processing every frame independently is computationally wasteful — consecutive frames are highly similar — but capturing motion information across frames is what makes video understanding genuinely different from image understanding.

Action recognition is the video equivalent of image classification: given a short video clip, predict what activity is occurring. Temporal models process clips of 8 to 32 frames, using either 3D convolutions that extend spatial filters into the time dimension, or temporal attention mechanisms that learn which frames to attend to when recognizing a particular activity.

Video object tracking — maintaining the identity of detected objects across frames — is a different and harder problem. Objects move, get occluded, change appearance as the viewpoint shifts, and can leave and re-enter the frame. Modern trackers combine detection with appearance matching and motion prediction, using the temporal consistency of motion to maintain object identity even through brief occlusions.

Building a model that works in a notebook is the first 20% of the job. Deploying it reliably, maintaining it over time, and monitoring its behavior in production is the other 80% — and it is consistently underweighted in academic training while being consistently overweighted in production job requirements.

Data Pipeline Engineering

The single most impactful factor in model quality is data quality. This is not a platitude. It is a technical reality that determines your ceiling before you write a single line of model code.

A production computer vision data pipeline must handle four concerns simultaneously. Data collection must be representative of the actual distribution the model will encounter in deployment — a model trained on studio-quality product photos will fail on blurry, poorly-lit photos taken by users on smartphones. Annotation quality must be high and consistent — ambiguous or inconsistent labels are learned as noise and directly reduce model accuracy. Data augmentation must simulate the variability the model will encounter in production — random crops, flips, color jitter, blur, and noise teach the model to be invariant to transformations that do not change the semantic content. And the augmentation pipeline must correctly transform annotations alongside images — a bounding box that no longer points at the right object after a crop or flip produces training examples that actively harm model performance.

Model Optimization for Deployment

A model that achieves state-of-the-art accuracy at 500ms per inference is not a production model for most applications. Real deployments have latency, memory, and energy budgets that require model optimization before deployment, particularly on mobile or edge hardware.

Quantization reduces the numerical precision of model weights from 32-bit floats to 8-bit integers. This halves memory usage twice over and makes arithmetic operations significantly faster on hardware that has native integer compute units (which most modern CPUs and mobile chips do). The accuracy cost is typically negligible for classification and detection models, though it can be more significant for models doing fine-grained regression like keypoint detection or depth estimation.

Knowledge distillation trains a small model (the student) to mimic the behavior of a large model (the teacher), rather than training the small model directly on labels. Because the teacher's soft probability outputs carry more information than hard labels — a teacher that outputs 70% cat, 29% lynx, 1% everything else is communicating structural similarity between classes that a hard label discards — the student trained this way consistently outperforms a student trained directly on labels.

Monitoring and Model Drift

A deployed computer vision model operates on real-world data that shifts over time. Camera hardware is upgraded. Lighting conditions change seasonally. Product catalogs are updated. The distribution of objects the model encounters in production gradually diverges from the distribution it was trained and validated on. This is called distribution shift, and it is the primary cause of silent model degradation in production systems.

The insidious property of distribution shift is that the model keeps producing predictions with high confidence even as those predictions become increasingly unreliable. The model does not know that it has drifted out of its training distribution. Your monitoring system has to tell it — or tell you, so you can act.

Effective monitoring compares the statistical distribution of incoming image features against a reference distribution captured at validation time. A significant divergence is a signal to investigate: check whether the degradation is correlated with a specific data source, a specific camera, a time of day, or a recent deployment change. The appropriate response might be targeted retraining, data collection in the drifted region, or a rollback if the root cause is an upstream data pipeline change.

These are the areas where the field is actively moving. They are not stable enough to be treated as foundational, but they are mature enough to appear in production systems and engineering interviews at senior level.

Foundation Models and Vision-Language Models

Vision-language models (VLMs) connect visual representations to language, enabling open-vocabulary understanding — describing, questioning, and reasoning about image content in natural language rather than fixed class labels. Models like GPT-4V, LLaVA, and Qwen-VL can answer questions about images, describe scenes in detail, identify anomalies, and reason about spatial relationships using free-form text prompts.

The engineering implication of VLMs for production systems is significant. Many tasks that previously required a purpose-built, custom-trained classifier — "is there a person in this image", "does this product have a visible defect", "what text is visible on this sign" — can now be handled with a pretrained VLM and a carefully designed text prompt. This eliminates the data collection, annotation, and training overhead for a class of problems, at the cost of higher inference latency and per-query compute expense compared to a small specialized classifier.

The skill that matters here is prompt engineering for vision tasks: learning which question phrasings produce reliable, consistent outputs, how to structure few-shot examples in the prompt, and how to design evaluation pipelines that catch VLM failures, which tend to be different in character from classical model failures.

Segment Anything and Promptable Segmentation

Meta's Segment Anything Model (SAM) introduced a new interaction paradigm for segmentation: instead of being trained to segment specific object categories, SAM can segment any object in any image given a simple user prompt — a click, a bounding box, or a rough sketch indicating what to segment.

The architectural insight behind SAM is the separation of the image encoder from the prompt encoder and mask decoder. The image encoder runs once per image, producing a rich embedding. The prompt encoder and mask decoder are lightweight and run in milliseconds, meaning interactive segmentation — where a user clicks a point and immediately sees a segmentation mask — is computationally feasible in real time.

SAM 2 extends this to video, propagating segmentation masks across frames given a single-frame prompt. This makes it practically useful for video annotation workflows, where annotators previously had to label every frame manually. With SAM 2, an annotator clicks once on the first frame and the model tracks the object through the rest of the video, with the annotator only intervening to correct errors.

Generative Models in Production CV

Diffusion models — the technology behind Stable Diffusion, DALL-E, and Midjourney — have moved from research curiosity to production tool in the span of three years. For computer vision engineers, the most relevant applications are not image generation for its own sake, but data augmentation, synthetic data generation, and domain adaptation.

The fundamental problem of computer vision data — collecting and annotating enough examples of rare edge cases — can be partially addressed by generating synthetic training examples using a fine-tuned diffusion model. A model trained to generate images of product defects can produce thousands of labeled defect examples to augment a small real dataset. The catch is that synthetic data has its own distribution, and models trained on it must be carefully evaluated to ensure the synthetic distribution is close enough to the real one to transfer.

The computer vision engineer roadmap is not a linear path that terminates. It is a branching tree rooted in mathematics and classical image processing, with the deep learning layer as its trunk, and a growing canopy of specialized domains and frontier capabilities extending outward. The engineers who navigate this field effectively are not the ones who know the most techniques — they are the ones who understand which layer of the stack a problem lives in, which tools are appropriate for that layer, and how stable those tools are likely to remain.

Invest deeply in the foundations. Linear algebra, calculus, camera geometry, and classical filtering are knowledge you accumulate once and use for the rest of your career. Invest moderately in framework-level knowledge — PyTorch, timm, ultralytics — understanding that specific APIs will change but the underlying concepts will not. Stay current at the frontier not by adopting every new model, but by reading papers carefully enough to understand which architectural innovations are likely to become foundational and which are incremental improvements on a crowded benchmark.

The field will be reinvented again. The engineers who built strong foundations will adapt. The engineers who only know how to call APIs will not.

Q: Do I need a PhD or advanced degree to become a computer vision engineer?

A: No. A significant portion of working computer vision engineers do not have PhDs. What matters is demonstrated technical depth — the ability to implement models from papers, debug training runs, design data pipelines, and deploy systems to production. A strong portfolio of projects, contributions to open-source CV libraries, and the ability to discuss architectural tradeoffs in an interview are more predictive of job performance than academic credentials. A PhD is valuable if you want to do research and publish, not if your goal is production engineering.

Q: Should I learn TensorFlow or PyTorch first?

A: PyTorch. The research community moved to PyTorch almost entirely between 2018 and 2021, and the production ecosystem followed. TensorFlow is still present in legacy systems, but virtually all new computer vision research, tooling, and open-source models are built in PyTorch. Learn ONNX export early as well, because it is the interchange format that lets PyTorch-trained models run on TensorFlow Serving, TensorRT, OpenVINO, and other deployment runtimes.

Q: How important is GPU programming knowledge for a CV engineer?

A: Knowing CUDA at a conceptual level is useful — understanding memory hierarchy, why certain operations are memory-bandwidth-bound rather than compute-bound, and how batch size affects GPU utilization. You do not need to write custom CUDA kernels unless you specialize in inference optimization or novel architecture implementation. Most CV engineers work at the level of PyTorch and compiled inference frameworks and delegate kernel-level optimization to tools like TensorRT or Triton.

Q: What benchmark datasets should every CV engineer know well?

A: For classification: ImageNet. For detection and instance segmentation: COCO. For semantic segmentation: ADE20K and Cityscapes. For face recognition: LFW and IJB-C. For depth estimation: NYU Depth V2 and KITTI. For video understanding: Kinetics-400. These are not just datasets — they are the benchmarks against which papers report results. Knowing their characteristics, their known biases, and their limitations lets you critically evaluate performance numbers rather than taking them at face value.

Q: How do I stay current in a field that moves this fast?

A: Read papers selectively rather than comprehensively. Follow the proceedings of CVPR, ICCV, ECCV, and NeurIPS. Use Papers With Code to track state-of-the-art numbers on benchmarks relevant to your work. Subscribe to a small number of high-quality newsletters rather than trying to read every arXiv preprint. Most importantly, implement things. Reading gives you awareness. Implementing gives you understanding — and understanding is what transfers when the specific tools change.

Q: Is classical computer vision still worth learning given how dominant deep learning is?

A: Absolutely. Classical methods handle preprocessing, geometric reasoning, real-time edge deployment, and scenarios where you have very little training data. More importantly, classical CV gives you the conceptual vocabulary to understand deep learning properly. An engineer who has never implemented a Sobel filter does not really understand what a CNN's first layer is doing. An engineer who has never worked through camera calibration does not really understand why monocular depth estimation is hard. The foundations are not optional extras — they are the context that makes everything above them make sense.