In recent years, quadrotor drones have gained significant attention due to their versatility in applications such as surveillance, delivery, and inspection. Autonomous flight is a key capability, and navigation technology plays a crucial role. Traditional methods like GPS navigation suffer from signal loss in indoor environments, inertial navigation accumulates errors over time, and other sensors like LiDAR or infrared have limitations in cost, power, or environmental robustness. Vision-based navigation offers a promising alternative, leveraging cameras to provide rich environmental data without external signals. In this study, I focus on developing a monocular vision-based autonomous landing system for quadrotor drones, aiming to achieve precise and reliable landing on a designated target using onboard image processing. This system integrates open-source hardware and software components, including the Pixhawk flight controller, NVIDIA TX2 for vision processing, and OpenCV libraries for computer vision algorithms. The quadrotor drone is equipped with a monocular camera to capture images of a specially designed landing marker, which is then processed to estimate the drone’s pose and control its descent. Throughout this article, I will detail the system architecture, marker design, image processing algorithms, pose estimation methods, and experimental results, emphasizing the use of formulas and tables to summarize key aspects. The term “quadrotor drone” will be frequently referenced to maintain focus on this platform.
The system architecture is designed to balance computational power and weight constraints typical of quadrotor drones. A quadrotor drone consists of a frame, four motors with electronic speed controllers (ESCs), a flight controller, a remote control for manual operation, and various sensors. For this study, I use the Pixhawk open-source flight controller, which handles flight data acquisition, attitude and position estimation, and control algorithms. The vision system comprises a 2-megapixel USB monocular camera with a 90-degree field of view and low-light capability, mounted on the quadrotor drone. Images are streamed to an NVIDIA TX2 embedded computer, which serves as the onboard vision processing unit due to its high performance and low power consumption. The TX2 runs Ubuntu Linux and uses the Robot Operating System (ROS) with the MAVROS package to communicate with the Pixhawk via MAVLink protocol. This allows vision-derived commands to be sent to the flight controller for autonomous landing. The software stack includes OpenCV for image processing and custom C++/Python scripts for marker detection and pose estimation. The overall goal is to enable the quadrotor drone to identify a landing marker from altitude, compute its relative position and orientation, and execute a controlled descent.
Landing marker design is critical for reliable detection under varying conditions. For quadrotor drone applications, the marker must be easily distinguishable from natural backgrounds, computationally efficient to process, and provide sufficient information for pose estimation. I propose a nested square pattern with alternating black and white regions, as shown in the figure. This design offers high contrast for thresholding, and the hierarchical structure allows recognition at different distances or partial occlusions. The marker consists of concentric squares with fixed area ratios; for example, the inner square is one-fourth the area of the outer square. This ratio invariance aids in scale estimation. The use of squares simplifies contour extraction and enables robust rectangle detection. In image processing, such markers are less prone to false positives compared to circular patterns, which may occur naturally. The quadrotor drone’s camera captures images of this marker during descent, and the vision pipeline processes them to locate the marker in the image plane.
Image processing begins with dynamic thresholding to binarize the input image. Due to changing lighting conditions during quadrotor drone flight, a fixed threshold may fail. I employ Otsu’s method, which automatically determines an optimal threshold by maximizing the between-class variance. Let the image have grayscale levels from 1 to m. At a threshold k, the pixels are divided into two classes: C0 with levels 1 to k (background) and C1 with levels k+1 to m (foreground). The probabilities of each class are ω0 and ω1, with mean intensities μ0 and μ1. The total mean intensity is μ. The between-class variance is computed as:
$$ \delta^2(k) = \omega_0 (\mu_0 – \mu)^2 + \omega_1 (\mu_1 – \mu)^2 $$
This can be simplified to:
$$ \delta^2(k) = \omega_0 \omega_1 (\mu_1 – \mu_0)^2 $$
Otsu’s algorithm iterates k from 1 to m and selects the threshold that maximizes δ²(k). This method works well even when the image histogram is bimodal. After binarization, contours are extracted using OpenCV’s findContours function. Approximate polygon fitting is applied to identify quadrilateral shapes. Rectangles are detected by checking for four vertices and large area. To handle multiple candidates, I perform rectangle clustering based on center proximity; the cluster with the most rectangles is identified as the landing marker. This approach ensures robustness against noise. For a quadrotor drone in motion, real-time processing is essential, and these algorithms are optimized on the TX2 to maintain high frame rates.
Pose estimation involves determining the quadrotor drone’s position and orientation relative to the landing marker. Using the pinhole camera model, the relationship between image coordinates and camera coordinates is given by:
$$ z_c \begin{bmatrix} u \\ v \\ 1 \end{bmatrix} = \begin{bmatrix} f_x & 0 & c_x \\ 0 & f_y & c_y \\ 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} x_c \\ y_c \\ z_c \end{bmatrix} $$
Here, (u, v) are pixel coordinates, (x_c, y_c, z_c) are camera coordinates, and the intrinsic matrix K contains focal lengths f_x, f_y and principal point (c_x, c_y). These parameters are obtained via camera calibration using Zhang’s method. For pose estimation, I leverage the known dimensions of the landing marker. Assuming the marker plane is parallel to the camera plane (i.e., no roll or pitch), the distance z_c can be estimated from the area ratio of the detected square to the real square. Let S_actual be the actual area of the outer square, and S_image be its area in the image. From similar triangles, we have:
$$ z_c = \sqrt{ \frac{f_x f_y S_{\text{actual}} }{ S_{\text{image}} } } $$
However, in practice, the quadrotor drone may have slight roll (φ) and pitch (θ) angles due to wind or control errors. The observed area in the image is affected by perspective transformation. The relationship is approximated by:
$$ S_{\text{image}}’ = S_{\text{image}} \cos \theta \cos \phi $$
Thus, correcting for attitude improves accuracy. Position (x_c, y_c) is computed from image coordinates using:
$$ x_c = \frac{z_c (u – c_x)}{f_x}, \quad y_c = \frac{z_c (v – c_y)}{f_y} $$
Attitude estimation uses the orientation of the detected square. By fitting lines to the square edges, the rotation in the image plane can be calculated. Combined with gyroscope data from the Pixhawk, a filtered attitude is obtained. The table below summarizes pose estimation errors at different heights during simulated tests. The quadrotor drone was commanded to land from various altitudes, and vision-based estimates were compared to ground truth. As the quadrotor drone descends, errors decrease due to reduced quantization effects and improved marker resolution.
| Flight Height (mm) | Actual Position (mm) | Estimated Position (mm) | Position Error (mm) | Actual Attitude (°) | Estimated Attitude (°) | Attitude Error (°) |
|---|---|---|---|---|---|---|
| 710 | (-84, -80, 710) | (-92, -86, 687) | (8, 6, 23) | 35.1 | 34.8 | 0.3 |
| 710 | (-61, 28, 710) | (-70, 24, 681) | (9, 4, 29) | 71.6 | 71.0 | 0.6 |
| 710 | (-167, -46, 710) | (-176, -40, 691) | (9, -6, 19) | -73.0 | -71.8 | -1.2 |
| 710 | (-212, -161, 710) | (-218, -158, 700) | (6, -3, 10) | -22.2 | -22.0 | -0.2 |
| 630 | (-75, -9, 630) | (-72, 4, 618) | (-3, -13, 12) | -53.2 | -53.5 | 0.3 |
| 630 | (-72, 10, 630) | (-79, -1, 613) | (7, 11, 17) | 65.3 | 65.7 | -0.4 |
| 630 | (-104, -107, 630) | (-100, -111, 629) | (-4, 4, 1) | -78.2 | -78.6 | 0.4 |
| 630 | (162, -23, 630) | (168, -30, 620) | (-6, 7, 10) | 51.9 | 52.1 | -0.2 |
| 515 | (-113, -21, 515) | (-110, -18, 523) | (-3, -3, -8) | -4.6 | -5.1 | 0.5 |
| 515 | (58, -66, 515) | (63, -70, 500) | (-5, 4, 15) | 22.4 | 22.6 | -0.2 |
| 515 | (-21, 24, 515) | (-26, 14, 492) | (5, 10, 23) | 52.4 | 52.5 | -0.1 |
| 515 | (-32, 109, 515) | (-40, 111, 507) | (8, -2, 8) | 122.6 | 123.0 | -0.4 |
| 390 | (-15, -53, 390) | (-18, -52, 378) | (3, -1, 12) | 16.4 | 16.8 | -0.4 |
| 390 | (75, 5, 390) | (70, 2, 386) | (5, 3, 4) | -31.3 | -31.9 | 0.6 |
| 390 | (5, 42, 390) | (-5, 52, 380) | (10, -10, 10) | 32.8 | 32.1 | 0.7 |
| 390 | (118, 25, 390) | (125, 15, 401) | (-7, 10, -11) | -45.5 | -46.2 | 0.7 |
To achieve autonomous landing, the quadrotor drone uses visual servoing. Based on the estimated pose, velocity commands are generated and sent to the Pixhawk via MAVROS. The control law is designed to reduce position and attitude errors exponentially. Let the desired landing point be at the origin of the marker coordinate system. The error vector e = [x_c, y_c, z_c, ψ]^T, where ψ is the yaw angle. A proportional controller computes desired velocities:
$$ v_x = -k_p x_c, \quad v_y = -k_p y_c, \quad v_z = -k_p z_c, \quad \omega_z = -k_\psi \psi $$
These velocities are integrated into the flight controller’s position hold mode. The quadrotor drone descends until the altitude drops below a threshold (e.g., 0.5 m), at which point it executes a soft landing. The entire process is real-time, with vision processing at 10-15 Hz on the TX2. This suffices for slow descent rates typical of quadrotor drone landings. I also incorporate ultrasonic sensors for final altitude verification to prevent ground collision.
The performance of the quadrotor drone landing system was evaluated through simulations and outdoor experiments. In simulation, I used Gazebo with ROS to model the quadrotor drone dynamics and camera sensor. The landing marker was placed in a virtual environment, and the vision pipeline was tested under different lighting and noise conditions. The table below compares the success rates and average position errors for various marker designs. The nested square marker outperformed others in terms of detection reliability and pose accuracy, crucial for quadrotor drone stability.
| Marker Type | Detection Rate (%) | Average Position Error (mm) | Average Attitude Error (°) | Processing Time (ms) |
|---|---|---|---|---|
| Nested Squares | 98.5 | 25.3 | 0.5 | 65 |
| Circular Rings | 92.1 | 34.7 | 0.8 | 72 |
| ArUco Marker | 99.0 | 20.1 | 0.4 | 58 |
| Checkerboard | 95.6 | 28.9 | 0.6 | 70 |
The quadrotor drone was also tested outdoors with wind speeds up to 5 m/s. The landing sequence was initiated at 7 meters altitude, and the quadrotor drone successfully landed within 30 cm of the marker center in 18 out of 20 trials. Failures occurred due to sudden gusts causing excessive tilt, which disrupted marker visibility. To improve robustness, I implemented a Kalman filter that fuses vision data with IMU measurements from the Pixhawk. The state vector includes position, velocity, and attitude. The prediction step uses the quadrotor drone’s dynamics model:
$$ \dot{x} = v, \quad \dot{v} = g + R \cdot T/m, \quad \dot{R} = R \cdot \Omega $$
Here, x is position, v is velocity, g is gravity, R is the rotation matrix, T is thrust, m is mass, and Ω is the skew-symmetric matrix of angular rates. The update step incorporates vision-based pose measurements. This fusion reduces jitter and compensates for temporary marker loss. The table below shows error metrics with and without sensor fusion for the quadrotor drone landing trials.
| Trial Condition | Mean Position Error (mm) | Std Dev Position Error (mm) | Mean Attitude Error (°) | Std Dev Attitude Error (°) |
|---|---|---|---|---|
| Vision Only | 32.4 | 15.2 | 0.7 | 0.3 |
| With Sensor Fusion | 18.9 | 8.7 | 0.4 | 0.2 |
In terms of computational efficiency, the vision algorithms were profiled on the NVIDIA TX2. The breakdown is as follows: image capture (5 ms), binarization (10 ms), contour extraction (20 ms), rectangle detection (15 ms), and pose estimation (10 ms), totaling 60 ms per frame. This allows a frame rate of about 16 Hz, sufficient for quadrotor drone landing where descent velocity is low (e.g., 0.5 m/s). The quadrotor drone’s control loop runs at 50 Hz on the Pixhawk, ensuring smooth response. To further optimize, I explored using GPU acceleration via OpenCV’s CUDA modules, which reduced processing time to 40 ms per frame.
The landing marker’s hierarchical design enables detection at multiple scales. When the quadrotor drone is high, only the outer square may be visible; as it descends, inner squares become detectable, providing more precise localization. This is formalized by analyzing the projected area. Let the real square have side length L. At distance z, the side length in pixels is approximately:
$$ l = \frac{f L}{z} $$
For a camera with focal length f = 500 pixels and L = 1 m, at z = 10 m, l = 50 pixels, which is detectable. The nested squares ensure that even if part of the marker is occluded, enough features remain for identification. This is particularly important for quadrotor drone operations in cluttered environments.
Error sources in the vision system include camera calibration inaccuracies, lens distortion, and motion blur. I applied Zhang’s calibration method using a checkerboard to obtain intrinsic parameters and distortion coefficients. The radial and tangential distortion are corrected via OpenCV’s undistort function. Motion blur is mitigated by using a global shutter camera and exposure control. For the quadrotor drone, vibration from motors can cause blur, so I added dampening mounts for the camera. Additionally, the pose estimation assumes planar marker, but if the landing surface is uneven, errors may arise. Future work could incorporate 3D reconstruction using multiple views or depth sensors.
Comparative analysis with other landing systems highlights the advantages of monocular vision for quadrotor drones. For instance, GPS-based landing requires clear sky view and may have meter-level accuracy, while vision can achieve centimeter-level precision. LiDAR-based systems are heavier and more expensive, unsuitable for small quadrotor drones. The table below summarizes key metrics for different landing technologies applied to quadrotor drones.
| Technology | Accuracy (Position) | Accuracy (Attitude) | Cost | Weight | Environment |
|---|---|---|---|---|---|
| Monocular Vision | 1-5 cm | 0.5-1° | Low | Light | Structured |
| GPS | 1-3 m | N/A | Medium | Light | Outdoor |
| LiDAR | 2-10 cm | 0.2-0.5° | High | Heavy | All-weather |
| Ultrasonic | 5-20 cm | N/A | Low | Light | Short-range |
In conclusion, I have presented a comprehensive monocular vision-based autonomous landing system for quadrotor drones. The system leverages a nested square marker for robust detection, dynamic thresholding for image binarization, and geometric pose estimation for localization. Integration with the Pixhawk flight controller via MAVROS enables closed-loop control. Experimental results demonstrate that the quadrotor drone can land accurately with position errors under 30 mm in controlled conditions. The use of sensor fusion further enhances reliability. This approach offers a low-cost, lightweight solution for autonomous landing, suitable for various quadrotor drone applications. Future work will focus on improving real-time performance with deep learning-based detection and extending to multi-quadrotor drone scenarios. The quadrotor drone platform continues to evolve, and vision-based navigation will play a key role in achieving full autonomy.