geom_brick_col() draws data columns as bricks.
vignettes/models-from-other.Rmd
+ models-from-other.RmdThe bricks_from_* series of functions creates 3D models of LEGO bricks from a variety of input formats. These models are rendered using Tyler Morgan-Wall’s rayshader package. This package must be installed.
Begin with a brickr mosaic from an image. Rather than graphically rendering the mosaic using build_mosaic(), use bricks_from_mosaic(). This function takes two other inputs:
mosaic_height is the number of bricks stacked at the mosaic’s highest point. The default is 6.highest_el specifies if ‘light’ or ‘dark’ color bricks should be the tallest in the model. The default is ‘light’.mosaic <- png::readPNG("../Images/mf_unicorn.PNG") %>%
+ image_to_mosaic()
+
+mosaic %>% build_mosaic()
+mosaic %>%
+ bricks_from_mosaic(highest_el = "dark") %>%
+ build_bricks(phi = 60, theta = 15)
+
+rayshader::render_snapshot(clear = TRUE)
rayshader by Tyler Morgan-Wall is an open source package for producing 2D and 3D data visualizations in R. rayshader uses elevation data in a base R matrix and a combination of raytracing, spherical texture mapping, overlays, and ambient occlusion to generate beautiful topographic 2D and 3D maps. (Note: text lifted straight from rayshader.com.)
+3D models in brickr are rendered using the functions in rayshader. Using bricks_from_rayshader(), you can convert rayshader map output into a brickr model. This function takes three inputs:
hillshade is topographic image matrix with an RGB channel (much like the mosaics).heightmap is a two-dimensional matrix specifiying the height of the image at each location.max_height is the number of bricks stacked at the mosaic’s highest point. The default is 12.img_size is the number of bricks on each side of the model. The default is 48.library(rayshader)
+
+#Example from rayshader.com
+
+#Here, I load a map with the raster package.
+loadzip = tempfile()
+download.file("https://tylermw.com/data/dem_01.tif.zip", loadzip)
+localtif = raster::raster(unzip(loadzip, "dem_01.tif"))
+unlink(loadzip)
+
+#And convert it to a matrix:
+elmat = matrix(raster::extract(localtif, raster::extent(localtif), buffer = 1000),
+ nrow = ncol(localtif), ncol = nrow(localtif))
+
+rayshader_object <- elmat %>%
+ sphere_shade(texture = "desert") %>%
+ add_water(detect_water(elmat), color = "desert") %>%
+ add_shadow(ray_shade(elmat, zscale = 3, maxsearch = 300), 0.5)
+
+#Plot with rayshader
+rayshader_object %>%
+ plot_3d(elmat, zscale = 10, fov = 0, theta = 135, zoom = 0.75, phi = 45, windowsize = c(1000, 800))
+
+rayshader::render_snapshot(clear = TRUE)
+#Plot as bricks
+rayshader_object %>%
+ bricks_from_rayshader(elmat) %>%
+ build_bricks(theta = 135, zoom = 0.75, phi = 45)
+
+rayshader::render_snapshot(clear = TRUE)
vignettes/models-from-program.Rmd
+ models-from-program.RmdThe bricks_from_* series of functions creates 3D models of LEGO bricks from a variety of input formats. These models are rendered using Tyler Morgan-Wall’s rayshader package. This package must be installed.
Use bricks_from_coords() to programmatically build 3D LEGO models rather than manually drawing them in a spreadsheet or table. Prove the function with a data frame with x, y, and z coordinates, along with an official LEGO color name for each point.
Below, we create a 8x8x8 cube by expanding a data frame with the array 1:8 as the x-, y-, and z-coordinates. We then assign each row of that data frame one of three colors: Bright blue, Bright yellow, or Bright red.
+use_colors <- c("Bright blue", "Bright yellow", "Bright red")
+
+cube <- expand.grid(
+ x = 1:8,
+ y = 1:8,
+ z = 1:8
+)
+
+cube$Color <- sample(use_colors, nrow(cube), replace = TRUE, prob = c(5, 3, 1))
+
+cube %>%
+ bricks_from_coords() %>%
+ build_bricks(brick_res = "hd", phi = 30, theta = 30)
+
+rayshader::render_snapshot(clear = TRUE)
Using the same logic, we can build a sphere with a specified radius, and then apply rules to color each brick based on its coordinates.
+radius <- 4
+sphere_coords <- expand.grid(
+ x = 1:round((radius*2.5)),
+ y = 1:round((radius*2.5)),
+ z = 1:round((radius/(6/5)*2.5)) #A brick is 6/5 taller than it is wide/deep
+) %>%
+ dplyr::mutate(
+ #Distance of each coordinate from center
+ dist = (((x-mean(x))^2 + (y-mean(y))^2 + (z-mean(z))^2)^(1/2)),
+ Color = dplyr::case_when(
+ #Yellow stripes on the surface with a 2to4 thickness
+ dplyr::between(dist, (radius-1), radius) & (x+y+z) %% 6 %in% 0:1 ~ "Bright yellow",
+ #Otherwise, sphere is blue
+ dist <= radius ~ "Bright blue"
+ ))
+
+sphere_coords %>%
+ bricks_from_coords() %>%
+ build_bricks(brick_res = "hd", phi = 30, theta = 30)
+
+rayshader::render_snapshot(clear = TRUE)
Rather than directly writing a data frame for a model, you can write a function that returns a data frame with x, y, z, and Color coordinates given initial starting parameters.
+Below, the function brick_house() creates a LEGO house with randomized colors. The x- and y-coordinates and the size of the house are inputs to the functions.
brick_house <- function(x_coord = 0, y_coord = 0, width=6, length=5, height=6){
+ roof_colors <- c("Dark orange", "Dark brown", "Medium nougat", "Medium stone grey")
+ roof_col <- sample(roof_colors, 1)
+
+ house_colors <- c("Bright blue", "Bright red", "Dark red", "Dark azur", "Nougat", "Bright reddish violet")
+ house_col <- sample(house_colors, 1)
+
+ house_coords <- expand.grid(
+ x = 1:width, y = 1:length, z = (1:height)+1
+ ) %>%
+ dplyr::mutate(
+ roof = (z > round((1/2)*height)),
+ Color = dplyr::case_when(
+ #Roof
+ roof & (abs(y - floor(length/2) -1) <= (height-z)) ~ roof_col,
+ roof ~ NA_character_,
+ #Door and windows
+ x == round(width/2) & z == 1 ~ NA_character_,
+ dplyr::between(x, 2, width-1) & x %% 2 == 0 & y > 1 & z == 2 ~ NA_character_,
+ dplyr::between(y, 2, length-1) & y %% 2 == 0 & z == 2 ~ NA_character_,
+ x %in% c(1, width) | y %in% c(1, length) ~ house_col),
+ x = x+x_coord,
+ y = y+y_coord
+ )
+ return(house_coords)
+}
+
+#Build one house
+brick_house() %>% bricks_from_coords() %>%
+ build_bricks(theta = 225)
+rayshader::render_snapshot(clear = TRUE)
Next, we write one more function, brick_street() to build a road and grass foundation. The, for an arbitrary number of houses and neighborhood size, use purrr::pmap_df to generate many houses and place them along the road.
brick_street <- function(width = 100, length = 40){
+ expand.grid(x=1:width, y=1:length, z=1) %>%
+ dplyr::mutate(
+ Color = dplyr::case_when(
+ y == round(length/2) & x %% 4 %in% 1:4 ~ "Bright yellow",
+ dplyr::between(y, length/2 -5, length/2 +5) ~ "Dark stone grey",
+ TRUE ~ "Dark green"
+ ))
+}
+
+#Build a village, houses on 2 sides of a street
+n_houses = 14
+sz = c(100, 40)
+
+list(x_coord = c(sample(seq(10, sz[1]-10, by = 10), n_houses/2),
+ sample(seq(10, sz[1]-10, by = 10), n_houses/2)),
+ y_coord = c(rep(sz[2]/2-15, n_houses/2), rep(sz[2]/2+10, n_houses/2)),
+ width = sample(4:10, n_houses, replace = TRUE),
+ length = sample(4:8, n_houses, replace = TRUE),
+ height = sample(5:8, n_houses, replace = TRUE)
+ ) %>%
+ purrr::pmap_df(brick_house) %>%
+ dplyr::bind_rows(brick_street(sz[1], sz[2])) %>%
+ bricks_from_coords() %>%
+ build_bricks()
+
+rayshader::render_camera(theta = 60, phi = 20, zoom = 0.75)
+rayshader::render_snapshot(clear = TRUE)
The bricks_from_* series of functions creates 3D models of LEGO bricks from a variety of input formats. These models are rendered using Tyler Morgan-Wall’s rayshader package. This package must be installed.
bricks_from_table() converts a matrix-shaped table of integers into LEGO bricks, where most columns are x-coordinates, rows are y-coordinates, and a special Level column denotes the elevation of the row. For simple models, this table can be made manually using data.frame() or tibble::tribble().
For more advanced models, it’s recommended you use MS Excel or a .csv file. bricks_from_excel() is a wrapper function to more easily build models designed using a Microsoft Excel template. Please see this repo: brickr toybox.
Pass the output of any bricks_from_*() function to build_bricks() to render it as a 3D model.
Create a single 2x4 brick with a 2x4 data frame, with an additional column to specify the ‘Level’. These can be letters or numbers.
+#This is a 2 (columns) x 4 (rows) brick
+(brick <- data.frame(
+ Level="A",
+ X1 = rep(3,4), #The number 3 is the brickrID for 'bright red'
+ X2 = rep(3,4)
+))
+#> Level X1 X2
+#> 1 A 3 3
+#> 2 A 3 3
+#> 3 A 3 3
+#> 4 A 3 3
+
+brick %>%
+ bricks_from_table() %>%
+ build_bricks(brick_res = "hd") #Bricks available in standard def, high def, and ultra hd.
+
+rayshader::render_snapshot( clear = TRUE)
Stack many bricks by changing the ‘Level’ value in the data frame. The script below uses purrr::map_df() to avoid copying and pasting. Changing the numeric values inside the data frame for each level creates different colors.
1:10 %>%
+ purrr::map_df(~dplyr::mutate(brick,
+ Level = LETTERS[.x],
+ X1 = .x,
+ X2 = .x)) %>%
+ bricks_from_table() %>%
+ build_bricks(brick_res = "hd")
+
+rayshader::render_snapshot( clear = TRUE)
The most direct way to create a 3D model is to manually create a data frame. Below, we create a data frame using tibble::tribble() so we can more easily see the structure as it’s written.
The data frame has 3 numbers as input (values of 0 are void spaces in the model). Rather than use the default brickr colors for the values of 1, 2, and 3, we define another data frame ‘brick_colors’
+tree_or_mushroom <- tibble::tribble(
+ ~Level, ~X1, ~X2, ~X3, ~X4, ~X5, ~X6,
+ "A", 1, 1, 1, 1, 1, 1,
+ "A", 1, 1, 1, 1, 1, 1,
+ "A", 1, 1, 1, 1, 1, 1,
+ "A", 1, 1, 1, 1, 1, 1,
+ "B", 0, 0, 0, 0, 0, 0,
+ "B", 0, 0, 2, 2, 0, 0,
+ "B", 0, 0, 2, 2, 0, 0,
+ "B", 0, 0, 0, 0, 0, 0,
+ "C", 0, 0, 0, 0, 0, 0,
+ "C", 0, 0, 2, 2, 0, 0,
+ "C", 0, 0, 2, 2, 0, 0,
+ "C", 0, 0, 0, 0, 0, 0,
+ "D", 0, 3, 3, 3, 3, 0,
+ "D", 0, 3, 3, 3, 3, 0,
+ "D", 0, 3, 3, 3, 3, 0,
+ "D", 0, 3, 3, 3, 3, 0,
+ "E", 0, 0, 3, 3, 0, 0,
+ "E", 0, 3, 3, 3, 3, 0,
+ "E", 0, 3, 3, 3, 3, 0,
+ "E", 0, 0, 3, 3, 0, 0,
+ "F", 0, 0, 0, 0, 0, 0,
+ "F", 0, 0, 3, 3, 0, 0,
+ "F", 0, 0, 3, 3, 0, 0,
+ "F", 0, 0, 0, 0, 0, 0,
+ "G", 0, 0, 0, 0, 0, 0,
+ "G", 0, 0, 3, 0, 0, 0,
+ "G", 0, 0, 0, 3, 0, 0,
+ "G", 0, 0, 0, 0, 0, 0
+)
+
+brick_colors <- tibble::tribble(
+ ~`.value`, ~Color,
+ 1, "Bright green",
+ 2, "Dark orange",
+ 3, "Dark green"
+)
+
+tree_or_mushroom %>%
+ bricks_from_table(brick_colors) %>%
+ build_bricks(theta = 210, phi = 20, brick_res = "hd")
+
+rayshader::render_snapshot(clear = TRUE)
That’s clearly a tree, right? Why is the data frame called ‘tree_or_mushroom’?
+Use the input ‘brick_type=“plate”’ to render the 3D model using LEGO plates rather than bricks, which are 1/3 as tall.
+brick_colors <- tibble::tribble(
+ ~`.value`, ~Color,
+ 1, "Dark green",
+ 2, "Light nougat",
+ 3, "Bright red"
+)
+
+tree_or_mushroom %>%
+ bricks_from_table(brick_colors) %>%
+ build_bricks(theta = 210, phi = 10, brick_res = "hd", brick_type="plate")
+
+rayshader::render_snapshot(clear = TRUE)
When designing larger models, it is much easier to use a spreadsheet program to lay out the bricks for each level.
+See the brickr toybox GitHub repo for some examples and templates.
+brickr also includes tools help users create the Mosaics and 3D model output using real LEGO® elements.
+The goal of {brickr} is to provide a series of tools to integrate the LEGO® system with R by:
+brickr is developed using publicly available information about LEGO® products and is not officially affiliated with The LEGO Group
Breaking: Pretty much EVERY function. Seriously, check out the README and start fresh.
Breaking: Data “lego_colors.rda” has been updated with more accurate RGB values and new brickrID numbers. This will impact previously created mosaics and 3D models.
build_instructions generates building instructions for 3D models, as well as mosaics.ggplot - continuous scale
Other Resources: build_pieces_table,
+
Other Resources: build_instructions,
+ build_pieces_table,
build_pieces, build_themes
R/build-mosaic.R
+ Source: R/build-instructions.R
build_instructions.Rdbuild_instructions(image_list, num_steps = 6)+
build_instructions(brickr_obj, num_steps = 6)
| image_list | -Mosaic object from image_to_mosaic(). |
+ brickr_obj | +brickr mosaic or 3D model object. |
|---|---|---|---|
| num_steps | -Number of discrete steps in instruction manual |
+ Number of discrete steps in instruction manual, for mosaics only |
Other Mosaics: build_mosaic,
- image_to_mosaic
Other Resources: build_colors,
+ build_pieces_table,
+ build_pieces, build_themes
build_mosaic(image_list, title = NULL)+
build_mosaic(brick_obj, title = NULL)
| image_list | -List output from collect_bricks() or image_to_bricks(). Contains an element |
+ brick_obj | +List output from image_to_bricks(). Contains an element |
||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| title | @@ -154,8 +163,7 @@
| image_list | -Mosaic output from image_to_mosaic(). |
+ brick_obj | +brickr mosaic or 3D model object. |
|---|
Other Resources: build_colors,
+ build_instructions,
build_pieces_table,
build_themes
build_pieces_table(image_list)+
build_pieces_table(brick_obj)
| image_list | -Mosaic output from image_to_mosaic(). |
+ brick_obj | +brickr mosaic or 3D model object. |
|---|
Other Resources: build_colors,
+ build_instructions,
build_pieces, build_themes
Other Resources: build_colors,
+ build_instructions,
build_pieces_table,
build_pieces
color_table is sup
Other Mosaics: build_instructions,
- build_mosaic
Other Mosaics: build_mosaic
Graphically display required bricks.
Display bricks required to build model or mosaic.