TriSAR: Task Coordination and Collision Avoidance for Aerial Robot Teams in Disaster Response

Accepted at TAROS 2026 · arXiv:2609.01731

Official code repository and benchmark evaluation suite for the paper:

"TriSAR: Task Coordination and Collision Avoidance for Aerial Robot Teams in Disaster Response"

Authors: Aditya Anil Kapile, Pedro Machado, Isibor Kennedy Ihianle

📄 Read the paper on arXiv
💻 View the source code

📌 Abstract

Unmanned Aerial Vehicle (UAV) swarms offer transformative capabilities for disaster response, search-and-rescue, and emergency aerial mapping in GPS-denied, post-earthquake urban environments. However, scaling multi-drone operations requires solving NP-hard combinatorial task allocation while simultaneously maintaining real-time 3D flight safety under tight inter-agent proximity.

TriSAR introduces a decoupled hierarchical framework integrating a Genetic Algorithm (GA) for multi-objective target allocation with a Particle Swarm Optimization (PSO) controller incorporating an exponential potential-field inter-agent repulsion mechanism.

The system is evaluated using a balanced factorial study across 120 stochastic simulation episodes, with 30 episodes per experimental condition. Results demonstrate that reactive inter-agent repulsion provides a substantial safety benefit, while GA-based task allocation provides measurable mission-efficiency advantages under specific conditions.

🏗️ System Architecture

TriSAR decouples global target distribution from local 3D trajectory generation:

                                   +-----------------------------+
                                   |   Blackboard Shared State   |
                                   +--------------+--------------+
                                                  |
                                                  v
                                   +-----------------------------+
                                   |  GA Task Allocator          |
                                   |  (Combinatorial Search)     |
                                   +--------------+--------------+
                                                  |
                                                  v
                                   +-----------------------------+
                                   |  3D PSO Flight Controller   |
                                   |  + Inter-Drone Repulsion    |
                                   +--------------+--------------+
                                                  |
                                                  v
                                   +-----------------------------+
                                   | ROS 2 / Gazebo Sim Backend  |
                                   | + Voxel SLAM & Mesh Relay   |
                                   +-----------------------------+

Core Components

Global Task Allocation (GA)
Evaluates multi-drone target assignments, balancing rescue urgency and total swarm travel distance.
Local 3D Navigation (PSO)
Computes continuous velocity commands for each drone with dynamic velocity clamping.
Reactive Collision Avoidance (Repulsion)
Applies an artificial potential-field force when inter-drone distance falls below the safe boundary.
Voxel Mapping & Mesh Relay
Maintains a real-time 3D SLAM occupancy grid while dedicating high-altitude stationary drones as ad-hoc wireless communication relays.

📂 Repository Structure

TriSAR/
├── README.md                          # Academic overview & paper reproduction guide
├── LICENSE                            # MIT License
├── CITATION.cff                       # Citation metadata
├── requirements.txt                   # Standard Python dependencies
├── environment.yml                    # Conda environment specification
├── Dockerfile                         # Container build configuration
│
├── configs/                           # Experimental condition configs
│   ├── full.yaml                      # GA Allocator + PSO + Repulsion
│   ├── no_ga.yaml                     # Greedy Allocator + PSO + Repulsion
│   ├── no_repulsion.yaml              # GA Allocator + PSO - Repulsion
│   └── floor.yaml                     # Greedy Allocator + PSO - Repulsion
│
├── simulation/                        # Gazebo worlds and ROS 2 launch files
│   ├── worlds/                        # Gazebo 3D urban environment models
│   ├── models/                        # Custom CAD/SDF model assets
│   └── launch/                        # ROS 2 & Gazebo launch manifests
│
├── src/                               # Core Python framework packages
│   ├── allocation/                    # GA & Greedy task allocators
│   ├── control/                       # 3D PSO controller & repulsion
│   ├── energy/                        # Aerodynamic drag battery model
│   └── evaluation/                    # Metrics logger & collision detector
│
├── experiments/                       # Experiment execution entry points
│   ├── run_episode.py                 # Single episode execution wrapper
│   ├── run_ablation.py                # 30-episode ablation study runner
│   └── run_all_experiments.sh         # Master experiment script
│
├── data/                              # Data dictionary & processed CSVs
│   ├── raw/                           # Raw episode datasets
│   └── processed/                     # Summarized CSVs
│
├── analysis/                           # Statistical analysis & figure generation
│   ├── prepare_data.py                # Raw JSON to CSV aggregator
│   ├── statistical_analysis.py        # Statistical analysis
│   ├── generate_table1.py             # Summary statistics reporter
│   └── generate_figure4.py            # 3D trajectory plot generator
│
├── figures/                            # High-resolution paper figures
├── legacy_benchmarks/                  # Legacy ablation datasets & scripts
├── tests/                              # Test suite
└── docs/                               # Project specifications & documentation

🛠️ Installation & Setup

Option A: Using Conda (Recommended)

# Clone repository
git clone https://github.com/Aditya-1711/TriSAR.git
cd TriSAR

# Create and activate Conda environment
conda env create -f environment.yml
conda activate trisar

Option B: Using Pip

pip install -r requirements.txt

Option C: Using Docker

Build and run the complete simulation environment in a container:

# Build Docker container image
docker build -t trisar .

# Run container
docker run --rm -v $(pwd)/logs:/app/logs trisar

# Run statistical analysis
docker run --rm trisar python analysis/statistical_analysis.py

🚀 Quickstart & Reproduction Commands

1. Single Demonstration Run

Run a single 3D search-and-rescue episode:

PYTHONPATH=. python experiments/run_episode.py

2. Reproduce Table 1

Generate summary statistics across the canonical ablation benchmark:

PYTHONPATH=. python analysis/generate_table1.py

3. Reproduce Statistical Analysis

Run the statistical analysis for mission-efficiency and collision-safety metrics:

PYTHONPATH=. python analysis/statistical_analysis.py

4. Reproduce Figure 4

Generate high-resolution 3D swarm flight trajectory plots:

PYTHONPATH=. python analysis/generate_figure4.py

📊 Experimental Results

TriSAR evaluates the interaction between:

Task allocation: Genetic Algorithm vs Greedy allocation
Collision avoidance: Reactive repulsion enabled vs disabled

The study uses:

5 UAVs
8 targets
120 total stochastic episodes
30 episodes per experimental condition
Physics-based Gazebo simulation
2 × 2 factorial experimental design

Table 1: Ablation Study Benchmark Summary

Experimental Variant	Allocation Mechanism	Repulsion	Success Rate	Total Steps	Path Length (m)	Energy Consumed (%)	Collision-steps
FULL	Genetic Algorithm	Active	100.0%	179.07 ± 34.15	355.85 ± 26.74	96.85 ± 17.12	0.00 ± 0.00
NO_GA	Greedy	Active	100.0%	173.77 ± 7.46	360.39 ± 3.14	92.86 ± 1.94	0.00 ± 0.00
NO_REPULSION	Genetic Algorithm	Disabled	100.0%	152.63 ± 11.20	331.35 ± 12.70	71.81 ± 3.50	2.70 ± 3.22
FLOOR	Greedy	Disabled	100.0%	160.30 ± 3.23	347.77 ± 2.76	74.80 ± 1.55	3.03 ± 1.96

Collision Avoidance

Under Greedy allocation, enabling reactive repulsion eliminated recorded collision-threshold violations:

Without repulsion: 3.03 ± 1.96 collision-steps
With repulsion: 0.00 ± 0.00 collision-steps
Mann-Whitney U = 885
p = 4.03 × 10⁻¹²
Rank-biserial r = 0.97
Episodes with collision-step: 96.7% → 0.0%

Under GA allocation, the corresponding comparison also showed a significant protective effect:

Mann-Whitney U = 675
p = 1.26 × 10⁻⁵
Rank-biserial r = 0.50

Task Allocation Efficiency

When reactive repulsion was enabled, GA-based allocation did not show a statistically detectable mission-efficiency advantage over Greedy allocation.

When repulsion was disabled, GA-based allocation showed significant advantages in:

Total steps
Path length
Energy consumption

with Welch's t-tests producing effect sizes of approximately:

|g| = 0.92–1.76

These findings indicate that collision avoidance and task allocation interact: the efficiency benefit of more computationally expensive GA allocation becomes more detectable when reactive repulsion is disabled.

Allocation Timing

The measured task-allocation times were:

Allocator	Mean Time	Behaviour
Genetic Algorithm	86.53 ± 13.83 ms	16–19 generations
Greedy	0.174 ± 0.039 ms	Immediate nearest-target assignment

The Greedy allocator is approximately 500× faster than the GA allocator, while both remain within the measured real-time mission-planning constraints.

🔬 Key Findings

1. Reactive collision avoidance provides a strong safety benefit

The potential-field repulsion mechanism substantially reduces inter-agent collision-threshold violations, particularly under Greedy task allocation.

2. GA task allocation is not universally superior

GA introduces considerably higher computational cost than Greedy allocation. Its mission-efficiency advantage depends on the collision-avoidance configuration.

3. Safety and efficiency should be evaluated jointly

Optimising task allocation independently of local trajectory safety can produce misleading conclusions. TriSAR therefore evaluates allocation and collision avoidance as interacting components.

4. Decoupled coordination provides a reproducible experimental framework

Separating global task allocation from local trajectory generation enables controlled ablation of individual coordination mechanisms.

🧪 Experimental Design

TriSAR uses a balanced 2 × 2 factorial design:

                         Collision Avoidance
                       Disabled       Enabled
                    +-------------+-------------+
          GA        | NO_REPULSION|    FULL     |
                    +-------------+-------------+
          Greedy    |    FLOOR    |   NO_GA     |
                    +-------------+-------------+

Each configuration is evaluated over 30 stochastic episodes, giving:

4 experimental conditions × 30 episodes = 120 episodes

The same five-UAV / eight-target scenario is used across conditions to enable controlled comparisons.

🧰 Technologies

Python
ROS 2
Gazebo
NumPy
SciPy
Particle Swarm Optimization (PSO)
Genetic Algorithms (GA)
Multi-Agent Systems
Swarm Intelligence
3D trajectory planning
Reactive collision avoidance
SLAM / voxel mapping
Statistical analysis

📄 Paper

TriSAR: Task Coordination and Collision Avoidance for Aerial Robot Teams in Disaster Response

Authors

Aditya Anil Kapile
Pedro Machado
Isibor Kennedy Ihianle

Accepted at: TAROS 2026
arXiv: 2609.01731
Category: Robotics (cs.RO)

Links

📄 Read the paper

📥 Download PDF

💻 Source Code

📜 Citation

If you use TriSAR or find this codebase useful in your research, please cite:

@inproceedings{kapile2026trisar,
  title     = {TriSAR: Task Coordination and Collision Avoidance for Aerial Robot Teams in Disaster Response},
  author    = {Kapile, Aditya Anil and Machado, Pedro and Ihianle, Isibor Kennedy},
  booktitle = {Proceedings of Towards Autonomous Robotic Systems (TAROS 2026)},
  year      = {2026},
  doi       = {10.48550/arXiv.2609.01731}
}

arXiv citation

@misc{kapile2026trisar_arxiv,
  title        = {TriSAR: Task Coordination and Collision Avoidance for Aerial Robot Teams in Disaster Response},
  author       = {Aditya Anil Kapile and Pedro Machado and Isibor Kennedy Ihianle},
  year         = {2026},
  eprint       = {2609.01731},
  archivePrefix = {arXiv},
  primaryClass  = {cs.RO},
  doi          = {10.48550/arXiv.2609.01731}
}

📚 Reproducibility

The repository provides the components required to reproduce the experimental workflow, including:

Simulation environments
ROS 2 launch files
UAV models
GA and Greedy task allocators
PSO trajectory controller
Collision-avoidance mechanism
Energy model
Experiment runners
Raw and processed datasets
Statistical analysis scripts
Figure-generation scripts
Docker environment
Conda environment specification

The goal is to provide a transparent and reproducible benchmark for studying the interaction between multi-agent task allocation and reactive collision avoidance.

📁 Project Highlights

Component	Description
🧬 GA Allocator	Global multi-UAV task allocation
⚡ Greedy Allocator	Fast nearest-target allocation baseline
🌀 PSO Controller	Local 3D trajectory generation
🛡️ Repulsion	Reactive inter-UAV collision avoidance
🌐 ROS 2	Robot middleware and coordination
🌍 Gazebo	Physics-based simulation
🗺️ Voxel SLAM	3D environment representation
📊 Statistical Analysis	Controlled ablation evaluation

📄 License

This project is licensed under the MIT License.

See the LICENSE file for details.

⭐ Acknowledgements

This work was developed as part of research in robotics and intelligent systems at Nottingham Trent University.

If you find this project useful, consider ⭐ starring the repository and citing the associated paper.

Name		Name	Last commit message	Last commit date
ablation_results		ablation_results
analysis		analysis
configs		configs
data		data
docs		docs
experiments		experiments
figures		figures
legacy_benchmarks		legacy_benchmarks
simulation		simulation
src		src
tests		tests
trishield_core		trishield_core
trishield_gym		trishield_gym
trishield_ros2		trishield_ros2
.gitignore		.gitignore
CITATION.cff		CITATION.cff
Dockerfile		Dockerfile
HOW_TO_RUN.md		HOW_TO_RUN.md
LICENSE		LICENSE
README.md		README.md
environment.yml		environment.yml
requirements.txt		requirements.txt

Latest commit

History

Folders and files

Repository files navigation

TriSAR: Task Coordination and Collision Avoidance for Aerial Robot Teams in Disaster Response

📌 Abstract

🏗️ System Architecture

Core Components

📂 Repository Structure

🛠️ Installation & Setup

Option A: Using Conda (Recommended)

Option B: Using Pip

Option C: Using Docker

🚀 Quickstart & Reproduction Commands

1. Single Demonstration Run

2. Reproduce Table 1

3. Reproduce Statistical Analysis

4. Reproduce Figure 4

📊 Experimental Results

Table 1: Ablation Study Benchmark Summary

Collision Avoidance

Task Allocation Efficiency

Allocation Timing

🔬 Key Findings

1. Reactive collision avoidance provides a strong safety benefit

2. GA task allocation is not universally superior

3. Safety and efficiency should be evaluated jointly

4. Decoupled coordination provides a reproducible experimental framework

🧪 Experimental Design

🧰 Technologies

📄 Paper

TriSAR: Task Coordination and Collision Avoidance for Aerial Robot Teams in Disaster Response

Links

📜 Citation

arXiv citation

📚 Reproducibility

📁 Project Highlights

📄 License

⭐ Acknowledgements

About

Topics

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages