# Showcase Applications
Complete demonstration applications that highlight real-world use cases of the Gazebo MCP Server. Each application is production-quality, documented, and ready to demonstrate.
---
## Overview
Showcase applications serve multiple purposes:
- **Proof of Concept**: Demonstrate real-world applicability
- **Inspiration**: Show what's possible
- **Templates**: Starting points for similar projects
- **Marketing**: Impressive demos for stakeholders
- **Education**: Complete examples for learning
---
## Available Applications
### 1. Warehouse Automation Demo (`warehouse_automation/`)
**Scenario**: Autonomous robot fleet manages warehouse inventory
**Features**:
- Multi-robot coordination
- Task allocation and scheduling
- Obstacle avoidance in dynamic environment
- Package pickup and delivery simulation
- Performance metrics and optimization
**Technologies**:
- Fleet of TurtleBot3 robots
- Nav2 for autonomous navigation
- Custom task scheduler
- Warehouse world with shelves and packages
**Metrics Demonstrated**:
- Tasks completed per hour
- Average delivery time
- Robot utilization percentage
- Collision-free operation time
**Run Time**: 15-20 minutes demo
**Wow Factor**: ⭐⭐⭐⭐⭐
**Best For**:
- Logistics companies
- Automation conferences
- ROI demonstrations
- Multi-robot system showcases
---
### 2. Search and Rescue Simulation (`search_rescue/`)
**Scenario**: Robots autonomously explore disaster zone to locate survivors
**Features**:
- Autonomous exploration of unknown terrain
- Victim detection using camera and thermal sensors
- Multi-robot collaborative search
- Path planning around rubble and obstacles
- Real-time mapping and coordination
**Technologies**:
- Mixed robot types (ground and aerial)
- SLAM for mapping
- Computer vision for victim detection
- Dynamic world with rubble obstacles
- Thermal sensor simulation
**Metrics Demonstrated**:
- Area coverage percentage
- Victims found vs. time
- Map quality metrics
- Multi-robot efficiency gain
**Run Time**: 20-30 minutes demo
**Wow Factor**: ⭐⭐⭐⭐⭐
**Best For**:
- Emergency response demonstrations
- Computer vision conferences
- Research labs (SLAM, exploration)
- Public safety presentations
---
### 3. Agricultural Monitoring (`agricultural_monitoring/`)
**Scenario**: Autonomous robots monitor crop health in agricultural field
**Features**:
- Field traversal with path planning
- Plant health assessment using vision
- Soil moisture sensing simulation
- Coverage path planning
- Data collection and analysis
**Technologies**:
- Agricultural field world (rows of crops)
- Custom sensors (multispectral camera simulation)
- Efficient coverage path algorithms
- Data visualization and analytics
**Metrics Demonstrated**:
- Field coverage efficiency
- Plants inspected per hour
- Detection accuracy
- Fuel/energy efficiency
**Run Time**: 15 minutes demo
**Wow Factor**: ⭐⭐⭐⭐
**Best For**:
- Agricultural technology events
- Precision agriculture demos
- Environmental monitoring
- Autonomous systems research
---
### 4. Delivery Drone Coordination (`delivery_drones/`)
**Scenario**: Fleet of drones coordinate to deliver packages in urban environment
**Features**:
- 3D path planning (aerial navigation)
- No-fly zone avoidance
- Weather effects (wind, rain)
- Landing zone detection
- Battery management and recharging
**Technologies**:
- Quadcopter drone models
- 3D urban environment
- Wind simulation
- Battery drain modeling
- Multi-drone task allocation
**Metrics Demonstrated**:
- Deliveries per hour
- Average delivery time
- Energy efficiency
- Safety (collision avoidance)
**Run Time**: 15-20 minutes demo
**Wow Factor**: ⭐⭐⭐⭐⭐
**Best For**:
- Drone technology conferences
- Last-mile delivery demos
- Urban robotics showcases
- Autonomous aerial vehicle research
---
### 5. Autonomous Exploration (`autonomous_exploration/`)
**Scenario**: Robot explores unknown environment and creates detailed map
**Features**:
- Frontier-based exploration
- SLAM for mapping
- Autonomous decision-making
- Unknown terrain navigation
- Complete area coverage
**Technologies**:
- Advanced SLAM algorithms
- Frontier detection
- Dynamic obstacle handling
- Map visualization
- Exploration metrics
**Metrics Demonstrated**:
- Exploration efficiency
- Map accuracy
- Coverage percentage vs. time
- Path optimality
**Run Time**: 20 minutes demo
**Wow Factor**: ⭐⭐⭐⭐
**Best For**:
- Research presentations (SLAM, exploration)
- Autonomous systems conferences
- Algorithm demonstrations
- Educational purposes
---
## Application Structure
Each showcase application directory contains:
```
showcase_apps/app_name/
├── README.md # Application overview
├── SETUP.md # Setup instructions
├── DEMO_SCRIPT.md # How to demonstrate
├── ARCHITECTURE.md # Technical architecture
├── src/
│ ├── main.py # Main application
│ ├── robot_controller.py # Robot control logic
│ ├── task_scheduler.py # Task management
│ └── visualization.py # Data visualization
├── worlds/
│ ├── app_world.sdf # Gazebo world file
│ └── models/ # Custom models
├── config/
│ ├── robots.yaml # Robot configurations
│ ├── tasks.yaml # Task definitions
│ └── params.yaml # Application parameters
├── launch/
│ ├── full_demo.launch.py # Complete demo launcher
│ └── components/ # Individual component launchers
├── docs/
│ ├── user_guide.md # User documentation
│ ├── developer_guide.md # Development guide
│ └── api_reference.md # API documentation
├── tests/
│ ├── test_controller.py # Unit tests
│ ├── test_scheduler.py # Integration tests
│ └── test_full_demo.py # End-to-end tests
├── data/
│ ├── results/ # Demo run results
│ ├── metrics/ # Performance metrics
│ └── visualizations/ # Charts and graphs
└── videos/
├── demo_recording.mp4 # Full demo video
├── highlights.mp4 # Short highlights
└── tutorial.mp4 # How-to video
```
---
## Quick Start
### Run a Showcase App
```bash
# Navigate to app directory
cd showcase_apps/warehouse_automation
# Run setup (first time only)
./setup.sh
# Launch demo
./launch_demo.sh
# Or use ROS2 launch
ros2 launch warehouse_automation full_demo.launch.py
```
### Customize Parameters
```bash
# Edit configuration
nano config/params.yaml
# Common parameters:
# - number_of_robots: 5
# - task_complexity: medium
# - visualization: true
# - metrics_collection: true
# Launch with custom config
./launch_demo.sh --config config/params_custom.yaml
```
---
## Demo Scripts
Each application includes a demo script optimized for presentations:
### Standard Demo Flow
**1. Introduction** (2 min)
- Problem statement
- Solution overview
- Key capabilities
**2. Setup** (2 min)
- Launch environment
- Spawn robots
- Initialize systems
**3. Demonstration** (10-15 min)
- Main scenario execution
- Highlight key features
- Show real-time metrics
**4. Analysis** (3 min)
- Performance metrics
- Comparison to baseline
- Insights and takeaways
**5. Q&A** (5 min)
- Answer questions
- Show additional capabilities
- Provide resources
---
## Comparison Matrix
| Application | Complexity | Setup Time | Run Time | Wow Factor | Best Audience |
|-------------|------------|------------|----------|------------|---------------|
| Warehouse | High | 5 min | 15-20 min | ⭐⭐⭐⭐⭐ | Industry, logistics |
| Search & Rescue | Very High | 10 min | 20-30 min | ⭐⭐⭐⭐⭐ | Public safety, research |
| Agriculture | Medium | 5 min | 15 min | ⭐⭐⭐⭐ | AgTech, environment |
| Delivery Drones | High | 7 min | 15-20 min | ⭐⭐⭐⭐⭐ | Drone companies, urban tech |
| Exploration | Medium | 5 min | 20 min | ⭐⭐⭐⭐ | Research, education |
---
## Development Guide
### Creating a New Showcase App
1. **Choose Use Case**
- Real-world problem
- Demonstrates key features
- Visually impressive
- Technically interesting
2. **Design Architecture**
- Robot types needed
- World environment
- Task workflow
- Metrics to track
3. **Implement Core Features**
- Robot control
- Task management
- Coordination (if multi-robot)
- Data collection
4. **Create World and Models**
- Design Gazebo world
- Custom models if needed
- Test performance
5. **Add Visualization**
- Real-time metrics dashboard
- Map visualization
- Task status indicators
6. **Write Documentation**
- Setup guide
- Demo script
- Architecture overview
- User guide
7. **Test Thoroughly**
- Multiple test runs
- Edge cases
- Recovery procedures
- Performance benchmarks
8. **Record Demo Video**
- High-quality recording
- Narration
- Highlights clip
- Tutorial version
---
## Technical Requirements
### Hardware
**Minimum** (for basic apps):
- 8 GB RAM
- 4 CPU cores
- Integrated graphics
**Recommended** (for smooth demos):
- 16 GB RAM
- 8 CPU cores
- Dedicated GPU (NVIDIA, AMD, Intel)
**Optimal** (for complex multi-robot scenarios):
- 32 GB RAM
- 12+ CPU cores
- High-end GPU
- SSD storage
### Software
**Required**:
- Ubuntu 22.04 or 24.04
- ROS2 Humble
- Gazebo Harmonic
- Gazebo MCP Server
- Python 3.10+
**Application-Specific**:
- Nav2 (for navigation apps)
- Computer vision libraries (for detection apps)
- SLAM packages (for exploration apps)
---
## Customization
### Modifying Difficulty
**Easy Mode** (quick demos):
```yaml
# config/params.yaml
difficulty: easy
robots: 2
tasks: 5
obstacles: minimal
visualization: simplified
```
**Hard Mode** (impressive demos):
```yaml
difficulty: hard
robots: 10
tasks: 50
obstacles: complex
visualization: full
real_time_metrics: true
```
### Adding Features
```python
# src/custom_feature.py
class CustomFeature:
"""Add your custom capability"""
def execute(self):
# Implement feature
pass
# Register in main.py
from custom_feature import CustomFeature
app.add_feature(CustomFeature())
```
---
## Performance Benchmarks
### Warehouse Automation
| Metric | Target | Typical | Best |
|--------|--------|---------|------|
| Tasks/hour | 50 | 65 | 80 |
| Success rate | >95% | 98% | 100% |
| Robot utilization | >80% | 85% | 92% |
| Avg delivery time | <3 min | 2.5 min | 2 min |
### Search & Rescue
| Metric | Target | Typical | Best |
|--------|--------|---------|------|
| Area coverage | 80% | 85% | 95% |
| Victims found | >90% | 95% | 100% |
| Time to first | <5 min | 4 min | 3 min |
| Map accuracy | >85% | 90% | 95% |
---
## Troubleshooting
### App Won't Launch
```bash
# Check dependencies
./check_dependencies.sh
# Verify ROS2 environment
source /opt/ros/humble/setup.bash
ros2 pkg list | grep navigation2
# Check Gazebo
gz model --list
# Review logs
tail -f ~/.ros/log/latest/rosout.log
```
### Poor Performance
```bash
# Reduce complexity
# Edit config/params.yaml:
robots: 2 # Reduce from 5
visualization: false # Disable heavy viz
gui: false # Headless mode
# Check system resources
htop
nvidia-smi # If using GPU
```
### Robots Not Coordinating
```bash
# Check ROS2 topics
ros2 topic list
ros2 topic echo /task_allocation
# Verify multi-robot setup
ros2 node list
ros2 param list /robot_coordinator
# Review coordination logs
cat logs/coordination.log
```
---
## Best Practices
### For Demonstrations
1. **Practice First**: Run through 3+ times before live demo
2. **Have Backups**: Pre-recorded video if live fails
3. **Start Simple**: Begin with basic scenario, add complexity
4. **Explain Context**: Help audience understand what they're seeing
5. **Show Metrics**: Real-time data makes it compelling
### For Development
1. **Modular Design**: Easy to swap components
2. **Configurable**: Parameters in YAML, not hardcoded
3. **Tested**: Comprehensive test coverage
4. **Documented**: Clear docs for users and developers
5. **Robust**: Handle failures gracefully
### For Presentations
1. **Know Your Audience**: Adjust technical depth
2. **Tell a Story**: Context → Problem → Solution → Impact
3. **Interactive**: Allow audience questions and suggestions
4. **Time Management**: Stay within allocated time
5. **Follow Up**: Provide resources for learning more
---
## Contributing
Want to add a showcase app?
**Requirements**:
- Solves real-world problem
- Technically impressive
- Well-documented
- Fully tested
- Includes demo script and video
**Process**:
1. Propose use case (GitHub issue)
2. Get feedback and approval
3. Develop application
4. Submit PR with all components
5. Review and merge
---
## Resources
**Application Examples**:
- ROS2 demo applications
- Gazebo example worlds
- Nav2 demo scenarios
**Development Tools**:
- RViz for visualization
- Plotjuggler for data
- RQt for debugging
**Community**:
- Share your demos!
- Discord/Slack showcases
- Monthly demo sessions
---
## License & Attribution
All showcase applications are open source (MIT License).
**When using in presentations**:
- Credit the Gazebo MCP project
- Link to repository
- Mention if modified
**When publishing results**:
- Cite project and authors
- Share modifications
- Contribute improvements back
---
**Ready to showcase?** Start with the warehouse automation demo - it's the most impressive and reliable for general audiences!
```bash
cd showcase_apps/warehouse_automation
./launch_demo.sh
```
🚀 **Happy Demonstrating!**
