Planning, visualisation, and control of drone inspection missions around buildings.
DroCo Mission Planner is a Unity application for preparing aerial inspections of buildings and construction complexes. It allows users to select a building directly on a 3D map, automatically create an inspection route around it, adjust individual waypoints, and then simulate the mission or apply it to a real drone.
The project was created as an extension of the DroCo system developed at the Faculty of Information Technology at Brno University of Technology.
Features · How it works · Run · Architecture · Documentation
Building inspection with a drone often begins before the flight itself: choosing the right area, estimating the shape of the building, and preparing a safe route.
DroCo brings this process together in one environment:
- the user selects a building on the map,
- the application loads its footprint from OpenStreetMap,
- an inspection trajectory is generated around the building,
- the user adjusts the route as needed,
- the mission is launched in the simulator or applied to the drone's controller.
The result is a clear 3D tool for reviewing and refining a planned mission before it is carried out.
- 3D map environment based on ArcGIS Maps SDK for Unity
- direct building selection on the map
- building highlighting when hovering over the map
- building footprint retrieval from OpenStreetMap through the Overpass API
- conversion of geographic coordinates into Unity 3D space
- automatic route generation based on the building footprint
- configurable distance from the building
- configurable vertical step and segment length
- support for vertical and horizontal mission patterns
- collision checking and a basic safety distance
- route visualization using waypoints and connecting lines
- selection of individual waypoints in the scene
- waypoint movement using 3D manipulators
- adjustment of waypoint altitude and position
- editing through controls in the user interface
- mission parameters displayed in a side panel
- WebSocket communication
- server and client modes
- transmission of telemetry, battery status, GPS data, and warnings
- transmission of image data from the drone
- Virtual Stick control support
- uploading and controlling waypoint missions
Verified real-flight platform:
DJI Mavic Mini 1 connected through the DJIStreamer application.
The project includes a simple Python simulator that connects to the Unity application and simulates:
- movement between waypoints,
- GPS coordinates,
- altitude and orientation,
- battery status,
- signal strength and satellite count,
- warning states,
- an image stream.
This makes it possible to test the basic mission workflow without connecting a physical drone.
- overview of the drone status
- battery and signal indicators
- GPS and flight data
- quick actions for the camera, video, return-to-home, and stopping
- collapsible panels
- live video preview
- color-coded status icons
- animated panel transitions
A building can be selected by double-clicking directly on the map. The application then sends a request to the Overpass API and loads the building footprint geometry. However, an API request is not mandatory if there are preloaded models present.
After the building has been loaded, the application creates an inspection route at the selected altitude, step, distance from the building, and other parameters.
Each waypoint can be selected and adjusted using 3D manipulators directly in the scene or through the control panel. Multiselection of waypoints is also supported.
The prepared mission can be started with the simulator or applied through DJIStreamer to a connected drone.
flowchart LR
User[User] --> Unity[DroCo Mission Planner]
Unity --> ArcGIS[ArcGIS 3D map]
Unity --> OSM[OpenStreetMap / Overpass API]
Unity --> Mission[Mission generator and editor]
Mission --> Simulator[Python simulator]
Mission --> WebSocket[WebSocket communication]
WebSocket --> DJIStreamer[DJIStreamer Android]
DJIStreamer --> DJI[DJI drone]
DJI --> Telemetry[Telemetry and video]
Telemetry --> Unity
Communication between the Unity application and DJIStreamer takes place over WebSocket. The system can transfer, among other things:
- information about the connected drone,
- GPS position,
- altitude and speed,
- orientation,
- battery status,
- warnings,
- mission progress,
- video frames,
- commands for starting, pausing, and stopping a mission.
- Unity Hub
- Unity Editor
2022.3.23f1 - Visual Studio Community 2022 nebo kompatibilní IDE
- Windows Build Support
- Android Build Support
- Git Bash
- Visual C++ Redistributable 2015–2022 x64
- Python 3
- packages in
requirements.txt
Install the Python dependencies with:
pip install -r requirements.txt- Open the project in Unity Editor
2022.3.23f1. - Open the scene:
Assets/ArcGISMapsSDK/Scenes/MainScene
- Start the scene by clicking Play.
- Wait for the map data to load.
- Double-click a building to create a mission.
An internet connection is required to load the map and building data for the first time.
First start the server mode in DroCo. Then run:
python drone_interactive.py 5556The simulator connects to the local WebSocket server and begins sending telemetry to the Unity application.
The simulator is intended primarily for development and workflow demonstrations. It is not a physically accurate flight simulation.
To perform a real flight:
- start DroCo in server mode,
- connect the DJIStreamer application,
- enter the IP address of the computer running DroCo,
- use port
5556, - enable the live data stream,
- enable Virtual Sticks,
- start the prepared mission in DroCo.
Before an actual flight, always verify:
- GPS signal,
- battery level,
- available airspace,
- safe altitude,
- the return-to-home procedure,
- the correct drone and controller configuration.
Real-flight support was verified on the DJI Mavic Mini 1 platform.
- Open the project in the required Unity version.
- In Unity, select:
File → Build Settings
- Keep only the
MainScenescene enabled. - Select the target platform.
- Configure the resolution and window mode in
Player Settings. - Click Build.
It is recommended to store the build output outside the main project directory.
DroCo/
├── Assets/
│ ├── Scripts/
│ │ ├── Buildings/ # loading buildings from OpenStreetMap
│ │ ├── Drones/ # drone model and status
│ │ ├── Managers/ # main application managers
│ │ ├── Missions/ # mission generation and editing
│ │ ├── UI/ # original user interface
│ │ ├── UI2/ # extended user interface
│ │ └── Waypoint/ # waypoint selection
│ ├── Animations/
│ ├── Icons/
│ ├── Materials/
│ ├── Models/
│ ├── Prefabs/
│ └── Settings/
├── Packages/
├── ProjectSettings/
├── Submodules/
├── drone_interactive.py
├── COMMUNICATION_API.md
├── QUICK_REFERENCE.md
└── requirements.txt
The most important parts of the implementation are:
| Area | Main files |
|---|---|
| Route generation | Assets/Scripts/Missions/MissionGenerator.cs |
| Mission control | Assets/Scripts/Missions/MissionController.cs |
| Waypoint editing | Assets/Scripts/Missions/MissionEditor.cs |
| Navigation | Assets/Scripts/Missions/Navigator.cs |
| Building retrieval | Assets/Scripts/Buildings/BuildingFetcher.cs |
| OpenStreetMap data | Assets/Scripts/Buildings/OSMData.cs |
| WebSocket server | Assets/Scripts/Managers/WebSocketServer.cs |
| WebSocket client | Assets/Scripts/Managers/WebSocketClient.cs |
| Drone status | Assets/Scripts/Managers/StatusManager.cs |
COMMUNICATION_API.md– complete WebSocket APIQUICK_REFERENCE.md– quick overview of messages and commandsJSON_EXAMPLES.json– communication examplesREADME2.md– running the build and simulatorREADME3.md– program documentationREADME4.md– supporting materialsREADME5.md– DJIStreamer application extension
- Building retrieval depends on the availability of the Overpass API and an internet connection.
- Real drone control was verified on the DJI Mavic Mini 1.
- The Python simulator is not a physically accurate flight simulation.
- The simulator's waypoint mode is intended for testing and demonstrations.
- The quality and safety of a mission depend on the route configuration and actual flight conditions.
- Unity
2022.3.23f1 - C#
- Python
- ArcGIS Maps SDK for Unity
- OpenStreetMap
- Overpass API
- WebSocket
- DJI SDK
- GStreamer
- TextMesh Pro
- JetBrains Mono
Václav Sovák
Faculty of Information Technology
Brno University of Technology
Bachelor's thesis, 2026
Supervisor: Ing. Daniel Bambušek
This project extends the DroCo system developed at the Faculty of Information Technology at Brno University of Technology.
Used sources and technologies:
- OpenStreetMap – map data
- ArcGIS Maps SDK for Unity
- JetBrains Mono – user interface font
- Google Material Icons
- DJI SDK
- GStreamer
OpenStreetMap data is used in accordance with the ODbL licence.