🚁 Ariadne: Autonomous Air-to-Ground Optical Navigation

📄 Read the full academic report: Ariadne: A Synthetic Proof of Concept for Air-to-Ground Optical Navigation

In classical mythology, the labyrinth was navigated using "Ariadne's thread", a lifeline provided by an outside observer to guide a vulnerable explorer safely through a maze.

Ariadne is the modern digital equivalent. When GPS signals are jammed or ground sensors fail in disaster zones, robots go blind. This project utilizes a single high-altitude image from an overhead drone (UAV) to act as an "oracle." By passing this image through a deep learning pipeline, the system automatically segments the environment and draws a safe, collision-free mathematical route for a ground vehicle (UGV) to follow.

💡 The Problem: Navigating the Unknown

Modern ground drones rely heavily on GPS and active sensors like LiDAR. But what happens during electronic warfare, under a thick forest canopy, or in a chaotic disaster zone? Those signals die.

Ariadne shifts the paradigm to passive optical reconnaissance. Instead of forcing the ground robot to blindly discover obstacles by bumping into them, an overhead drone looks down, understands the geometry of the terrain, and feeds the ground robot the perfect route before it even moves.

Why test on a Maze? Before deploying complex AI into messy, unpredictable real-world jungles, we have to prove the underlying math actually works. A procedural 2D maze acts as our "noiseless sandbox," allowing us to rigorously test the object detection, semantic segmentation, and pathfinding algorithms without the distractions of real-world shadows or weather.

🎲 Building the Sandbox (Data Generation)

Relevant Files: data_generation directory.

To train our deep learning models to understand geometry, we needed a flawless dataset. We procedurally generated 1,000 custom mazes using Blender's Python API, which allowed us to automatically export mathematically perfect ground-truth labels for our AI to learn from.

Figure 1: Blender rendering set up

 
Figure 2: Simulated UAV Optical Feed (left), Perfect Ground-Truth Mask (right)

🧩 The Ariadne Pipeline

The system translates raw pixels into physical movement through three core phases:

1. 🎯 Finding the Needle (Object Detection)

First, the system needs to know where we are and where we are going. A custom-trained YOLO (You Only Look Once) model scans the raw optical feed, successfully hunting down the exact pixel coordinates of our Ground Robot (Start) and our Human Target (Goal).

• Input: RGB overhead image.
• Output: Bounding box coordinates and confidence scores.
• Environment:
  • Model Training: Colab (model_training/object_detection/)
  • Inference execution: Local (cv_pipeline/modules/target_detector.py)

Figure 3: YOLO successfully isolating the UGV and Human target.

2. 🗺️ Seeing the Walls (Environmental Segmentation)

Next, the pipeline has to figure out what is a safe path and what is a concrete wall. We built and tested two different approaches to prove why deep learning is necessary:

• Approach A: Classical Color Heuristics (cv_pipeline/modules/color_segmenter.py)

  • Uses OpenCV to filter the image purely by color. While incredibly fast, it is easily confused by shadows and fuzzy pixel edges, making it dangerous for real robots.

• Approach B: Neural Semantic U-Net (cv_pipeline/modules/unet_segmenter.py)

  • Powered by a PyTorch U-Net architecture with a ResNet34 backbone. Instead of just looking at colors, it actually learns the structural geometry of the walls, creating a rock-solid, mathematically perfect map.

• Environment:

  • U-Net Training: Colab (model_training/image_segmentation/unet_training.ipynb)
  • Inference execution: Local (Both segmenter modules)

Figure 4: Custom built Color Threshold Tuner for Approach A

 
Figure 5: RGB Input (left), Approach A Classical Heuristic Output (right). Notice the fuzzy, unreliable edges.

 
Figure 6: RGB Input (left), Approach B Neural Semantic Output (right). A perfectly rigid, traversable map.

3. 🛤️ Drawing the Map (Tactical Pathfinding)

Finally, Ariadne takes the start/goal nodes from YOLO and the rigid map from the U-Net, transmuting them into a mathematical cost matrix. Utilizing the A (A-Star) search algorithm*, the system calculates the absolute shortest path while maintaining a strict physical buffer to ensure the robot never clips a wall corner.

• Environment: Executed Local (cv_pipeline/modules/path_finder.py)

🚀 Final Results: Pixels to Physical Routes

The final output of the Ariadne pipeline is a fully autonomous, collision-free waypoint route projected seamlessly back onto the original visual space.

📂 Explore more routing examples and edge-cases in the showcase directory.

 
Figure 7: Standard routing. Classical heuristic (left) vs. the highly optimized Neural U-Net path (right).

 
Figure 8: Complex routing. The system successfully navigates high-density obstacles without crashing.

🔭 Future Directions

With the core logic of the pipeline validated in this proof-of-concept, Ariadne is structurally prepared to scale to real-world deployment:

• Unstructured Environments (Forest Canopies): Upgrading the U-Net training weights from synthetic mazes to complex, messy real-world topography where traditional sensors fail.
• Dynamic Terrain Weights: Evolving the binary map (wall vs. path) into a multi-class map (mud vs. asphalt), allowing the A* algorithm to calculate routes that are not just the shortest, but the most energy-efficient for the hardware.
• Tactical Edge Deployment: Optimizing the pipeline for deployment on SWaP-constrained (Size, Weight, and Power) edge accelerators, such as the NVIDIA Jetson architecture.