Stereo visual odometry you can derive, debug, and defend.
Visual odometry is the backbone of localization for robots and autonomous vehicles, and it is taught in two useless extremes: flashy demo reels with no explanation, or dense papers with no code. This course is the middle. Over about 7 hours you build monocular and stereo VO from the essential matrix up, write RANSAC and the nonlinear solvers by hand, add keyframes and a g2o bundle-adjustment back end, then run the complete pipeline on KITTI, EuRoC and a simulator, first in Python and then in C++ on ROS 2. No black boxes. Real datasets with ground truth. Two full pipelines that are yours.
Every autonomous machine localizes itself. Almost nobody can open that layer up when it fails.
Search for visual odometry and you get two extremes: demo reels that show a trajectory and explain nothing, or papers with no runnable code between the equations. The gap in the middle is where the architectural intuition lives, so most engineers skip it and install a package instead. That works until a degeneracy case collapses the estimate and the only remaining fix is rebooting the robot by hand, which means the system was never autonomous.
Clones a SLAM package, edits a YAML file, and hopes. When the trajectory spikes there is nothing to inspect, because the front end, the solver and the graph are all somebody else's decisions.
Knows the monocular estimate is a ratio between two frames, recognizes the stationary-camera case on sight, and changes the outlier rule, the keyframe threshold or the graph directly.
Monocular VO from the essential matrix
Recover rotation and scaled translation between two frames, then walk a full driving sequence with it.
The two-view geometry under every structure-from-motion toolStereo VO with triangulation and PnP
Measure 3D points directly, reject outliers with RANSAC, and solve pose with no scale ambiguity.
GPS-denied navigation for drones, delivery robots and driving stacksA keyframe map and a bundle-adjustment back end
Hold a sliding window of keyframes and landmarks, then refine both as a graph in g2o.
The backend line between a hobby demo and a professional systemA real-time stereo VO node in C++
The same pipeline rebuilt on ROS 2, publishing point cloud, path and a debug image as it runs.
What actually ships on embedded compute in the fieldSix pieces make a visual odometry system. You build exactly those six.
This is not a survey of the literature. Visual navigation 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.
SO(3) and so(3), the exponential and log map, Rodrigues, and the transform T you compose all pipeline long.
→ taught in Level 0The essential matrix by SVD, its four pose candidates, and the cheirality check that picks the real one.
→ taught in Level 1Direct 3D measurement from stereo, reprojection error, and pose from 3D-to-2D correspondences.
→ taught in Level 1RANSAC written from scratch: sampling, thresholds, inlier counts, and where its assumption breaks.
→ taught in Level 2Residuals, Jacobians, gradient descent, Gauss-Newton and Levenberg-Marquardt, built before any solver is called.
→ taught in Level 2A map of frames and landmarks, then a g2o graph of poses and reprojection edges solved over a window.
→ taught in Levels 3 and 48 reasons this is a pipeline you own, not another demo you watch.
Environment and manifolds, monocular and stereo VO, robust and nonlinear solvers, keyframes, bundle adjustment, then the complete system in Python and C++. Nothing appears out of nowhere.
Most tutorials stop at feature tracking. A full chapter builds local bundle adjustment on g2o from the graph up, and the pipeline chapters then run it live inside the map.
RANSAC, gradient descent, Gauss-Newton and Levenberg-Marquardt are written by hand on small problems first, so solvePnPRansac stops being a magic line and becomes a choice.
KITTI odometry for the driving case and EuRoC MAV for the drone case, plus a simulator where you can drive the robot yourself and create the failure you want to study.
The full pipeline is built twice: a readable Python version where the mechanics are visible, then a real-time C++ node on ROS 2 with Sophus, Eigen and RViz.
A stationary camera, a truck crossing the frame, a featureless wall, motion too fast for the tracker: each degeneracy is shown breaking a real run, then diagnosed on the spot.
Every run is instrumented in rerun.io or RViz: inliers and outliers on the image, reprojected points, the local and global map, the camera frustum, and your trajectory against ground truth.
Two first-author AIAA papers on visual-inertial odometry, a graduate thesis on camera ego-motion estimation, and a stereo visual SLAM pipeline written from scratch in C++ with a g2o back end.
Derive it, code it, then run it until it breaks.
The same three-step loop on every stage of the pipeline, so you never watch without building, and never trust a result you have not tried to destroy.
Start from the geometry
Each stage opens with the equation and the intuition under it, from the perpendicularity condition of the essential matrix to the reprojection residual.
Write it line by line
The equation becomes a notebook you run: detector, optical flow, triangulation, and the solver call with the arguments it actually wants.
Check it against ground truth, then push it over
Every result is compared with the dataset's ground truth in rerun or RViz, then pushed into the case that makes it fail, and the failure is diagnosed rather than edited out.
One connected climb: Level 0 to Level 5.
Each level ends in code that runs and is the prerequisite for the next, so no stage of the pipeline ever appears out of nowhere. About 7 hours of build-along video across nine chapters, ending with the same system written twice, once to understand it and once to run it in real time.
Environment, manifolds, and the data
A stack that runs, the rotation math visual navigation actually uses, and both benchmark datasets loaded, plotted and understood.
Classic monocular and stereo VO
The two pipelines every open-source project is a variation of, built end to end, compared honestly, and then broken on purpose.
RANSAC and nonlinear optimization
The two numerical engines under the pose solver, written by hand on problems small enough to see, before they are trusted at scale.
Keyframes and map management
The idea that separates a frame-to-frame demo from a system: anchor the estimate to a keyframe, and give the map a structure you can actually query.
Local bundle adjustment with g2o
The professional line. Poses and landmarks become one graph, and the whole window is solved against every measurement at once.
The full pipeline, written twice
Everything above assembled into one system: first in Python, where every mechanism stays visible, then in C++ on ROS 2, where it runs in real time.
You finish with two pipelines you wrote, a back end you can defend, and a clear view of the line where visual odometry ends and visual-inertial odometry and full SLAM begin.
Is this course for you?
✕ Not for you if…
✓ This IS for you if…
Prerequisites: fluent Python and NumPy, working knowledge of camera projection and calibration, and the rotation and state-estimation basics that Robotics 101 and the Computer Vision course cover. Chapter 2 reviews manifolds, SE(3) and the vision essentials, but it reviews them rather than teaching them from zero. You need Linux, Ubuntu or WSL, and chapter 9 is a C++ ROS 2 workspace, so you must be able to read C++ even if you do not write it. Datasets are free downloads and there is no hardware to buy.
The system you can draw by the end.
By Level 5 you can explain a visual odometry system from the raw stereo pair to the optimized map, and say which stage a given failure came from. Here is the exact stack you build, box by box. Every box is your own code.
This is the real code, not a brochure diagram: vo_frontend_mapping.py, vo_frontend_tracking.py, vo_backend.py, vo_map_model.py and vo_visualizer.py in the Python package, and map.hpp, stereo_geometry.hpp and the viewer in the C++ ROS 2 workspace.
Nine chapters, one connected pipeline.
- 01What We Will Cover
- 02Communication Channels
- 03Setting Up Environments
- 01Manifolds - Nonlinear Spaces SO3 and SE3
- 02Computer Vision Recap
- 03KITTI Dataset Breakdown
- 04Code Recap for Manfolds and CV
- 05Code Recap for KITTI
- 01Using Virtual Robots
- 01Overview
- 02MVO - Intro
- 03MVO - Essential Matrix
- 04MVO - Pose Recovery
- 05MVO - Discussion
- 01RANSAC Deep Dive 1
- 02RANSAC Deep Dive 2
- 03Nonlinear Optimization Overview
- 04Nonlinear Optimization Methods
- 05Nonlinear Optimization Rosenbrock
- 01Overview
- 02Keyframe Concept
- 03Map Management
- 04Keyframe Wrap-Up
- 05Keyframe Implementation
- 01Local Bundle Adjustment (LBA) Intro
- 02LBA Concept
- 03LBA Example 1
- 04LBA Example 2
- 05LBA Example 3
- 01VO in Python Intro
- 02PyVO Running with KITTI Dataset
- 03PyVO Running with Virtual Robots
- 04[PyVO] Main Entry & Utils
- 05[PyVO] Map Model
- 01C++ VO Intro
- 02Download EuroC MAV Dataset
- 03Ubuntu & Docker Setup
- 04WSL Setup
- 05Running ROS2 for C++ VO with KITTI & EuroC Datasets
Chapter order matches the produced course, and the lesson list is pulled live from the course itself. Chapters 1 to 8 are Python; chapter 9 is the C++ and ROS 2 rebuild.
Real slides, real runs, and the notebooks you build in.
Straight from the course. Every algorithm shown here is one you implement yourself and then watch run on data with ground truth.
Elliot Lee, aerospace autonomy engineer.
Founder of Ubicoders His graduate research at Ohio State was visual-inertial odometry: estimating a monocular camera's ego-motion and its uncertainty, published first-author at AIAA. Since 2014 he has been building the same stack outside the lab, from gesture-controlled multirotors to a stereo visual SLAM pipeline written from scratch in C++ with a g2o back end. This course is the framework he spent months looking for and never found.
“During my graduate studies, I spent months, literally months, grappling with these concepts, struggling to find a single foothold. I was drowning in equations and open source code that I couldn't even understand.”
“In modern visual navigation, bundle adjustment is the real line between hobbyist tutorial and professional project.”
verbatim, from the course introduction
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. Chapter 1 has a lesson on which channel to use and what to include, because a VO question with the sequence, the frame and the plot attached gets a far better answer than one without.
Proof of skill, not attendance.
A verifiable Certificate of Completion recording that you implemented monocular and stereo visual odometry, a keyframe map, and a bundle-adjustment back end, and validated them against dataset ground truth. 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 pipeline. Yours for good.
Everything needed to build visual odometry you own, from two-view geometry to a node that runs in real time.
Move past the demos.
You can get here without this course, the same way the instructor did: months of grappling with papers and open-source code until the architecture finally clicks. This is that path compressed into nine chapters, with the derivations, the failure cases and both pipelines 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.
Price increases September 1, 2026.
Secure checkout via Paddle.com
What this unlocks.
Visual odometry is the layer the rest of visual navigation stands on. Once the front end, the solvers and the graph are yours, the things that used to read as research projects become the next build.