From raw pixels to metric 3D depth, with nothing hidden.
The world your robot moves through is not flat, and every decision it makes about that world starts with a camera. This course is the geometry layer under all of it, built by hand: an image as a table of numbers, colour tracking on real video, convolution, features and optical flow, then the projection model itself, camera calibration from the singular value decomposition up, and finally a stereo pair that returns a position in metres. Under three hours of video, no filler, every stage written in a notebook you keep. It is the prerequisite layer for visual odometry, SLAM and any navigation stack you intend to own rather than install. No black boxes. Real cameras, real captures, and a number you can check.
Every robot that acts in the world has to know how far away things are. Most engineers can only call the function that answers.
Computer vision is taught at two useless extremes: tutorials that load an image, call a filter and stop, or multiple-view-geometry textbooks with no runnable code between the equations. The gap in the middle is where 3D perception actually lives, so most engineers skip it, buy a depth camera and treat the numbers it returns as truth. That works until the rig is knocked out of alignment, the focus ring moves, or the depth quietly degrades with distance, and there is no way to tell because nothing in the pipeline was ever yours to inspect.
Reads depth off an SDK and tunes numDisparities until the picture looks plausible. When the measurement drifts there is nothing to check, because the intrinsics, the rectification and the matcher are all somebody else's decisions.
Knows depth is focal length times baseline over disparity, so a longer baseline buys range and a shorter one buys close-in accuracy. Reads a reprojection error and can say whether the calibration or the matching is at fault.
A colour tracker that runs on video
Threshold, clean up with erosion and dilation, find the centroid, then follow the object frame by frame in a moving crop window.
Visual servoing, object following, and the first sanity check on any camera rigFeatures, descriptors and optical flow
Convolution written by hand, then FAST corners, BRIEF and ORB descriptors, brute-force matching, and both sparse and dense flow.
The front end of every visual odometry and SLAM systemA camera projection model you wrote yourself
Build K from focal length and principal point, compose the extrinsic transform, and project known 3D points onto the image to check the result.
Sim-to-real validation, augmented reality, and any fusion of a camera with another sensorA calibrated camera, distortion included
Solve for the projection matrix by singular value decomposition, decompose it back into K, R and t, then calibrate a real lens with a checkerboard and undistort the images.
Every measurement anyone ever makes from an imageA stereo rig that returns metric XYZ
Calibrate both cameras, rectify the pair, triangulate matched points, and build a dense disparity map that converts to depth in metres.
GPS-denied navigation, obstacle avoidance and robot manipulationSix pieces make a 3D vision system. You build exactly those six.
This is not a survey of what OpenCV can do. Perception decomposes into six pieces, and the six levels of this course build precisely those, in the order they depend on each other. The row below is the whole pipeline in miniature.
Rows, columns and three channels: indexing, cropping, colour spaces, masks and morphology, and the coordinate conversion that keeps a crop registered to the full frame.
→ taught in Level 1A kernel slid by hand before filter2D is called, then edges, the bilateral filter and Canny, judged by what each one keeps and destroys.
→ taught in Level 2FAST corners, why a descriptor is needed at all, BRIEF and ORB, brute-force matching, and Lucas-Kanade against dense Farneback flow.
→ taught in Level 2The pinhole camera, the virtual image plane, homogeneous coordinates, the intrinsic matrix K, and why the whole formulation looks the way it does.
→ taught in Level 3SE(3) as one 4 by 4 matrix, composing and inverting frames, and the full camera projection matrix P assembled from K and the pose.
→ taught in Level 3The direct linear transform by singular value decomposition, lens distortion, stereo calibration and rectification, then triangulation and disparity to depth.
→ taught in Levels 4 and 57 reasons this is a perception layer you own, not another OpenCV walkthrough.
Under three hours of video, and every lesson ends in code that runs. Setup, images as data, filtering and features, projection geometry, calibration, and metric depth, in one dependency chain where nothing appears out of nowhere.
A whole lesson exists purely to answer why the intrinsic matrix looks the way it does: the pinhole model, the virtual image plane, and what homogeneous coordinates buy you. The equations stop being notation you copy.
First from the mathematics: stack the correspondences into A p equals zero, solve the null space by singular value decomposition, and decompose the result back into K, R and t. Then the practical route, with real lens distortion and a checkerboard.
The course is shot with a pair of manual-focus USB cameras on a 3D-printed mount with a 150 millimetre baseline, alongside a commercial stereo camera for comparison. Every capture and calibration file is supplied, so nothing has to be bought to follow along.
Objects are placed at measured ranges before the depth pipeline runs, so the final number is compared against ground truth on camera, error included, instead of a heat map that merely looks convincing.
Projection is taught in a game-engine scene where every world coordinate is known exactly, so the projected pixels can be verified by eye before the same code is pointed at a real lens that bends light.
Two first-author AIAA conference papers on visual-inertial odometry and uncrewed aerial systems, a graduate thesis on monocular camera ego-motion, and a multi-camera calibration pipeline in production use today.
Derive it, code it, then measure something you already know.
The same three-step loop on every stage of the pipeline, so you never watch without building, and never accept a result that was not checked against something independent.
Start from the geometry
Each stage opens with the picture and the equation under it: the pinhole model behind the intrinsic matrix, the rigid transform behind the extrinsics, the two equations and four unknowns that make a single camera insufficient.
Write it line by line
The equation becomes a notebook you run: building K from fx, fy, cx and cy, composing the 4 by 4 transform, calling the solver with the arguments it actually wants, and drawing the result back onto the image.
Check it against something known
Projected points are compared with the simulated scene, calibration is judged by reprojection error and by the undistorted image, and the final depth estimate is compared with objects placed at measured distances.
One connected climb: Level 0 to Level 5.
Each level ends in code that runs and is the prerequisite for the next, so no part of the pipeline ever appears out of nowhere. Six chapters take you from an image as a table of numbers to a stereo pair returning a position in metres, and every parameter in that final number is one you estimated yourself.
A stack that runs, on your machine
Editor, environment and course workspace installed on whichever operating system you use, so the first notebook opens and runs before any vision is attempted.
An image is a table you can measure
Pixels, channels and coordinates first, then the smallest complete perception loop there is: find an object by colour, clean up the mask, compute its position, and follow it through a video.
Convolution, features and optical flow
The front end that every visual odometry and SLAM system starts with, built one layer at a time: a kernel slid by hand, corners that survive a viewpoint change, and pixel motion between frames.
The camera projection model
The heart of the course. How a 3D point becomes a pixel, why the formulation looks the way it does, and how the camera's pose enters the same matrix, verified in a simulated scene where every coordinate is known.
Camera calibration, from the null space to a real lens
In the field nobody hands you fx, fy, cx and cy. You estimate them: first from the mathematics on synthetic data, then from a real checkerboard on a real lens that bends light, then across two cameras at once.
3D depth: triangulation and disparity
The payoff. Two views, one physical point, and a position in metres, computed two different ways and compared against objects placed at distances measured in advance.
You finish with a perception layer you wrote, a calibration you can redo on any camera you are handed, and a clear view of the line where 3D vision ends and visual odometry, visual navigation and SLAM begin.
Is this course for you?
✕ Not for you if…
✓ This IS for you if…
Prerequisites: comfortable Python and NumPy, and enough linear algebra to be unbothered by matrix multiplication and an inverse. Singular value decomposition and homogeneous coordinates are explained where they are used. You need a laptop running macOS, Ubuntu or Windows, and chapter 1 installs the environment with you. No camera is required: the captures, the checkerboard images and the calibration files are supplied, though a webcam and a printed board are enough if you want to calibrate your own.
The system you can draw by the end.
By Level 5 you can explain a 3D perception system from a raw image pair to a point in metres, and say which stage a bad number came from. Here is the exact stack you build, box by box. Every box is your own code.
This is the real workspace, not a brochure diagram: ch1_a_image_structure.ipynb through ch2_d_optical_flow.ipynb in the first code pack, and ch1_a_camera_intrinsics.ipynb, ch1_c_camera_extrinsics.ipynb, ch2_c_camera_calibration_stereo.ipynb, ch3_a_stereo_camera_triangulation.ipynb, ch3_b_stereo_camera_depth_map.ipynb, RotationUtils.py and calib_data_stereo.json in the second.
Six chapters, one path from pixels to metric depth.
- 01Course Intro
- 02VSCode Installation
- 03Conda Installation
- 04Course Environment Setup in Conda
- 01Image as Data
- 02Cropping The Image
- 03Filtering the RED
- 04Detecting the RED
- 05Tracking the RED
- 01The First Image Processing
- 02Feature Descriptors and Feature Matching
- 03Optical Flow
- 01Camera Intrinsics Quick Dive
- 02Camera Intrinsics Python Code
- 03Camera Intrinsics Deeper Dive
- 04Camera Extrinsic Parameters
- 05Camera Extrinsic Parameters Python Code
- 01Introduction
- 02Camera Calibration Simple Concept
- 03Camera Calibration Simple Concept in Python
- 04Camera Calibration with Distortion
- 05Camera Calibration using OpenCV Python
- 013D Depth Estimation - Triangulation
- 023D Depth Estimation - Triangulation Code
- 033D Depth Estimation - Disparity
- 043D Depth Estimation - Disparity Code
- 05Outro
Chapter order matches the produced course, and the lesson list is pulled live from the course itself. Chapters 1 to 3 are image processing in Python and OpenCV; chapters 4 to 6 are the 3D geometry, calibration and stereo depth.
Real slides, real captures, and the notebooks you build in.
Straight from the course. Every result shown here comes from code you write yourself and then point at a real camera or a real capture.
Elliot Lee, aerospace autonomy engineer.
Founder of Ubicoders Cameras have been his instrument since 2014, when his undergraduate research at Ohio State navigated a multirotor indoors from vision alone. His graduate thesis estimated a monocular camera's ego-motion and its uncertainty, published first-author at AIAA. Today he runs a multi-camera calibration pipeline and an indoor positioning lab that localizes drones from fiducial boards, which is the same geometry this course starts from.
“The world isn't flat. It is a rich three-dimensional space for robots and autonomous vehicles to move through it safely and intelligently.”
“In real life, no one is going to give us the corresponding numeric values. Therefore, we'll need to estimate them ourselves.”
verbatim, from the course
A real person answers.
Ask in the discussion thread on the lesson itself, or in the Discord forum. The instructor is notified for every post and answers there himself. A calibration question that arrives with the board, the capture set and the reprojection error attached gets a far better answer than one without, so bring the numbers.
Proof of skill, not attendance.
A verifiable Certificate of Completion recording that you implemented the camera projection model, calibrated a real lens and a stereo pair, and recovered metric 3D depth by triangulation and by disparity. It is not a licence and it is not a degree. It is a statement of what you built, which is the only thing this audience checks anyway.
The questions everyone asks first.
Answering the catch.
One payment. The whole geometry layer. Yours for good.
Everything needed to build 3D perception you own, from a pixel index to a position in metres.
Own the measurement.
You can reach this on your own, the way the instructor did: a textbook, a stack of OpenCV documentation and a lens that refuses to agree with either. This is that path compressed into six chapters, with the derivations, the real captures and the checks against known distances included, and the choice is entirely yours.
Full lifetime access
- Lifetime access — learn entirely at your pace
- Every video lesson, from first principles to mastery
- All source code & course projects
Applicable sales tax / VAT is calculated at checkout based on your location.
Secure checkout via Paddle.com
What this unlocks.
3D vision is the layer the rest of visual navigation stands on. Once projection, calibration and triangulation are yours, the things that used to read as research projects become the next build.