Guía Rápida de Rerun: Visualización de Planificación de Rutas Óptimas para Robots con Algoritmo RRT*
【Enlace de Descarga Gratuita】rerun Visualize streams of multimodal data. Fast, easy to use, and simple to integrate. Built in Rust using egui. Proyecto: https://gitcode.com/GitHub_Trending/re/rerun
¿Sigues frustrándote al depurar algoritmos de planificación de rutas para robots? Ante la optimización de trayectorias en entornos complejos, las herramientas de depuración tradicionales suelen generar datos de registro monótonos, dificultando la evaluación visual del rendimiento del algoritmo. En este artículo, te mostraremos cómo utilizar Rerun (una herramienta de visualización de datos multimodales de código abierto) para implementar la visualización en tiempo real de trayectorias de movimiento robótico mediante el algoritmo RRT* (versión optimizada del algoritmo de Árbol de Exploración Rápida Aleatoria), haciendo que el proceso de planificación de rutas sea completamente transparente.
Al finalizar este artículo, habrás aprendido:
- Métodos rápidos para desplegar el entorno de visualización de Rerun
- Principios fundamentales y pasos de implementación del algoritmo RRT*
- Cómo registrar y visualizar en tiempo real el proceso de planificación de rutas con Python
- Técnicas de ajuste de parámetros clave y análisis de efectos de evitación de obstáculos
¿Por qué elegir Rerun para la visualización de planificación de rutas?
En el campo de la planificación de rutas para robots, la depuración y optimización de algoritmos dependen de una observación intuitiva del proceso. Los métodos tradicionales presentan tres desafíos principales:
- Los archivos de registro son extensos, dificultando el seguimiento del proceso dinámico del algoritmo
- La relación entre las rutas generadas y los obstáculos no es intuitiva, complicando la depuración de la lógica de evitación
- La comparación de rendimiento bajo diferentes configuraciones de parámetros carece de base visual
Rerun, como herramienta de visualización diseñada específicamente para flujos de datos multimodales, resuelve perfectamente estos problemas. Desarrollado en Rust e implementado con el motor gráfico egui, admite la visualización en tiempo real de múltiples tipos de datos como nubes de puntos 2D/3D, líneas y texto. Su arquitectura es clara y ofrece SDKs para Python, C++, Rust y otros lenguajes, facilitando su integración en sistemas robóticos existentes.
Ventajas principales del proyecto:
- Diseño ligero, rápido inicio y bajo consumo de recursos
- Soporte para datos de series temporales, permitiendo retrovisitar cada paso de la planificación
- Interfaz de usuario personalizable con múltiples vistas síncronas
- Código abierto, documentación completa y comunidad activa
Principios e Implementación del Algoritmo RRT*
Conceptos Fundamentales de RRT*
RRT* (Rapidly-exploring Random Tree Star) es un algoritmo de planificación de rutas óptimas basado en muestreo, que construye progresivamente un árbol de movimiento mediante muestreo aleatorio para encontrar finalmente la ruta óptima desde el punto de inicio hasta el destino. En comparación con el algoritmo RRT básico, RRT* incorpora un proceso de reconfiguración (Rewiring) que optimiza la estructura del árbol, reduciendo gradualmente el costo de la ruta hasta converger con la solución teóricamente óptima.
Pasos básicos del algoritmo:
- Inicializar el árbol aleatorio desde el punto de inicio
- Muestrear puntos aleatorios en el espacio y generar nuevos nodos
- Verificar si la trayectoria entre el nuevo nodo y su padre colisiona
- Reconfigurar los nodos cercanos para optimizar el costo de la ruta
- Finalizar cuando se encuentre el destino o se alcance el número máximo de iteraciones
Estructuras de Datos Clave
En ejemplos/python/rrt_estrella/rrt_estrella.py, la implementación del algoritmo depende principalmente de tres clases fundamentales:
# Clase de nodo: almacena posición, costo y relaciones padre-hijo
class Vertice:
progenitor: Vertice | None
posicion: Punto2D # Punto de coordenadas 2D
costo: float # Costo desde el inicio hasta este nodo
descendientes: list[Vertice] # Lista de nodos hijos
# Clase de árbol aleatorio: gestiona nodos y estructura del árbol
class ArbolAleatorio:
raiz: Vertice # Nodo raíz (punto de inicio)
def mas_cercano(self, punto: Punto2D) -> Vertice: # Encuentra el nodo más cercano
def agregar_vertice(self, padre: Vertice, vertice: Vertice) -> None: # Agrega un nuevo nodo
def segmentos(self) -> list[tuple[Punto2D, Punto2D]]: # Obtiene los bordes del árbol
# Clase de mapa: gestiona obstáculos y detección de colisiones
class Entorno:
obstaculos: list[tuple[Punto2D, Punto2D]] # Colección de segmentos de obstáculos
def interseccion_con_obstaculo(self, inicio: Punto2D, fin: Punto2D) -> bool: # Detección de colisiones
Implementación Central del Algoritmo
La lógica principal de búsqueda de rutas se implementa en la función planificador_rrt, con pasos clave que incluyen muestreo aleatorio, expansión de nodos y optimización de rutas:
def planificador_rrt(ent: Entorno, inicio: Punto2D, destino: Punto2D, tamano_paso_max: float,
tamano_vecindario: float, num_iter: int | None) -> list[tuple[Punto2D, Punto2D]] | None:
arbol = ArbolAleatorio(inicio) # Inicialización del árbol
while condicion_iteracion:
# 1. Muestreo aleatorio
punto_aleatorio = np.multiply(np.random.rand(2), [2, 1])
# 2. Buscar nodo más cercano y generar nuevo nodo
nodo_cercano = arbol.mas_cercano(punto_aleatorio)
nuevo_punto = desviar(nodo_cercano.posicion, punto_aleatorio, tamano_paso_max)
# 3. Detección de colisiones
if not ent.interseccion_con_obstaculo(nodo_cercano.posicion, nuevo_punto):
# 4. Selección del nodo padre óptimo
nodos_cercanos = arbol.en_vecindario(nuevo_punto, tamano_vecindario)
nodo_minimo = encontrar_nodo_costo_minimo(nodos_cercanos, nuevo_punto)
# 5. Agregar nuevo nodo
nodo_agregado = Vertice(nodo_minimo, nuevo_punto, costo + nodo_minimo.costo)
arbol.agregar_vertice(nodo_minimo, nodo_agregado)
# 6. Reconfiguración para optimización
reconfigurar_vecindario(arbol, nodo_agregado, nodos_cercanos)
# 7. Verificación de llegada al destino
if distancia(nuevo_punto, destino) < tamano_paso_max:
return ruta_a_raiz(nodo_destino) # Retorna ruta óptima
Práctica con Visualización Rerun
Preparación y Despliegue del Entorno
Primero, clona el repositorio del proyecto e instala las dependencias:
git clone https://gitcode.com/GitHub_Trending/re/rerun
cd GitHub_Trending/re/rerun
pip install -e ejemplos/python/rrt_estrella
Una vez instalado, ejecuta directamente el programa de ejemplo:
python -m rrt_estrella --iteraciones 500
El programa iniciará automáticamente la interfaz de visualización de Rerun, mostrando todo el proceso de planificación de rutas. Puedes verificar más opciones de configuarción con el parámetro --help:
python -m rrt_estrella --ayuda
Registro de Datos para Visualización
En la implementación del algoritmo RRT*, los datos clave se registran mediante el SDK de Python de Rerun:
# Registro de puntos de inicio y destino
rr.registro("mapa/inicio", rr.Puntos2D([punto_inicio], radios=0.02, colores=[[255, 255, 255, 255]]))
rr.registro("mapa/destino", rr.Puntos2D([punto_destino], radios=0.02, colores=[[255, 255, 0, 255]]))
# Registro de obstáculos
rr.registro("mapa/obstaculos", rr.Lineas2D(self.obstaculos))
# Registro del árbol aleatorio
rr.registro("mapa/arbol/bordes", rr.Lineas2D(arbol.segmentos(), radios=0.0005, colores=[0, 0, 255, 128]))
rr.registro("mapa/arbol/vertices", rr.Puntos2D([vertice.posicion for vertice in arbol], radios=0.002))
# Registro de nuevos bordes y nodos generados
rr.registro("mapa/nuevo/nuevo_borde", rr.Lineas2D([(nodo_cercano.posicion, nuevo_punto)], colores=[color], radios=0.001))
rr.registro("mapa/nuevo/punto_aleatorio", rr.Puntos2D([punto_aleatorio], radios=0.008))
Estos códigos registran elementos clave del proceso algorítmico (inicio, destino, obstáculos, árbol aleatorio, rutas, etc.) en diferentes canales, que pueden controlarse por separado en la interfaz de Rerun.
Análisis de la Interfaz de Visualización
La interfaz de Rerun se divide por defecto en dos partes: la vista del mapa 2D a la izquierda y la documentación de explicación del algoritmo a la derecha. En la vista del mapa, puedes observar:
- Puntos blancos grandes: punto de inicio
- Puntos amarillos grandes: punto de destino
- Líneas azules: estructura del árbol aleatorio
- Líneas verdes: nuevos bordes válidos generados
- Líneas rojas: bordes inválidos que colisionan con obstáculos
- Líneas cian: ruta óptima final después de la optimización
Mediante la barra de tiempo, puedes retrovisitar cada paso de la planificación de rutas, observando cómo el árbol aleatorio se expande gradualmente y encuentra la ruta óptima. Al pasar el ratón sobre un nodo, también se muestra el costo de la ruta en ese nodo, ayudando a analizar el proceso de optimización del algoritmo.
Ajuste de Parámetros y Análisis de Efectos de Evitación de Obstáculos
Impacto de los Parámetros Clave
El rendimiento del algoritmo RRT* depende en gran medida de la configuración de parámetros, y la visualización en Rerun permite comparar intuitivamente el efecto de diferentes parámetros:
- Tamaño de paso (tamano_paso_max): Controla la distancia de cada expansión
- Demasiado pequeño: la expansión del árbol es lenta, el tiempo de convergencia es prolongado
- Demasiado grande: puede saltar canales estrechos, aumentando el riesgo de colisiones
- Radio de vecindario (tamano_vecindario): El rango de nodos considerados durante la reconfiguración
- Demasiado pequeño: el efecto de reconfiguración es pobre, la optimización de la ruta es insuficiente
- Demasiado grande: aumenta la carga computacional, reduciendo la eficiencia del algoritmo
- Número de iteraciones (iteraciones): Número máximo de pasos de ejecución del algoritmo
- Insuficiente: puede no encontrar la ruta óptima
- Excesivo: aumenta el tiempo de cómputo, con rendimientos decrecientes
Análisis de Efectos de Evitación de Obstáculos
En el mapa predeterminado, el algoritmo debe evitar varios tipos de obstáculos:
# Definición de obstáculos del mapa predeterminado (rrt_estrella.py 138-146)
segmentos = [
((0, 0), (0, 1)), # Línea exterior
((0, 1), (2, 1)),
((2, 1), (2, 0)),
((2, 0), (0, 0)),
((1.0, 0.0), (1.0, 0.65)), # Obstáculo vertical
((1.5, 1.0), (1.5, 0.2)),
((0.4, 0.2), (0.4, 0.8)),
]
Al ajustar los parámetros, observa cómo la ruta encuentra el canal óptimo entre estos obstáculos:
- Cuando el tamaño de paso se establece en 0.05, la ruta está más cerca del borde de los obstáculos, ahorrando espacio pero reduciendo la seguridad
- Cuando el tamaño de paso es 0.2, la ruta está más alejada de los obstáculos, mejorando la seguridad pero aumentando el costo de la ruta
- Aumentar adecuadamente el radio de vecindario puede ayudar al algoritmo a encontrar rutas de desvío óptimas
Expansión del Proyecto y Casos de Aplicación
Soporte Multi-lenguaje
Además de Python, Rerun ofrece implementaciones de ejemplo en C++ y Rust:
- Ejemplo en C++: ejemplos/cpp/rrt_estrella/
- Ejemplo en Rust: ejemplos/rust/rrt_estrella/
Puedes elegir el lenguaje adecuado según las necesidades de tu proyecto.
Escenarios de Aplicación Práctica
El algoritmo RRT* tiene aplicaciones extensivas en el campo de la robótica:
- Navegación de robots móviles: Planificación de rutas para AGVs industriales y robots de servicio
- Planificación de trayectorias de drones: Generación de rutas de vuelo con evitación de obstáculos
- Planificación de movimiento de brazos robóticos: Optimización de rutas en el espacio de articulaciones
- Conducción autónoma: Planificación de rutas locales y evitación de obstáculos
Combinado con la visualización de Rerun, la eficiencia de desarrollo y depuración de estas aplicaciones mejorará significativamente.
Conclusión y Perspectivas
Este artículo ha introducido cómo utilizar la herramienta de visualización Rerun para observar en tiempo real el proceso de planificación de rutas del algoritmo RRT*. A través de la interfaz de visualización intuitiva, podemos ver claramente cada paso de la expansión del árbol aleatorio, la detección de colisiones y la optimización de rutas, reduciendo significativamente la dificultad de depuración de algoritmos.
Direcciones de optimización futuras para el proyecto:
- Añadir visualización de planificación de rutas en entornos 3D
- Implementar observación síncrona de planificación de rutas colaborativas multi-robot
- Desarrollar herramientas de ajuste automático de parámetros que recomienden parámetros óptimos basados en resultados de visualización
Rerun, como potente herramienta de visualización de datos multimodales, no solo es aplicable a la planificación de rutas, sino también a múltiples campos de la robótica como SLAM, fusión de datos de sensores y conducción autónoma. Esperamos que esta guía te ayude a familiarizarte rápidamente con Rerun y a aplicarlo en proyectos reales, mejorando la eficiencia de desarrollo.
Si este artículo te ha resultado útil, no dudes en dar like, guardar y seguir al autor para obtener más técnicas de desarrollo robótico y visualización. En el próximo número, presentaremos cómo integrar Rerun con ROS2 para lograr la visualización de datos de toda la cadena de sistemas robóticos.
Recursos del proyecto:
- Código de ejemplo completo: ejemplos/python/rrt_estrella/
- Documentación oficial: docs/content/getting-started.md
- SDK de Python de Rerun: rerun_py/
- Artículo de referencia del algoritmo: Karaman, S. Frazzoli, S. 2011. "Sampling-based algorithms for optimal motion planning"
【Enlace de Descarga Gratuita】rerun Visualize streams of multimodal data. Fast, easy to use, and simple to integrate. Built in Rust using egui. Proyecto: https://gitcode.com/GitHub_Trending/re/rerun