Casi todo niño alguna vez en algún momento tuvo como regalo de cumpleaños, regalo de navidad, o regalo por haber sacado buenas notas, un set de LEGO bricks. No se tú, pero yo de niño podía pasar horas construyendo más allá de las instrucciones, fantásticos mundos, creaturas y casi todo lo que la creatividad pudiera susurrarme al oído.

Es por ello, que evocando a recuerdos de la infancia, y aportando un artículo más sobre cosas útiles o curiosas que aún no sabes que puedes hacer con R, quiero presentarte esta ocasión a “brickr”, un divertido y completo package que lleva la experiencia LEGO a R y al ecosistema “tidyverse”. Este package incluye herramientas que te ayudarán a crear los mosaicos e incluso la salida del modelo 3D con elementos reales de LEGO.

Este package es dividido en 2:

Mosaics: Para convertir imágenes en mosaicos que podrían ser construidos con LEGO bricks.

3D Models: Para construir modelos LEGO 3D a partir de tablas de datos usando “rgl”.

Instalación del package

Crea un nuevo script en R. Primeramente deberás instalar el package, de manera sencilla desde su repositorio, para cargar la librería posteriormente.

# INSTALL PACKAGEinstall.packages("brickr")# LOAD LIBRARIESlibrary(brickr)
library(dplyr)

Construyendo Mosaicos

Las funciones para crear mosaicos representan un archivo JPG o PNG importado usando colores y bricks LEGO. Por ejemplo, puedes tomar el logo de R para cargarla. La imagen original es la siguiente:

Algunas consideraciones:

• Los mosaicos son de baja resolución y solo existen 42 colores.
• Minimiza el ruido de fondo. Una buena técnica es eliminar el fondo de tu imagen.
• Puedes jugar con los argumentos “brightness” y “contrast” para ajustar el brillo y contraste, también puedes ajustar el tamaño y la paleta de colores, en la función “image_to_mosaic()”

# MOSAICS, LOAD ANY PHOTO OR IMAGEmyImage_R <- png::readPNG("R_logo.png")myImage_R %>% 
  image_to_mosaic(
    # DEFAULT SIZE IS "48x48" BRICKS
    50, 
    brightness = 1, 
    contrast = 1, 
    # SETTING BRICKS TO USE
    use_bricks = c("4x6", "2x4", "1x2", "1x1") 
  ) %>% 
  build_mosaic()ggplot2::ggsave("img/R_logo_mosaic.png", device="png")

El resultado es el siguiente, como podrás ver, incluso respetando el número de bricks y de qué tipo.

Por si esto no fuera sorprendente ya, además puedes crear el modelo 3D a partir de lo obtenido, añadiendo la función “bricks_from_mosaic()”. Por ejemplo:

# 3D FROM MOSAIC, LOAD ANY PHOTO OR IMAGEmyImage_R_3D <- png::readPNG("R_logo.png")myImage_R_3D %>% 
  image_to_mosaic() %>% 
  # CONVERT TO 3D BRICKS
  bricks_from_mosaic() %>% 
  build_bricks()

Con lo cual obtendrás el resultado 3D, que podrás apreciar con el visor que desplegará RStudio.

Obtén las instrucciones y las piezas para armar tu modelo real de LEGO

Si lo anterior aún te pareciera poco, ahora podrás obtener las instrucciones e incluso la lista de bricks para armar cualquier modelo que hayas generado.

Podrás usar la función “build_instructions()” para dividir los mosaicos y los modelos 3D en pasos más fáciles de leer, tal como lo encontrarías con cualquier juego de LEGO que adquirieras. Por defecto desplegará 6 pasos, pero pasar cualquier valor entero como argumento a la función generará esa cantidad de pasos.

También podrás usar la función “build_pieces()” para generar una imagen con las piezas requeridas. Las piezas estarán ordenadas por color y tamaño.

# GET INSTRUCTIONS AND PIECES TO BUILD MODEL, LOAD ANY PHOTO OR IMAGEmyImageInstructions_R <- png::readPNG("R_logo.png") %>% 
  image_to_mosaic()myImageInstructions_R %>% 
  build_mosaic()
# GENERATING INSTRUCTIONS
myImageInstructions_R %>% 
  build_instructions(9)
# GENERATING PIECES
myImageInstructions_R %>% 
  build_pieces()

Como resultado obtendrás primeramente un plot con las instrucciones, por ejemplo, para construir el logo de R:

Y después además, obtendrás el plot de las piezas que se sugiere necesitarás para construir el logo de R.

Construyendo Modelos 3D

Puedes crear modelos 3D de bricks LEGO a partir de una variedad de formatos de entrada. Las funciones “bricks_from_table()” y “bricks_from_excel()” convierten una tabla de números enteros en forma de matriz en bricks LEGO. Para modelos simples, esta tabla se puede hacer manualmente usando las funciones “data.frame()” o “tibble::tribble()”. Para modelos más avanzados, se recomienda utilizar MS Excel o un archivo CSV. Algunas consideraciones:

• Cada valor en un dataframe corresponde a un brick 1×1.
• “Level” le dice a bricker que tan alto colocar la pieza.
• Los valores “x” son las columnas después de “Level”.
• Los valores “y” son implícitos y corresponden con las filas del dataframe.
• Los valores numéricos pueden estar predeterminados entre 1 y 54, correspondiendo cada número a un color diferente.

Por ejemplo, digamos que quieres construir simplemente un brick, para ejemplificar lo anteriormente explicado:

# BUILD 3D BRICK FROM "bricks_from_table()" FUNCTIONdata.frame(
  Level = "A",
  x1 = 33 
) -> myBrickmyBrick %>% 
  # CONVERT INTO A BRICKR OBJECT
  bricks_from_table() %>% 
  build_bricks()

Obtendrás como salida en el visor RGL el modelo en 3D

Comprendiendo un poco más cómo es que funciona, puedes construir modelos mucho más complejos. Por ejemplo, digamos que quieres hacer una pequeña casa:

# BUILD HOUSE 3D BRICKS FROM "bricks_from_table()" FUNCTIONtibble::tribble(
  ~Level, ~x1, ~x2, ~x3, ~x4, ~x5,
  "A",   13,   13,   13,   13,   13,
  "A",   3,   0,   0,   0,   3,
  "A",   3,   0,   0,   0,   3,
  "A",   3,   3,   0,   3,   3,
  #---
  "B",   13,   13,   13,   13,   13,
  "B",   3,   0,   0,   0,   3,
  "B",   3,   0,   0,   0,   3,
  "B",   13,   13,   13,   13,   13,
  #---
  "C",   18,   18,   18,   18,   18,
  "C",   13,   13,   13,   13,   13,
  "C",   13,   13,   13,   13,   13,
  "C",   18,   18,   18,   18,   18,
  #---
  "D",   0,   0,   0,   0,   0,
  "D",   18,   18,   18,   18,   18,
  "D",   18,   18,   18,   18,   18,
  "D",   0,   0,   0,   0,   0
) -> myHousemyHouse %>% 
  bricks_from_table() %>% 
  build_bricks()

Obtendrás como resultado algo como lo siguiente en el visor RGL:

Programando Modelos 3D

También contamos con la función “bricks_from_coords()”, que toma un dataframe con valores enteros “x”, “y” y “z” y columnas “Color”, donde cada combinación de “x”, “y” y “z” es un punto en un espacio tridimensional. El color debe ser un nombre de color oficial de LEGO de build_colors(). Este formato para muchos es más flexible que la función “bricks_from_table()” y permite el desarrollo programático de modelos 3D. Algunas consideraciones:

• x: Ubicación de los bricks de izquierda a derecha, valores > 0
• y: Ubicación de los bricks de adelante hacia atrás, valores > 0
• z: Ubicación de los bricks de abajo hacia arriba, valores > 0
• color: Nombre del color a usar.
• Usa “tidyr::crossing()” para crear una fila para cada combinación de datos de entrada
• La opción “outline_bricks = TRUE” agrega un contorno negro alrededor de los bordes de los bricks.
• Establecer “rgl_lit = FALSE” desactiva los efectos de iluminación automatizados de rgl.

Por ejemplo, digamos que quieres crear un solo brick, para comprender cómo funciona lo anteriormente señalado, antes de crear algo más complejo:

# BUILD 3D BRICK FROM "bricks_from_coords()" FUNCTIONtibble::tibble(
  x = 1, y = 1, z = 1, color = "Bright orange"
) %>% 
  bricks_from_coords() %>% 
  build_bricks()

VIsualizarás entonces a continuación el brick

Una vez comprendido de manera un poco más clara cómo funciona la función “bricks_from_coords()”, ahora podrías digamos, programar la construcción de un modelo cuyas piezas emulen a un “pato Donald”:

# BUILD 3D DONALD FROM "bricks_from_coords()" FUNCTION# X AND Y NOT INCLUDED SINCE THEY ARE CONSTANT
# "b" IS BRICK & "p" IS PLATE (1-unit)
# "mid_level" HAS 3 UNITS: 0, 1, 2tibble::tribble(
  ~z, ~mid_level,  ~piece_type, ~color,
  # ORANGE FEET
  1, 0, "b", "Bright orange", 
  # WHITE LEGS
  2, 0, "b", "White", 
  # BLUE SHIRT
  3, 0, "b", "Bright blue", 
  # ADD 2 PLATES HEIGHT
  4, 0, "p", "Bright blue", 
  4, 1, "p", "Bright blue",
  # BEAK
  4, 2, "p", "Bright orange", 
  # HEAD
  5, 0, "b", "White",
  6, 0, "p", "White",
  #CAP BRIM
  6, 1, "p", "Black", 
  # CAP
  6, 2, "p", "Bright blue" 
) -> donaldBricks# "tidyr::expand()" ADD X AND Y, WHILE DUPLICATING EACHdonaldBricks %>% 
  tidyr::expand(x=1:2, y=1:2,tidyr::nesting(z, mid_level, piece_type, color)
  ) -> myDonaldmyDonald %>% 
  bricks_from_coords() %>% 
  build_bricks(
    background_color = "#d8fdff" 
  )

Ahora tendrás como resultado en el visor RGL una figura 3D como la siguiente:

Como verás, con un poco más de práctica podrías entretenerte muchísimo tiempo con tus propias creaciones. Uno de los principales objetivos del package es generar interés en R y programación a nuevas audiencias, con modelos 3D fáciles de crear. Si actualmente al igual que yo, te dedicas a temas de educación e instrucción, encontrarás muy útil este recurso además de entretenido y divertido.

Me despido compartiendo un bonito mosaico generado de los avatares de mi novia y yo, me gustó, estaré imprimiendo las instrucciones para que armemos juntos el mosaico jeje (una buena idea como para regalo de San Valentín).

Muchas gracias por tu amable lectura. Como con la mayoría de mis artículos, comparto, aquí puedes encontrar el código completo: https://github.com/cosmoduende/r-lego

Te agradezco por llegar hasta el final. ¡Que tengas muy felices análisis, que puedas poner en práctica todo, y te sorprendas y diviertas tanto como yo con los resultados!