Colores y paletas de colores en R

El uso del color es clave para comunicar, y el ecosistema de R tiene varios trucos convenientes para ayudarnos a usar el color de mejores formas.

En R, los colores se escriben como código, y a grandes rasgos pueden ser colores con nombre (por ejemplo, "purple"), colores hexadecimales (escritos como códigos de al menos 6 dígitos, como #FFFFFF), o como parte de funciones que producen paletas de colores.

Usar colores

La forma más básica de elegir un color en R es por su nombre. Por defecto, en R existen 657 colores con nombre.

Aquí puedes ver una lista de los principales colores de R y copiar sus nombres para usarlos:

white lightpink1 lightpink2 lightpink pink1 pink2 lightpink3 pink3 pink maroon palevioletred1 palevioletred2 palevioletred palevioletred3 lavenderblush lavenderblush2 lavenderblush3 deeppink deeppink2 violetred1 violetred2 deeppink3 hotpink violetred3 hotpink1 hotpink2 hotpink3 maroon1 maroon2 violetred mediumvioletred maroon3 magenta magenta2 magenta3 orchid1 darkmagenta orchid2 violet orchid orchid3 plum1 plum2 plum plum3 thistle1 thistle2 thistle thistle3 mediumorchid1 mediumorchid2 mediumorchid mediumorchid3 darkorchid1 purple darkorchid2 darkviolet darkorchid3 darkorchid purple1 purple2 blueviolet purple3 mediumpurple1 mediumpurple2 mediumpurple mediumpurple3 slateblue1 lightslateblue slateblue2 mediumslateblue slateblue3 slateblue darkslateblue blue blue2 blue3 navy midnightblue lavender ghostwhite royalblue1 royalblue2 royalblue royalblue3 cornflowerblue dodgerblue dodgerblue2 dodgerblue3 steelblue1 steelblue2 steelblue3 steelblue lightsteelblue1 lightsteelblue2 lightsteelblue lightsteelblue3 aliceblue deepskyblue deepskyblue2 deepskyblue3 skyblue1 lightskyblue skyblue2 skyblue3 skyblue lightskyblue1 lightskyblue2 lightskyblue3 lightblue1 lightblue2 lightblue lightblue3 cadetblue1 cadetblue2 cadetblue3 powderblue cyan turquoise1 cyan2 turquoise2 cyan3 darkturquoise turquoise3 mediumturquoise lightseagreen paleturquoise1 paleturquoise paleturquoise2 cadetblue paleturquoise3 lightcyan lightcyan2 lightcyan3 azure azure2 azure3 turquoise mediumspringgreen aquamarine aquamarine2 aquamarine3 springgreen springgreen2 springgreen3 seagreen1 seagreen2 seagreen3 mediumseagreen seagreen mintcream green green2 green3 limegreen forestgreen palegreen1 palegreen darkgreen lightgreen palegreen3 darkseagreen1 darkseagreen2 darkseagreen3 darkseagreen honeydew honeydew2 honeydew3 chartreuse lawngreen chartreuse2 chartreuse3 greenyellow darkolivegreen1 darkolivegreen2 darkolivegreen3 darkolivegreen olivedrab1 olivedrab2 olivedrab3 olivedrab yellow yellow2 yellow3 lightgoldenrodyellow lightyellow lightyellow2 beige lightyellow3 ivory ivory2 ivory3 darkkhaki khaki1 khaki2 khaki3 palegoldenrod khaki lemonchiffon lemonchiffon2 lemonchiffon3 gold gold2 gold3 lightgoldenrod lightgoldenrod1 lightgoldenrod2 lightgoldenrod3 cornsilk2 cornsilk3 cornsilk darkgoldenrod1 goldenrod1 darkgoldenrod2 goldenrod2 goldenrod darkgoldenrod3 goldenrod3 darkgoldenrod floralwhite orange orange2 orange3 wheat1 wheat wheat2 wheat3 oldlace moccasin papayawhip navajowhite navajowhite2 navajowhite3 blanchedalmond burlywood1 burlywood2 burlywood burlywood3 tan antiquewhite antiquewhite2 darkorange bisque bisque2 antiquewhite1 antiquewhite3 bisque3 darkorange1 darkorange2 darkorange3 peru linen tan1 tan2 sandybrown peachpuff peachpuff2 peachpuff3 seashell2 seashell3 chocolate1 chocolate2 chocolate chocolate3 seashell sienna1 sienna2 sienna3 sienna lightsalmon lightsalmon2 lightsalmon3 orangered orangered2 orangered3 coral darksalmon salmon1 salmon2 salmon3 coral1 coral2 coral3 tomato tomato2 tomato3 salmon mistyrose mistyrose2 mistyrose3 red red2 firebrick1 red3 firebrick2 brown1 brown2 firebrick3 brown3 firebrick darkred indianred1 indianred2 brown indianred3 indianred lightcoral rosybrown1 rosybrown2 rosybrown3 rosybrown snow snow2 snow3 gainsboro grey black

Ver un gráfico con todos los colores de R

#| output: asis
# toma todos los colores con nombres desde `colors()` y los ordena por tono, intensidad y brillo, y genera html con todos los colores en pildoritas

colores <- colors(distinct = T) |> 
  stringr::str_subset("gray", negate = T) |> 
  stringr::str_subset("4", negate = T)

library(dplyr)

tabla_colores <- tibble(color = colores) |> 
  mutate(hex = gplots::col2hex(color)) |> 
  mutate(tono = shades::hue(color)) |> 
  mutate(brillo = shades::lightness(color)) |> 
  mutate(croma = shades::chroma(color)) |> 
  # mutate(contraste = colorspace::contrast_ratio(color, "black")) |> 
  mutate(across(where(is.numeric), ~round(.x, 0) |> signif(2))) |> 
  arrange(desc(tono), desc(croma), desc(brillo)) |>
  filter(!color %in% c("black", "white"))

colores <- tabla_colores$color

colores <- c("white", colores, "grey", "black")

estilo <- "color: black; border-radius: 4px; padding: 1px 4px; margin: 2px; line-height: 1.9;"

cuadritos <- purrr::map(
  colores,
  \(color) {
    shiny::span(
      color, 
      style = paste("background-color:", gplots::col2hex(color), ";",
                    estilo,
                    paste("color:", 
                          ifelse(
                            colorspace::contrast_ratio(color, "black") < 4, 
                            "white", "black"),
                          ";"),
                    paste("border: solid 1px", colorspace::darken(color, 0.3), ";")
      )
    )
  })

shiny::tagList(cuadritos)

Para usar colores en R, simplemente usa su nombre en las funciones donde se puedan usar colores:

colores <- c("indianred", "steelblue", "grey60")

Casi todos estos colores pueden ser modificados agregando un número del 1 al 4 al final del nombre; por ejemplo, el color mediumorchid puede hacerse levemente más claro o más oscuro:

escala <- c("mediumorchid", "mediumorchid1", "mediumorchid2", "mediumorchid3", "mediumorchid4")

Los grises (gray) tienen la particularidad de que puedes ponerles un número entre 1 y 99 para ajustar su brillo:

escala <- c("gray2", "gray10", "gray30", "gray50", "gray70", "gray90")

Si tienes colores hexadecimales, que puedes encontrar en internet en muchas páginas, como coolors.co, recuerda ponerlos entre comillas y anteponer el signo gato:

colores <- c("#DEC5F2", "#9069C0", "#6E3A98")

paleta <- function(colores) {
  
  # colores <- colors(distinct = T) |> 
  #   stringr::str_subset("gray", negate = T)
  
  tamaño <- "width: 90px; height: 90px; font-size: 12px;"
  forma <- "border-radius: 50%; margin: 8px; display: inline-flex; word-break: break-all;"
  centrar <- "align-items: center; justify-content: center; text-align: center;"
  
  estilo <- paste(tamaño, forma, centrar)
  
  cuadritos <- purrr::map(
    colores,
    \(color) {
      shiny::div(
        color, 
        style = paste(
          paste("background-color:", gplots::col2hex(color), ";"),
          estilo,
          paste("color:", 
                ifelse(
                  colorspace::contrast_ratio(color, "black") < 4, 
                  "white", "black"), ";",
                paste("border: solid 1px", colorspace::darken(color, 0.2), ";")
          )
        ),
      )
    })
  
  
  output <- shiny::div(style = centrar,
                       shiny::tagList(cuadritos)
  ) 
  
  return(output)
}

# usar
paleta(c("#DEC5F2", "#9069C0", "#6E3A98"))

Paletas de colores

Varios paquetes de R contienen sus propias paletas de colores prediseñadas. Veremos algunas.

Uno de los conjuntos de paletas principales en visualización de datos, sobre todo para mapas, son las de Color Brewer, a las que puedes acceder con el paquete {RColorBrewer}.

Éstas son algunas de las paletas de Color Brewer:

library(RColorBrewer)

colores <- brewer.pal(name = "PuRd", n = 5)

colores <- brewer.pal(name = "BuPu", n = 5)

colores <- brewer.pal(name = "Purples", n = 5)

colores <- brewer.pal(name = "Blues", n = 5)

colores <- brewer.pal(name = "Set2", n = 5)

colores <- brewer.pal(name = "Pastel1", n = 5)

colores <- brewer.pal(name = "PRGn", n = 5)

colores <- brewer.pal(name = "RdYlBu", n = 5)

Puedes verlas todas ejecutando RColorBrewer::display.brewer.all()!

Ver todas las paletas de Color Brewer

RColorBrewer::display.brewer.all()

Cuando elijas una de las paletas, puedes usarla en cualquier gráfico de {ggplot2} con la función scale_color_brewer() o scale_fill_brewer(), según corresponda a la variable que quieres pintar, y elije la paleta por medio de su nombre:

library(ggplot2)

iris |> 
  ggplot() +
  aes(x = Sepal.Length, y = Sepal.Width, color = Species) +
  geom_point(size = 3, alpha = 0.8) +
  # usar la paleta "PuRd"
  scale_color_brewer(palette = "Set2")

Con el paquete {colorspace} también podemos ver otras paletas disponibles:

library(colorspace)

Aquí van algunas de ellas:

colores <- colorspace::sequential_hcl(5, palette = "Red-Blue")

colores <- colorspace::sequential_hcl(5, palette = "Purple-Orange")

colores <- colorspace::sequential_hcl(5, palette = "Heat 2")

colores <- colorspace::sequential_hcl(5, palette = "BurgYl")

colores <- colorspace::sequential_hcl(5, palette = "Mint")

colores <- colorspace::sequential_hcl(5, palette = "PinkYl")

colores <- colorspace::sequential_hcl(5, palette = "Sunset")

Puedes ver todas las paletas de colores de {colorspace} ejecutando colorspace::hcl_palettes(plot = TRUE).

Ver todas las paletas de colores de {colorspace}

colorspace::hcl_palettes(plot = TRUE)

Usar estas paletas en {ggplot2} es tan fácil como agregar la función de escala apropiada para definir los colores del gráfico:

iris |> 
  ggplot() +
  aes(Petal.Width, Sepal.Width, color = Sepal.Length) +
  geom_point(size = 3, alpha = 0.7) +
  # usar la paleta "Sunset" para una variable continua
  colorspace::scale_color_continuous_sequential(palette = "Sunset") +
  scale_y_continuous(expand = expansion(c(0, 0.1)))

Encuentra una lista que compila todas las paletas de colores de la comunidad de R en este repositorio.

Usar paletas de colores en gráficos

Gráficos con colores manuales

La forma más simple de usar colores en gráficos de {ggplot2} es definiéndolos en la escala de color apropiada.

Publicaciones relacionadas

Tutorial: visualización de datos con {ggplot2}

{ggplot2} es una librería de visualización de datos bastante popular en el mundo de la ciencia de datos. Sus principales características son su atractivo, su conveniencia para la exploración de datos,…

Para una variable discreta o categórica, los colores se aplican en la capa scale_color_manual() y se aplican en el orden de la variable:

library(ggplot2)

iris |> 
  ggplot() +
  aes(Sepal.Width, Sepal.Length, 
      color = Species) +
  geom_point(size = 2, alpha = .8) +
  scale_color_manual(
    values = c("#cc3b7b", "#705ce6", "#668cf6")
  )

O bien, se puede aplicar cada color a cada valor específico de la variable:

iris |> 
  ggplot() +
  aes(Sepal.Width, Sepal.Length, 
      color = Species) +
  geom_point(size = 2, alpha = .8) +
  # especificar un color para cada valor de la variable
  scale_color_manual(
    values = c("versicolor" = "#cc3b7b", 
               "virginica" = "#705ce6", 
               "setosa" = "#668cf6")
  )

Paletas de colores predefinidos

Muchos paquetes de R incorporan funciones de escalas de colores (scale_color_x(), scale_fill_x()) para aplicar una paleta de color fácilmente a un gráfico creado {ggplot2}.

Por ejemplo, las paletas de {colorspace} que vimos más arriba:

library(ggplot2)

# escalas para variables discretas
iris |> 
  ggplot() +
  aes(Petal.Width, fill = Species) +
  geom_bar() +
  colorspace::scale_fill_discrete_qualitative(palette = "Dark 3") +
  scale_y_continuous(expand = expansion(c(0, 0.1)))

# escalas para variables continuas
iris |> 
  ggplot() +
  aes(Sepal.Width, Sepal.Length, color = Petal.Width, size = Petal.Length) +
  geom_point(alpha = .8) +
  colorspace::scale_color_continuous_sequential(palette = "Sunset", na.value = "white") +
  scale_size_continuous(range = c(1, 3)) +
  guides(color = guide_colorsteps())

# escalas para variables continuas
iris |> 
  ggplot() +
  aes(Petal.Length, Sepal.Width, color = Petal.Width, size = Sepal.Length) +
  geom_point(alpha = .8) +
  viridis::scale_colour_viridis("viridis", na.value = "white") +
  scale_size_continuous(range = c(1, 3)) +
  guides(color = guide_colorsteps())

O bien, las paletas de {RColorBrewer} que vimos antes:

library(ggplot2)

iris |> 
  ggplot() +
  aes(x = Sepal.Length, y = Sepal.Width, color = Species) +
  geom_point(size = 3, alpha = 0.9) +
  # usar la paleta "Set2" de Color Brewer
  scale_color_brewer(palette = "Accent")

Algunas de las funciones para aplicar paletas de colores tienen funcionalidades extras. Por ejemplo, las funciones de {colorspace} permiten modificar sus paletas en términos de la saturación (chroma) y el brillo del color (luminance), entregándote más libertad al momento de definir una apariencia específica:

grafico <- iris |> 
  ggplot() +
  geom_point(aes(Sepal.Width, Sepal.Length, color = Petal.Width), size = 3, alpha = .8) +
  guides(color = guide_colorsteps())

grafico +
  colorspace::scale_color_continuous_sequential(
    palette = "TealGrn", 
    c1 = 50, # intensidad del color
    l1 = 40) # brillo del color

grafico +
  colorspace::scale_color_continuous_sequential(
    palette = "TealGrn", 
    c1 = 10, # intensidad del color
    l1 = 30) # brillo del color

Crear paletas de colores

También podemos usar funciones de R para crear paletas de colores personalizadas a partir de uno o varios colores, o especificando los rangos de variación de los colores.

Crear paletas secuenciales

Las paletas secuenciales consiste en un degradado entre dos o más colores. Suelen usarse para representar una variable continua o numérica, cuyo valor va cambiando de forma cuantitativa.

La función sequential_hcl() del paquete {colorspace} permite crear paletas secuenciales que, por defecto, se van degradando hacia blanco. El primer argumento es la cantidad de colores que deseas, y luego h es el tono desde el que quieres empezar la paleta:

colores <- colorspace::sequential_hcl(6, h = 300)

Ahora, una paleta de 6 colores, que empiece en el tono 300 y termine por el tono 100, a la vez que va aclarándose:

colores <- colorspace::sequential_hcl(8, h = c(300, 100))

Puedes explorar los argumentos para personalizar la paleta. Por ejemplo: 6 colores por el tono 200 definido en h, cambiando la intensidad del color en el argumento c, y pasando de una luminancia de 25 a una de 85

colores <- colorspace::sequential_hcl(5, 
                                      h = 200,
                                      c = c(45, 25), 
                                      l = c(25, 80)
)

También se pueden obtener vectores de colores a partir de las paletas existentes que vienen con el paquete {colorspace}:

colores <- colorspace::sequential_hcl(5, palette = "Red-Blue")

colores <- colorspace::sequential_hcl(5, palette = "Purple-Orange")

Crear paletas cualitativas

Como su nombre ética, en las paletas cualitativas los colores van saltando para maximizar la diferencia entre ellos. Se utilizan para variables cualitativas, categóricas o discretas, donde cada elemento de una secuencia es independiente de los demás, y el objetivo del uso del color es poder distinguirlos.

La función rainbow_hcl() de {colorspace} entrega una típica paleta de arcoíris, pero con la posibilidad de modificar sus atributos de color en sus argumentos, tales como las tonalidades (hue) de inicio o final, la intensidad (chroma) de los tonos, y más.

Por ejemplo, una paleta de arcoíris de 6 colores con intensidad de color de 70:

colores <- colorspace::rainbow_hcl(6, c = 70)

Un arcoíris de 7 colores de croma 100, que empiece en la tonalidad 190 y termine en la 380:

colores <- colorspace::rainbow_hcl(6, 
                                   c = 100, 
                                   start = 190,
                                   end = 380)

Un arcoíris de 6 colores con intensidad de 60, luminancia de 30, que empiece en el tono 230 y termine en el 370:

colores <- colorspace::rainbow_hcl(6, 
                                   c = 60, 
                                   l = 30, 
                                   start = 230, 
                                   end = 370)

También pueden usarse los nombres de las paletas preexistentes para generar una secuencia cualitativa con ellos.

Por ejemplo, 6 colores de la paleta de colores fríos, con intensidad (chroma) de 80:

colores <- colorspace::qualitative_hcl(6, 
                                       palette = "Cold", 
                                       c = 80)

Seis colores de la paleta de colores cálidos, con intensidad (chroma) de 70:

colores <- colorspace::qualitative_hcl(6, 
                                       palette = "Warm", 
                                       c = 70)

Crear paletas divergentes

Las paletas divergentes se utilizan cuando una variable expresa dos polos; una una misma magnitud donde los extremos son separados por una brecha central.

colores <- colorspace::diverging_hcl(n = 5, 
                                     h = c(35, 200),
                                     l = c(50, 90))

colores <- colorspace::diverging_hcl(n = 6, h = c(320, 180))

colores <- colorspace::diverging_hcl(n = 6, 
                                     h = c(360, 180), 
                                     c = 30,
                                     l = 60)

Como podemos ver, todas las paletas divergentes pasan por un tono blanco en el intermedio.

Extender paletas de colores

Si tienes un vector de colores y necesitas alargarlo para tener más colores basados en la paleta original, puedes hacerlo con la función colorRampPalette(). Esta función crea otra función a partir de los colores, a la que luego le das el número de colores que necesites obtener a partir de la paleta original:

# paleta de 5 colores
colores <- c("#f4b43f", "#ec6a2d", "#cc3b7b", "#705ce6", "#668cf6")

# extender la paleta de 5 colores a 12 colores
colores <- colorRampPalette(colores)(12)

También podemos usar esta función para crear con facilidad una paleta secuencial entre dos o más colores:

colores <- c("#df65b2", "#fae55f")

# extender la paleta a 8 colores
colores <- colorRampPalette(colores)(16)

Usando las paletas de colores creadas

Una vez que pensaste una paleta de colores, puedes usarla en cualquier gráfico de {ggplot2} usando scale_color_manual() o scale_fill_manual(), según corresponda, teniendo en consideración que tienes que crear la cantidad de colores que necesites según tus datos.

En este ejemplo, usamos la paleta de colores fríos para un gráfico de dispersión de la base de datos msleep que viene con {ggplot2}:

library(ggplot2)
library(dplyr)

# preparar datos de prueba
datos <- msleep |> 
  filter_out(is.na(vore))

# ver cuántos valores únicos tiene la variable
n_casos <- n_distinct(datos$vore)

# crear una paleta con esa cantidad de colores
colores <- colorspace::qualitative_hcl(n_casos, 
                                       palette = "Cold", 
                                       c = 80)

# visualizar
datos |> 
  ggplot() +
  aes(x = vore, y = sleep_total, color = vore) +
  geom_jitter(size = 3, alpha = 0.7, width = 0.3) +
  scale_color_manual(values = colores)

Personalizar y crear colores

Modificar colores existentes

Las funciones del paquete {shades} nos permitan obtener información detallada sobre cada uno de los colores, y usar esta misma información para modificarlos con mucho detalle.

Por ejemplo, definamos un color, y luego obtengamos el valor de su tonalidad. Recordemos que la tonalidad de los colores se expresan como grados entre 0° y 360°.

color <- "#f65b74"

shades::hue(color)

[1] 350.3226

Obtenemos que, para el color definido, el valor de su tonalidad es 350.3226125. Podemos usar esta información para modificar levemente el mismo color y así obtener una variable del mismo color levemente más anaranjada.

color2 <- shades::hue(color, 370)

Podemos obtener mismos resultados utilizando el delta de la tonalidad del color; es decir, sumándole restándole una cantidad de grados a el valor de la tonalidad del color mismo:

color3 <- shades::hue(color, delta(50))

Al usar la función delta(), lo que hacemos es pedirle que cambie la tonalidad del color en 50°, volviéndose en un tono amarillo.

Podemos obtener un resultado similar usando col_shift() del paquete {scales}:

color2 <- scales::col_shift(color, 20)

El brillo (brightness) va de cero a uno, mientras que la claridad (lightness) va de cero a 100.

color <- color |> brightness(0.7)

color <- color |> lightness(delta(20))

Con {scales}, la función col_lighter() realiza el mismo propósito:

color <- col_lighter(color, 20)

Por su parte, la saturación aumenta la intensidad del color.

color <- color |> saturation(delta(30))

Podemos utilizar la función delta() para crear una sencilla paleta de colores a partir de un mismo color, aumentando y disminuyendo su intensidad (chroma):

colores <- c(color |> chroma(delta(30)), 
             color,
             color |> chroma(delta(-30)))

En {scales}, la función es col_saturate():

color <- col_saturate(color, -50)

Podemos combinar estas técnicas para crear una paleta de colores más compleja, construida toda a partir de un solo color al cual se le va aumentando o disminuyendo sus valores de claridad e intensidad. El beneficio de hacerlo de esta manera es que luego basta con cambiar el color principal para obtener una paleta de iguales características, pero basada en una tonalidad distinta.

color_principal = "#4D4484"

color_fondo = color_principal |> lightness(13) |> chroma(20)
color_detalle = color_principal |> lightness(20) |> chroma(40)
color_destacado = color_principal |> lightness(50) |> chroma(65)
color_texto = color_principal |> lightness(80)

colores <- c(color_principal,
             color_fondo,
             color_detalle,
             color_destacado,
             color_texto)

Ahora usamos el mismo código, pero cambiando el color de origen:

color_principal = "#3170ac"

color_fondo = color_principal |> lightness(13) |> chroma(20)
color_detalle = color_principal |> lightness(20) |> chroma(40)
color_destacado = color_principal |> lightness(50) |> chroma(65)
color_texto = color_principal |> lightness(80)

colores <- c(color_principal,
             color_fondo,
             color_detalle,
             color_destacado,
             color_texto)

Notar que el código es igual, y sólo se cambió el valor del color_principal. Esta estrategia es muy útil si se están produciendo visualizaciones o aplicaciones que ocupan una paleta de colores monocromática.

Mezclar colores

Las funciones submix() y addmix() del paquete {shades} facilitan el mezclado de colores sustraje ctivo y aditivo, respectivamente.

A partir de dos colores, entrega la mezcla de ellos, abriendo muchas posibilidades para la experimentación y creación de nuevos colores.

Los siguientes ejemplos muestran en el centro la mezcla que resulta de los otros dos colores:

colores <- c("#70f1d5",
             submix("#70f1d5", "#fae55f"),
             "#fae55f")

colores <- c("#3377f7",
             addmix("#3377f7", "#ec4e3c"),
             "#ec4e3c")

colores <- c("#f9ce45",
             submix("#f9ce45", "#77d671", amount = 0.5),
             "#77d671")

Aplicar una tonalidad a una paleta de colores

El paquete {scales} también provee una función para mezclar colores: col_mix(). Cualquiera de estas funciones, ya sea scales:col_mix() o shades::addmix() y shades::submix() pueden usarse para tomar una paleta de colores y volverla más coherente al aplicarle una pequeña fracción de otro color. Veamos primero la paleta:

Ahora agreguémosle un 20% de naranjo a todos sus colores:

colores <- col_mix(a = c("#77d671", "#70f1d5", "#fae55f", "#ff479c"),
                   b = "orange2", 
                   amount = 0.2)

Ahora vemos que la paleta mantiene la diferencia entre sus colores, pero ahora todos se perciben más coherentes al compartir una tonalidad común:

Crear colores

Puedes crear un color en R definiendo su tonalidad (hue), saturación (saturation) y brillo (value) con hsv(), entendiendo que el matiz es la posición del color en la escala de todos los colores, que va del 0 al 1, empezando y terminando con el rojo:

color <- hsv(h = 0, s = 1, v = 1)

Para guiarse, la siguiente gráfica muestra la tonalidad de colores entre 0 y 1,

library(purrr)
library(dplyr)
library(ggplot2)

secuencia <- seq(0.0, 1.0, 0.1)

colores <- map(secuencia,
~hsv(h = .x, s = 1, v = 1))

tabla <- tibble(secuencia,
colores = unlist(colores))

tabla |> 
ggplot() +
aes(x = secuencia, y = 1,
fill = colores) +
geom_tile(color = "#EAD1FA") +
scale_fill_identity() +
scale_x_continuous(breaks = secuencia) +
theme_void(
paper = "#EAD1FA",
accent = "#9069C0",
ink = "#553A74") +
theme(axis.text.x = element_text(margin = margin(t = 1, b = 6)))

Siguiendo el gráfico anterior, vemos que el tono 0.8 corresponde al color morado, así que podemos crearlo con hsv():

color <- hsv(0.85, 1, 1)

Luego podemos modificar la saturación y brillo del color con los otros dos argumentos de hsv():

color <- hsv(0.82, 0.5, 0.4)

Previsualizar colores

En R puedes usar la función swatch() del paquete {shades} para previsualizar cualquier color o vector de colores. Una alternativa es la función show_col() de {scales}, que hace lo mismo.

library(shades)
library(scales)

colores <- c("#DEC5F2", "#9069C0", "#6E3A98")

shades::swatch(colores)

scales::show_col(colores)

Así puedes experimentar visualizando de inmediato las mezclas de colores y paletas de colores que crees.

Publicaciones sobre visualización de datos

Crea mapas bivariados en R para visualizar la relación entre dos variables Palíndromos de Chile Mapas hexagonales o cuadriculados con R Mapas y visualización de datos geoespaciales en R con {sf} Gráficos de puntos comparativos o dumbbell en {ggplot2}

Avanzado

Analizar colores

Si tenemos un conjunto de colores, podemos analizar sus propiedades, como tono (hue), brillo, e intensidad del color (chroma).

colores <- colors()

library(dplyr)

# crear una tabla con el vector de colores
tabla <- tibble(color = colores)

Con las funciones hue(), lightness() y chroma() del paquete {shades} podemos calcular el tono, brillo e intensidad de cada color:

library(shades)

tabla <- tabla |> 
  mutate(tono = shades::hue(color)) |> 
  mutate(brillo = shades::lightness(color)) |> 
  mutate(croma = shades::chroma(color)) |> 
  # redondear los valores
  mutate(across(where(is.numeric), ~round(.x, 0))) |> 
  # ordenar los colores
  arrange(desc(tono), desc(croma), desc(brillo))

Así obtenemos una tabla con las características de los colores, con lo que podemos ordenarlos por tono, desde menos a más claros, o realizar otras operaciones.

tabla

# A tibble: 657 × 4
   color       tono brillo croma
   <chr>      <dbl>  <dbl> <dbl>
 1 lightpink1   352     79    32
 2 lightpink3   352     65    27
 3 lightpink4   352     45    19
 4 lightpink2   351     74    30
 5 lightpink    351     81    29
 6 pink         350     84    24
 7 pink1        347     81    29
 8 pink2        347     76    28
 9 pink3        347     66    25
10 pink4        347     46    18
# ℹ 647 more rows

También podemos visualizar esta información con la función specplot() de {colorspace}:

colores <- colorspace::sequential_hcl(5, h = 290, c = 70)

colorspace::specplot(colores)

En el gráfico anterior vemos que los colores de la paleta no cambian de tono (hue), pero sí aumentan en brillo (luminance) y bajan en intensidad (chroma). Usualmente se recomienda que las paletas tengan también un cambio de tono, lo que ayuda con la accesibilidad. Así que podemos hacer un cambio en la paleta para mejorarla un poco, indicando que queretmos que el tono (argumento h) cambie:

colores <- colorspace::sequential_hcl(5, h = c(290, 350), c = 70)

Analizar el contraste de colores

Para mejorar la visibilidad y accesibilidad de tus visualizaciones de datos, puedes calcular el valor de contraste que tienen tus colores en comparación con otro. Por ejemplo, medir el contraste que tendría un texto negro encima de los colores de tu paleta:

# paleta de morados de distinta intensidad
colores <- colorspace::sequential_hcl(5, h = 290, c = 70)

colorspace::contrast_ratio(colores, "black", plot = TRUE)

colorspace::contrast_ratio(colores, "white", plot = TRUE)

La función contrast_ratio() del paquete {colorspace} retorna números que representan el contraste, donde un valor menor significa menor contraste, y por lo tanto menor visibilidad del color en comparación con el color de referencia.

Esto mismo se puede hacer con páginas como WebAIM, pero la gracia de hacerlo con R es que podemos usar la información del contraste para tomar decisiones: por ejemplo, decidir automáticamente si un texto debe ser blanco o negro dependiendo del color que le corresponde:

library(dplyr)
library(ggplot2)
library(colorspace)

# paleta de morados de distinta intensidad
colores <- colorspace::sequential_hcl(5, h = 290, c = 70)

# poner colores en tabla
tabla <- tibble(colores = colores,
                secuencia = seq_along(colores)) |> 
  # calcular contraste de cada color respecto al color negro
  mutate(contraste = contrast_ratio(colores, "black"))

# gráfico simple para mostrar los colores
tabla |> 
  ggplot() +
  # gráfico de mosaicos
  aes(x = secuencia, y = 1,
      fill = colores) +
  geom_tile(color = "#EAD1FA") +
  # texto con nombre de colores
  geom_text(
    aes(label = colores),
    # definir color del texto según el contraste
    color = ifelse(tabla$contraste > 7, "black", "white")
    ) +
  # aplicar el color que viene en la columna usada para el `fill`
  scale_fill_identity() +
  theme_void(
    base_family = "Atkinson Hyperlegible",
    paper = "#EAD1FA",
    accent = "#9069C0",
    ink = "#553A74")

Ahora el color del texto se decide dependiendo del contraste del color de fondo!

Convertir colores a código hecadecimal

Si tenemos colores definidos como nombres, podemos convertirlos a su valor hexadecimal con la función col2hex() del paquete {gplots}:

color <- "mediumpurple"

gplots::col2hex(color)

[1] "#9370DB"

Visualizar paletas en espacios de color

{colorspace} incluye funciones para poder visualizar secuencias de colores en proyecciones del espacio de color HCL (hue, chroma, luminance), lo que nos permite contextualizar las paletas en un espacio perceptual del color basado en estos tres parámetros.

colores <- sequential_hcl(7, h = 280, c = 80, l = c(35, 95))

colorspace::hclplot(colores)

colores <- sequential_hcl(7, h = c(280, 220), c = c(50, 70, 20), l = c(30, 90), power = 1.1)

colorspace::hclplot(colores)

Publicaciones sobre gráficos

Gráficos de puntos comparativos o dumbbell en {ggplot2} Aplicación: Visualizador de densidad de población urbana en comunas de Chile App: Suicidios en Chile (2017-2024) desde una perspectiva de género Gráficos de puente en {ggplot2} Temas de colores personalizados para tus gráficos {ggplot2}

Fuentes y recursos

• R Color Palettes, lista de paletas discretas por Emil Hvitfeldt
• Dealing with colors in ggplot2
• Top R Color Palettes to Know for Great Data Visualization
• Paletas de colores usadas en el paquete {tidyplots}