Anotaciones dinámicas en Matplotlib: Cómo usar mplcursors para destacar puntos clave al mover el cursor

Incluir anotaciones en gráficos es fundamental para resaltar la información relevante, especialmente al analizar grandes volúmenes de datos o cuando la interpretación de estos no es inmediata. Sin embargo, un exceso de anotaciones estáticas puede saturar los gráficos y dificultar su lectura. Por ejemplo, en un gráfico de dispersión con cientos de puntos, añadir etiquetas para cada uno generaría confusión en lugar de claridad. Una solución eficaz a este problema es implementar anotaciones dinámicas, que solo se muestran cuando el usuario pasa el cursor sobre los elementos del gráfico. Este enfoque permite interactuar con los datos, enfocarse en puntos específicos y explorar información adicional de forma eficiente y limpia.

En Python, la biblioteca mplcursors simplifica la creación de gráficos con anotaciones dinámicas en Matplotlib. A continuación, se mostrará cómo integrar la biblioteca en proyectos para mejorar la interactividad y la utilidad de las visualizaciones.

Introducción a la biblioteca mplcursors

mplcursors es una biblioteca ligera diseñada para trabajar con gráficos de Matplotlib. Su principal objetivo es proporcionar una forma intuitiva de agregar anotaciones dinámicas que se activan al interactuar con los gráficos mediante el cursor. Estas anotaciones pueden incluir:

• Coordenadas exactas de los puntos.
• Etiquetas personalizadas.
• Detalles adicionales calculados a partir de los datos, como valores derivados o estadísticas.

Instalación de mplcursors

Para instalar la biblioteca, se puede recurrir al gestor de paquetes pip. Simplemente se debe ejecutar el siguiente comando en una terminal:

En Analytics Lane

Programador de tareas de Windows: Guía definitiva para automatizar tu trabajo (BAT, PowerShell y Python)

pip install mplcursors

Una vez instalada, se puede integrar fácilmente en los scripts o notebooks de Python.

Configuración en entornos interactivos como Jupyter Notebook

Si se está trabajando en Jupyter Notebook o entornos similares, es necesario habilitar un backend interactivo compatible para que funcionen las anotaciones. Esto se puede hacer mediante el comando mágico %matplotlib widget. Lo que asegura que los gráficos generados sean interactivos y que las anotaciones dinámicas funcionen correctamente. Sin este paso, las características interactivas de mplcursors no estarán disponibles en el Notebook.

Configuración básica de mplcursors

Para usar mplcursors, el primer paso es crear un gráfico en Matplotlib y habilitar las anotaciones dinámicas. Aquí se muestra un ejemplo práctico:

import matplotlib.pyplot as plt
import numpy as np
import mplcursors

# Datos de ejemplo
np.random.seed(42)
x = np.random.rand(50)
y = np.random.rand(50)

# Crear un gráfico de dispersión
plt.scatter(x, y, color='blue", alpha=0.7)
plt.title("Gráfico de Dispersión con Anotaciones Dinámicas")
plt.xlabel("Eje X")
plt.ylabel("Eje Y")

# Habilitar anotaciones dinámicas con mplcursors
cursor = mplcursors.cursor(hover=True)

# Mostrar el gráfico
plt.show()

Lo que hace este código es:

1. Creación del gráfico de dispersión:
   • Se usa plt.scatter para crear un gráfico de dispersión con datos aleatorios.
   • A continuación, se incluyen etiquetas y un título para mejorar la claridad del gráfico.
2. Activación de las anotaciones dinámicas:
   • La línea cursor = mplcursors.cursor(hover=True) activa las anotaciones dinámicas.
   • El parámetro hover=True permite que las anotaciones aparecen al pasar el cursor sobre los puntos del gráfico, eliminando la necesidad de hacer clic para interactuar.
3. Anotaciones por defecto:
   • Inicialmente, las anotaciones muestran las coordenadas (X, Y) de cada punto seleccionado.
   • Más adelante, estas anotaciones se pueden personalizar para incluir información adicional, como etiquetas personalizadas o cálculos derivados.

Este enfoque básico proporciona una base sólida para integrar anotaciones dinámicas en los gráficos. En las próximas secciones, se explorará cómo personalizar estas anotaciones para adaptarlas a necesidades específicas.

Personalización de anotaciones: Incorporando etiquetas personalizadas

Con mplcursors, se puede modificar las anotaciones para incluir información específica, como etiquetas descriptivas, identificadores o valores adicionales. Esto es especialmente útil en gráficos complejos donde cada punto representa un dato significativo. Esto es lo que se hace en el siguiente ejemplo;

import matplotlib.pyplot as plt
import numpy as np
import mplcursors

# Datos de ejemplo con etiquetas
np.random.seed(42)
x = np.random.rand(10)
y = np.random.rand(10)
labels = [f"Punto {i}" for i in range(len(x))]

# Crear un gráfico de dispersión
fig, ax = plt.subplots(figsize=(8, 6))
scatter = ax.scatter(x, y, color='green', alpha=0.7, edgecolor='black')
ax.set_title("Anotaciones Personalizadas con Etiquetas", fontsize=14)
ax.set_xlabel("Eje X", fontsize=12)
ax.set_ylabel("Eje Y", fontsize=12)
ax.grid(True, linestyle="--", alpha=0.5)

# Habilitar anotaciones dinámicas con etiquetas personalizadas
cursor = mplcursors.cursor(scatter, hover=True)

@cursor.connect("add")
def on_add(sel):
    # Establecer texto personalizado
    sel.annotation.set_text(labels[sel.index])
    # Personalizar el fondo de la anotación
    sel.annotation.get_bbox_patch().set_facecolor("yellow")
    sel.annotation.get_bbox_patch().set_alpha(0.8)

plt.show()

Lo que hace este código es:

1. Generación de etiquetas personalizadas:
   • La lista labels contiene las descripciones de cada punto, generadas dinámicamente en función de su índice.
2. Configuración del evento add:
   • La función on_add se ejecuta cada vez que el cursor selecciona un punto.
   • sel.annotation.set_text(): Cambia el texto de la anotación para mostrar la etiqueta correspondiente al índice del punto.
   • get_bbox_patch(): Personaliza el fondo de la anotación, incluyendo color y transparencia.
3. Estilización del gráfico:
   • El gráfico incluye bordes en los puntos (edgecolor) y una cuadrícula para mejorar su legibilidad.

En la figura resultante, cuando se pase el cursor sobre un punto, aparecerá una anotación que muestra la etiqueta correspondiente, con un fondo amarillo semitransparente. Esta configuración hace que las anotaciones sean más visibles y útiles, especialmente en gráficos con múltiples puntos.

Gráfico de líneas con anotaciones dinámicas

Las anotaciones dinámicas no se limitan a gráficos de dispersión; también se pueden aplicar a gráficos de líneas para resaltar información en puntos específicos. Algo que es particularmente útil en análisis de series temporales o funciones matemáticas. Un ejemplo básico donde se agregan anotaciones dinámicas en un gráfico de líneas podría ser el siguiente:

import matplotlib.pyplot as plt
import numpy as np
import mplcursors

# Datos de ejemplo para un gráfico de líneas
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Crear un gráfico de líneas
fig, ax = plt.subplots(figsize=(8, 6))
line, = ax.plot(x, y, label="Seno", color="purple", linewidth=2)
ax.set_title("Gráfico de Líneas con Anotaciones Dinámicas", fontsize=14)
ax.set_xlabel("Eje X", fontsize=12)
ax.set_ylabel("Eje Y", fontsize=12)
ax.grid(True, linestyle="--", alpha=0.5)
ax.legend(fontsize=10)

# Habilitar anotaciones dinámicas
cursor = mplcursors.cursor(line, hover=True)

@cursor.connect("add")
def on_add(sel):
    # Personalizar el texto de la anotación con coordenadas
    sel.annotation.set_text(f"x = {sel.target[0]:.2f}\ny = {sel.target[1]:.2f}")
    # Personalizar el fondo de la anotación
    sel.annotation.get_bbox_patch().set_facecolor("lightblue")
    sel.annotation.get_bbox_patch().set_alpha(0.8)

plt.show()

Los pasos que se han seguido para conseguir esta gráfica son los siguientes:

1. Configuración de los datos:
   • Se utiliza np.linspace para generar valores uniformemente espaciados en el eje X, y np.sin para calcular los valores de Y.
2. Anotaciones dinámicas:
   • mplcursors.cursor() habilita las anotaciones dinámicas.
   • La función on_add personaliza el contenido de las anotaciones para mostrar las coordenadas del punto seleccionado (x e y con dos decimales).
3. Estilización del gráfico:
   • Colores y grosores: El gráfico de líneas tiene un color distintivo (purple) y un ancho de línea ajustado (linewidth=2) para mayor claridad.
   • Cuadrícula y leyenda: La cuadrícula mejora la referencia visual, mientras que la leyenda identifica la serie de datos.
4. Personalización de las anotaciones:
   • El fondo de las anotaciones se establece en azul claro con transparencia (alpha=0.8), lo que mejora la visibilidad sin obstruir el gráfico.

Al pasar el cursor sobre la línea, aparecerá una anotación que muestra las coordenadas exactas del punto resaltado. Esto permite explorar de manera interactiva los valores de la función representada.

Gráfico de barras con cálculos adicionales

Los gráficos de barras son ideales para representar datos categóricos, y al combinar mplcursors con cálculos personalizados, se puede enriquecer las anotaciones con información adicional, como porcentajes o valores acumulativos. Un ejemplo de esto sería el siguiente:

import matplotlib.pyplot as plt
import mplcursors

# Datos de ejemplo para un gráfico de barras
categories = ["A", "B", "C", "D", "E"]
values = [15, 25, 35, 20, 30]
total = sum(values)

# Crear el gráfico de barras
fig, ax = plt.subplots(figsize=(8, 6))
bars = ax.bar(categories, values, color="orange", alpha=0.8)
ax.set_title("Gráfico de Barras con Anotaciones Avanzadas", fontsize=14)
ax.set_ylabel("Valores", fontsize=12)
ax.grid(axis="y", linestyle="--", alpha=0.5)

# Habilitar anotaciones dinámicas con cálculos adicionales
cursor = mplcursors.cursor(bars, hover=True)

@cursor.connect("add")
def on_add(sel):
    # Calcular el porcentaje del total
    percentage = (values[sel.index] / total) * 100
    # Configurar el texto de la anotación
    sel.annotation.set_text(
        f"Categoría: {categories[sel.index]}\nValor: {values[sel.index]}\nPorcentaje: {percentage:.2f}%"
    )
    # Personalizar el estilo de la anotación
    sel.annotation.get_bbox_patch().set_facecolor("blue")
    sel.annotation.get_bbox_patch().set_alpha(0.7)

plt.show()

Los principales puntos de este ejemplo son:

1. Datos adicionales en las anotaciones:
   • Además del valor de cada barra, se calcula y muestra el porcentaje que representa sobre el total.
2. Estilización:
   • El fondo de las anotaciones tiene un color azul con transparencia (alpha=0.7) para mejorar la visibilidad.
   • Las anotaciones incluyen el nombre de la categoría correspondiente, lo que las hace más descriptivas.
3. Interactividad:
   • Las anotaciones aparecen al pasar el cursor sobre cada barra, evitando la sobrecarga visual típica de anotaciones estáticas.

Consejos para usar mplcursors de manera efectiva

Para maximizar la utilidad y claridad de los gráficos interactivos con mplcursors, es importante tener en cuenta los siguientes puntos:

1. Mantener la simplicidad: Asegurarse de que las anotaciones sean claras y concisas. Incluir demasiada información puede dificultar su interpretación.
2. Selección de los colores adecuados: Usar colores de fondo para las anotaciones que contrasten bien con el gráfico, sin resultar intrusivos.
3. Ajustar la transparencia: Emplear transparencias (alpha) para hacer que las anotaciones sean visibles pero no obstruyan elementos importantes del gráfico.
4. Evitar superposiciones: Si hay muchos elementos en el gráfico, se debe ajustar automáticamente la posición de las anotaciones para evitar que se solapen con otros elementos o texto.
5. Probar diferentes estilos de gráficos: Experimentar con tipos de gráficos más adecuados para los diferentes datos, como líneas, dispersión o barras apiladas, asegurándose de que las anotaciones agreguen valor.

Al seguir estos consejos, se pueden crear gráficos interactivos que no solo sean visualmente atractivos, sino también funcionales y fáciles de interpretar.

Conclusiones

Las anotaciones dinámicas son una herramienta con la que se puede mejorar la interactividad y comprensión de los gráficos, especialmente cuando se trabaja con grandes volúmenes de datos o se requiere destacar puntos clave sin saturar la visualización. Aunque Matplotlib no incluye soporte nativo para este tipo de funcionalidades, la biblioteca mplcursors ofrece una solución sencilla y altamente personalizable.

Con mplcursors, es posible transformar gráficos estáticos en herramientas interactivas que facilitan la exploración y el análisis de datos. Ya sea en gráficos de dispersión, líneas, barras u otros tipos, las anotaciones dinámicas no solo mejoran la estética de las visualizaciones, sino que también proporcionan contexto en tiempo real, adaptándose a las necesidades específicas de cada proyecto.

En resumen, integrar mplcursors en las gráficas de Matplotlib abre nuevas posibilidades para crear visualizaciones que no sólo informen, sino que también involucran al usuario de manera activa, haciendo que los datos sean más accesibles y comprensibles.