1 Plotly en R

El paquete Plotly en R surge como la adaptación de plotly.js, una librería desarrollada en JavaScript en 2012 con el objetivo de generar gráficos interactivos basados en tecnologías web. En sus inicios fue una plataforma cerrada, pero a partir de 2015 se liberó su código bajo licencia MIT, lo que permitió su rápida expansión y la creación de interfaces en diferentes lenguajes como Python, Julia y R.

En el ecosistema de R, Plotly se integra mediante el paquete plotly, que utiliza la infraestructura de htmlwidgets. Esto le permite generar gráficos dinámicos que pueden visualizarse tanto en RStudio como en entornos reproducibles como R Markdown y aplicaciones interactivas en Shiny.

La finalidad principal de este paquete es clara: convertir la visualización en una herramienta de exploración y no en un producto terminado. Mientras que librerías como ggplot2 o lattice generan gráficos estáticos muy estéticos, Plotly añade una capa extra al permitir acercar, desplazar, filtrar y obtener detalles al pasar el cursor sobre los datos.

De esta forma, Plotly representa una evolución natural en el flujo de trabajo de quienes ya utilizan gráficos en R, pues incluso permite transformar un gráfico de ggplot2 en uno interactivo con una sola línea de código mediante la función ggplotly().

2 Librería plotly

library(plotly)
## Cargando paquete requerido: ggplot2
## 
## Adjuntando el paquete: 'plotly'
## The following object is masked from 'package:ggplot2':
## 
##     last_plot
## The following object is masked from 'package:stats':
## 
##     filter
## The following object is masked from 'package:graphics':
## 
##     layout

2.1 Base de datos

La base de datos gapminder contiene información sobre el desarrollo socioeconómico y demográfico de distintos países del mundo entre los años 1952 y 2007, en intervalos de cinco años.

Fue creada por la organización Gapminder Foundation, fundada por el estadístico sueco Hans Rosling, con el propósito de mostrar cómo el progreso global en salud y economía ha cambiado a lo largo del tiempo.

library(gapminder)
head(gapminder)
  • country: Nombre del país.
  • continent: Continente al que pertenece el país.
  • year: Año de observación, en intervalos de 5 años, desde 1952 hasta 2007.
  • lifeExp: Esperanza de vida promedio al nacer, medida en años.
  • pop: Población total del país en ese año.
  • gdpPercap: Producto Interno Bruto (PIB) per cápita en dólares internacionales ajustados por poder adquisitivo (PPP).

3 Estructura de la función plot_ly()

La función plot_ly() es la función principal del paquete Plotly en R.
Permite construir gráficos interactivos especificando los datos, las variables que se asignan a los ejes y el tipo de gráfico a generar.

plot_ly(
  data = gapminder,
  x = ~continent,        
  y = ~lifeExp,     
  type = "box"           
)
Categoría Valor de type Descripción
Gráficos básicos (2D) scatter Gráfico de dispersión o líneas. Admite modos como “markers” o “lines”.
bar Gráfico de barras (vertical u horizontal).
box Diagrama de cajas que muestra mediana, cuartiles y outliers.
histogram Histograma para distribución de frecuencias.
violin Gráfico de violín (densidad y distribución).
pie Gráfico circular o de pastel.
funnel Gráfico de embudo (etapas de un proceso).
Gráficos geográficos scattergeo Puntos o líneas en mapas geográficos (latitud/longitud).
choropleth Mapa coloreado por regiones o países.
scattermapbox Puntos o líneas sobre mapas de Mapbox.
densitymapbox Mapa de densidad geográfica.
scattergl Versión optimizada de dispersión para grandes volúmenes de datos (WebGL).
Gráficos 3D scatter3d Dispersión tridimensional (x, y, z).
surface Superficie tridimensional generada por una matriz de valores.
mesh3d Malla tridimensional para formas o volúmenes.
line3d Líneas tridimensionales.
Calor y densidad heatmap Mapa de calor bidimensional (x, y, z).
contour Gráfico de curvas de nivel o isovalores.
density Visualización de densidad de puntos.
Jerárquicos y radiales sunburst Diagrama jerárquico radial tipo sol.
treemap Jerarquías en rectángulos anidados.
icicle Diagrama jerárquico descendente.
scatterpolar Gráfico polar (coordenadas angulares y radiales).
Financieros candlestick Gráfico de velas (precios de apertura, cierre, máximo, mínimo).
ohlc Gráfico financiero Open-High-Low-Close.
waterfall Gráfico de cascada (acumulación de ganancias/pérdidas).
Especiales parcoords Coordenadas paralelas para variables multivariadas.
sankey Diagrama de flujo entre categorías.
table Tabla interactiva.
indicator Indicadores numéricos o KPIs (paneles de control). 
plot_ly(
  data = gapminder,
  x = ~continent,         
  y = ~lifeExp,    
  type = "box",
  color = ~continent
) %>%
  layout(
    title = "Distribución de la esperanza de vida por continente",
    xaxis = list(title = "Continente"),
    yaxis = list(title = "Esperanza de vida (años)")
  )

4 Gráfico 3D

El paquete Plotly también permite representar funciones tridimensionales de forma interactiva mediante el parámetro type = "surface". Este tipo de visualización es especialmente útil para explorar superficies matemáticas, modelos predictivos o relaciones no lineales entre variables.

x <- seq(-5, 5, length.out = 50)
y <- seq(-5, 5, length.out = 50)
z <- outer(x, y, function(a, b) a^2 + b^2)   # Paraboloide

# Gráfico 3D de superficie
plot_ly(x = ~x, y = ~y, z = ~z, type = "surface",
        colorscale = "Viridis") %>%
  layout(title = "Superficie 3D del paraboloide (z = x² + y²)",
         scene = list(
           xaxis = list(title = "Eje X"),
           yaxis = list(title = "Eje Y"),
           zaxis = list(title = "Eje Z")
         ))

5 Mapa

Otra de las capacidades destacadas del paquete Plotly es la generación de mapas interactivos, los cuales permiten representar información geográfica mediante visualizaciones dinámicas. En este ejemplo se utiliza la función plot_ly() con el argumento type = “choropleth” para construir un mapa mundial que muestra la esperanza de vida por país en el año 2007, utilizando los datos del conjunto gapminder.

# Filtramos un año (2007)
gap_map <- subset(gapminder, year == 2007)

plot_ly(
  data = gap_map,
  type = "choropleth",
  locations = ~country,       # Nombre del país
  locationmode = "country names",  # Coincidir con nombres de países
  z = ~lifeExp,               # Variable a representar
  text = ~paste(country, "<br>Esperanza de vida:", round(lifeExp, 1)),
  colorscale = "Viridis",
  colorbar = list(title = "Años"),
  marker = list(line = list(color = "gray", width = 0.3))
) %>%
  layout(
    title = "Esperanza de vida por país (2007)",
    geo = list(
      showframe = FALSE,
      showcoastlines = TRUE,
      projection = list(type = "natural earth")
    )
  )

6 Mapa de calor de correlaciones

El paquete Plotly también permite representar matrices de datos mediante gráficos de calor, utilizando el argumento type = "heatmap". En este caso, se construyó un mapa de calor de correlaciones a partir de tres variables numéricas del conjunto gapminder: la esperanza de vida (lifeExp), la población (pop) y el PIB per cápita (gdpPercap).

# Seleccionamos variables numéricas
gap_corr <- gapminder %>%
  select(lifeExp, pop, gdpPercap)

# Calculamos la matriz de correlación
mat_corr <- cor(gap_corr, method = "pearson")

# Visualización con plotly
plot_ly(
  x = colnames(mat_corr),
  y = rownames(mat_corr),
  z = mat_corr,
  type = "heatmap",
  colorscale = "Viridis",       # Escala de color
  reversescale = TRUE
) %>%
  layout(
    title = "Mapa de calor de correlaciones (Gapminder)",
    xaxis = list(title = ""),
    yaxis = list(title = "")
  )

7 Motor WebGL

Una de las innovaciones más relevantes en Plotly es la incorporación de WebGL (Web Graphics Library), un motor de renderizado que aprovecha la aceleración gráfica del navegador para trabajar con grandes volúmenes de datos de manera fluida.

En gráficos tradicionales, representar más de unos pocos miles de puntos puede ralentizar la visualización, dificultando el zoom, el desplazamiento o incluso la carga del gráfico. Con WebGL, es posible manejar decenas de miles o incluso millones de observaciones sin pérdida de rendimiento, lo que resulta clave en contextos de Big Data o análisis exploratorio de grandes bases de datos.

En R, esta capacidad se activa mediante el uso de trazas específicas como scattergl para diagramas de dispersión o heatmapgl para mapas de calor. El beneficio es inmediato: la experiencia interactiva se mantiene ágil aunque el número de observaciones sea muy alto.

El siguiente ejemplo muestra un diagrama de dispersión con 20,000 puntos, que gracias a WebGL conserva fluidez al aplicar acciones de zoom y desplazamiento:

library(plotly)

set.seed(42)
n <- 20000
df <- data.frame(
  x = rnorm(n),
  y = rnorm(n),
  grupo = sample(LETTERS[1:5], n, replace = TRUE)
)
library(plotly)

set.seed(123)
n <- 15000
df_comp <- data.frame(
  x = rnorm(n),
  y = rnorm(n),
  grupo = sample(letters[1:3], n, replace = TRUE)
)
# Gráfico con scatter tradicional
p1 <- plot_ly(df_comp,
              x = ~x, y = ~y,
              type = "scatter", mode = "markers",
              color = ~grupo, colors = "Set1",
              marker = list(size = 4, opacity = 0.5)) %>%
  layout(title = "Scatter clásico (sin WebGL)")
p1
# Gráfico con scattergl (WebGL)
p2 <- plot_ly(df_comp,
              x = ~x, y = ~y,
              type = "scattergl", mode = "markers",
              color = ~grupo, colors = "viridis",
              marker = list(size = 4, opacity = 0.5)) %>%
  layout(title = "Scatter con WebGL (más fluido)")
p2

8 Interactividad y compatibilidad

8.1 Con ggplot2

Una ventaja de Plotly es su capacidad para convertir gráficos de ggplot2 en versiones interactivas mediante la función ggplotly().

library(ggplot2)

p_ggplot <- ggplot(gapminder, aes(x = continent, y = lifeExp, fill = continent)) +
  geom_boxplot() +
  labs(title = "Esperanza de vida por continente") +
  theme_minimal()
p_ggplot

ggplotly(p_ggplot)

8.2 Con ggridges

Otra de las innovaciones recientes en Plotly es su soporte para librerías externas como ggridges, que permiten representar distribuciones superpuestas de manera compacta y visualmente atractiva.
En este tipo de gráficos, cada categoría se representa con una densidad, lo que facilita comparar cómo se distribuyen los valores sin necesidad de recurrir a múltiples paneles.

library(ggridges)

# Seleccionamos un subconjunto para evitar sobrecarga visual
data_ridges <- subset(gapminder, year %in% c(1982, 2007))

# Gráfico base con ggridges
p_ridges <- ggplot(data_ridges, aes(x = lifeExp, y = factor(year), fill = continent)) +
  geom_density_ridges(alpha = 0.8, scale = 1.5, color = "white") +
  labs(
    title = "Distribución de la esperanza de vida por año y continente",
    x = "Esperanza de vida",
    y = "Año"
  ) +
  theme_minimal()

p_ridges
## Picking joint bandwidth of 2.18

ggplotly(p_ridges)
## Picking joint bandwidth of 2.18

8.3 Con ggalluvial

Plotly también soporta la librería ggalluvial, que permite crear diagramas de flujo o diagramas aluviales. Estos gráficos son ideales para representar cómo cambian los elementos de un grupo a otro a lo largo del tiempo o de distintas etapas. Por ejemplo, se pueden visualizar transiciones de estudiantes entre carreras universitarias o cambios de clientes entre categorías de productos.

library(ggalluvial)

# Datos que simulan estudiantes que cambian de carrera
datos_aluvial <- data.frame(
  Año1 = c(rep("Ingeniería", 30), rep("Medicina", 25), rep("Derecho", 20)),
  Año2 = c(rep("Ingeniería", 25), rep("Medicina", 5), 
           rep("Medicina", 20), rep("Ingeniería", 5),
           rep("Derecho", 18), rep("Medicina", 2)),
  Frecuencia = 1
) %>%
  group_by(Año1, Año2) %>%
  summarise(Freq = sum(Frecuencia), .groups = "drop")

head(datos_aluvial)
# Diagrama aluvial
p_aluvial <- ggplot(datos_aluvial,
             aes(y = Freq, axis1 = Año1, axis2 = Año2)) +
  geom_alluvium(aes(fill = Año1), width = 1/12) +
  geom_stratum(width = 1/12, fill = "gray", color = "white") +
  geom_label(stat = "stratum", aes(label = after_stat(stratum))) +
  scale_x_discrete(limits = c("Año 1", "Año 2"), expand = c(.05, .05)) +
  labs(title = "Flujo de estudiantes entre carreras") +
  theme_minimal()
p_aluvial

ggplotly(p_aluvial)

8.4 Shinny

Plotly se ha consolidado como un aliado para la construcción de aplicaciones interactivas. En R, su integración con Shiny permite añadir controles dinámicos (filtros, menús, sliders) que modifican los gráficos en tiempo real, sin necesidad de conocimientos avanzados de desarrollo web.

library(shiny)
library(dplyr)

# Datos
datos <- gapminder
datos$continent <- as.character(datos$continent)  

ui <- dashboardPage(
  dashboardHeader(title = "Dashboard Gapminder"),
  dashboardSidebar(
    sidebarMenu(
      menuItem("Visualizaciones", tabName = "viz", icon = icon("chart-bar")),
      
      
      sliderInput("year_sel", "Selecciona el año:",
                  min = min(datos$year), max = max(datos$year),
                  value = 2007, step = 5, sep = ""),
      
     
      selectInput("cont_sel", "Selecciona continente:",
                  choices = c("Todos", unique(datos$continent)),
                  selected = "Todos")
    )
  ),
  dashboardBody(
    tabItems(
      tabItem(tabName = "viz",
              fluidRow(
                box(width = 12, plotlyOutput("bubble"))
              ),
              fluidRow(
                box(width = 6, plotlyOutput("top10")),
                box(width = 6, plotlyOutput("boxplot"))
              ),
              fluidRow(
                box(width = 12, plotlyOutput("line"))
              )
      )
    )
  )
)

server <- function(input, output, session) {
  
  # Datos filtrados por año y continente
  datos_filtrados <- reactive({
    if (input$cont_sel == "Todos") {
      filter(datos, year == input$year_sel)
    } else {
      filter(datos, year == input$year_sel, continent == input$cont_sel)
    }
  })
  
  # Gráfico de burbujas
  output$bubble <- renderPlotly({
    plot_ly(datos_filtrados(), x = ~gdpPercap, y = ~lifeExp,
            size = ~pop, color = ~continent, text = ~country,
            type = "scatter", mode = "markers",
            sizes = c(10, 70),
            marker = list(opacity = 0.7, line = list(width = 1))) %>%
      layout(title = paste("Esperanza de vida vs PIB per cápita -", input$year_sel),
             xaxis = list(title = "PIB per cápita"),
             yaxis = list(title = "Esperanza de vida"),
             legend = list(title = list(text = "Continente")))
  })
  
  # Top 10 países más poblados
  output$top10 <- renderPlotly({
    datos_top <- datos_filtrados() %>%
      arrange(desc(pop)) %>%
      slice_head(n = 10)
    
    plot_ly(datos_top, x = ~reorder(country, pop), y = ~pop,
            type = "bar", marker = list(color = "coral")) %>%
      layout(title = paste("Top 10 países más poblados -", input$year_sel,
                           ifelse(input$cont_sel == "Todos", "Global", input$cont_sel)),
             xaxis = list(title = "País", tickangle = -45),
             yaxis = list(title = "Población"))
  })
  
  # Boxplot
  output$boxplot <- renderPlotly({
    plot_ly(datos_filtrados(), x = ~continent, y = ~lifeExp,
            color = ~continent, type = "box") %>%
      layout(title = paste("Esperanza de vida por continente -", input$year_sel),
             xaxis = list(title = "Continente"),
             yaxis = list(title = "Esperanza de vida"))
  })
  
  # Línea temporal
  output$line <- renderPlotly({
    datos_linea <- if (input$cont_sel == "Todos") {
      datos %>% group_by(year) %>% summarise(promedio_vida = mean(lifeExp))
    } else {
      datos %>% filter(continent == input$cont_sel) %>%
        group_by(year) %>% summarise(promedio_vida = mean(lifeExp))
    }
    
    plot_ly(datos_linea, x = ~year, y = ~promedio_vida,
            type = "scatter", mode = "lines+markers",
            line = list(color = "steelblue", width = 3)) %>%
      layout(title = paste("Tendencia de la esperanza de vida -",
                           ifelse(input$cont_sel == "Todos", "Global", input$cont_sel)),
             xaxis = list(title = "Año"),
             yaxis = list(title = "Esperanza de vida promedio"))
  })
}

shinyApp(ui, server)

Link de la publicación en Shiny: https://g-geral.shinyapps.io/Plotly_con_Shiny/