Flow Field Basics

The steps I took are:

1. Set up a grid, and store some angles in each item.
2. Drop a point somewhere on the grid (or outside!), and see how it moves, by:
3. Find the grid item that is closest to the current position.
4. Extend the current position with that angle, by a specified amount.
5. Repeat.

We’ll start with a 10 x 10 grid, and initialize all items with some angles. I’m just going to fit 0 ~ 2*pi according to the y-position.

I like to start by crossing x/y combinations, because it works so well with ggplot2, but we’re going to throw it into a matrix for later use (row/col indexing).

library(tidyverse)

my_grid <- crossing(
  x = 1:10,
  y = 1:10
) %>% 
  mutate(angle = (y / 10) * 2*pi)

my_flow_field <- matrix(data = my_grid$angle, nrow = 10, ncol = 10)

This is what we have:

grid_visualized <- my_grid %>% 
  mutate(
    xend = x + cos(angle) * 0.5,
    yend = y + sin(angle) * 0.5
  ) %>% 
  ggplot() +
  geom_segment(aes(x = x, y = y, xend = xend, yend = yend)) +
  geom_point(aes(x = x, y = y)) +
  coord_equal()

grid_visualized

We’ll drop a couple particles, defined as a tibble containing x/y coords.

my_particles <- tibble(
  x = c(2.5, 8.5),
  y = c(2.5, 3.5)
)

grid_visualized +
  geom_point(data = my_particles, aes(x = x, y = y), color = "red", size = 3)

Let’s perform one iteration of step 3, 4 & 5 from the above.

3. Find the grid item that is closest to the current position.
4. Extend the current position with that angle, by a specified amount.
5. Repeat

To do this, we find the col/row index in the flow field that’s closest to the current particle’s x/y position. For now, one unit increase in x/y coords, matches one unit increase in col/row in the flow field grid (we’ll come back to this later).

Grab that angle in the flow field, and draw a line from the particle at that angle by a specified amount. (say 2.8)

get_closest_angle <- function(x, y, flow_field) {
  max_x <- ncol(flow_field)
  max_y <- nrow(flow_field)
  
  closest_x_index <- which(abs(1:max_x - x) == min(abs(1:max_x - x)))[[1]] # Pick the first one, if there's multiple points with same distances
  closest_y_index <- which(abs(1:max_y - y) == min(abs(1:max_y - y)))[[1]] 
  closest_angle <- flow_field[[closest_y_index, closest_x_index]]
  
  return(closest_angle)
}

next_angle <- my_particles %>% 
  pmap_dbl(get_closest_angle, flow_field = my_flow_field)

my_particles <- my_particles %>% 
  mutate(angle = next_angle) %>% 
  mutate(xend = x + cos(angle) * 2.8,
         yend = y + sin(angle) * 2.8)

grid_visualized +
  geom_segment(data = my_particles, aes(x = x, y = y, xend = xend, yend = yend), color = "red") +
  geom_point(data = my_particles, aes(x = x, y = y), color = "red", size = 3)

You can keep iterating this, each time, using the newly calculated destination points as the starting x/y coords for the next line to be drawn.

After 1 more iteration, you end up with this:

That’s it! This is all you need to understand to get started with the flow field. After this, it’s just playing around with parameters to explore your creativity!

Beyond the Basics

I broke down the workflow above, into 3/4 controllable functions.

1. generate_flow_field
2. start_particles
3. draw_curve + step_into_next_curve_segment

In short, these work together to define a flow field with perlin noise, sprinkle some particles, and track how they move.

Chaining all the functions together was a little manual, so I won’t cover that, but if you’re interested, check my github.

library(ambient)

generate_flow_field <- function(flow_field_width = 1000, 
                                resolution_factor = 0.025,
                                perlin_scale_factor = 0.005,
                                perlin_seed,
                                perlin_freq) {
  
  resolution <- flow_field_width * resolution_factor 
  num_cols <- flow_field_width %/% resolution
  num_rows <- num_cols
  
  long_grid_ff <- ambient::long_grid(x = 1:num_cols,
                                     y = 1:num_rows) %>%
    mutate(x = x * perlin_scale_factor,
           y = y * perlin_scale_factor) %>% 
    mutate(angle = ambient::gen_perlin(x, 
                                       y,
                                       seed = perlin_seed,
                                       frequency = perlin_freq))
  
  # normalize angles to be between 0 & 2pi
  min_per <- min(long_grid_ff$angle)
  max_per <- max(long_grid_ff$angle)
  
  long_grid_ff <- long_grid_ff %>% 
    mutate(angle = (angle-min_per) / (max_per-min_per) *  (2*pi-0) + 0)
  
  my_flow_field <- matrix(data = long_grid_ff$angle,
                          ncol = num_cols,
                          nrow = num_rows)
  
  visualized_flow_field <- crossing(
    x = 1:num_cols,
    y = 1:num_rows
  ) %>% 
    mutate(angle = map2_dbl(x, y, ~my_flow_field[[.y, .x]])) %>% 
    mutate(xend = x + cos(angle) * 0.5,
           yend = y + sin(angle) * 0.5) %>% 
    mutate(x_index = x, y_index = y) %>% 
    mutate(across(c(x, y, xend, yend), ~ .x * resolution))
  
  list(my_flow_field, visualized_flow_field)
}

start_particles <- function(n_out = 800,
                            flow_field_width,
                            num_steps,  
                            step_length,
                            flow_field,
                            resolution_factor)
{      
  df <- tibble::tibble(
    start_x = runif(flow_field_width*-0.1, flow_field_width*1.1, n=n_out),
    start_y = runif(flow_field_width*-0.1, flow_field_width*1.1, n=n_out)
  ) %>%
    mutate(row_num = row_number(),
           resolution = flow_field_width * resolution_factor,
           num_steps = num_steps,
           step_length = step_length)
  
  df %>% 
    pmap_dfr(draw_curve, 
             flow_field = flow_field)
}

draw_curve <- function(start_x, 
                       start_y, 
                       row_num, 
                       flow_field, 
                       resolution, 
                       left_x = 1 * resolution, 
                       bot_y  = 1 * resolution,
                       num_steps,   
                       step_length) 
{ 
  
  x_container <- vector("numeric", num_steps+1)
  y_container <- vector("numeric", num_steps+1)
  
  x_container[1] <- start_x
  y_container[1] <- start_y
  
  
  # grid dimension range
  x_dim_range <- 1:ncol(flow_field) 
  y_dim_range <- 1:nrow(flow_field)
  
  # With the rest of num_steps, move through the flow field, 
  # Each time, stepping towards the closest angle we can grab.
  for (i in 1:num_steps) {
    
    next_step <- step_into_next_curve_segment( 
      start_x     = x_container[i], 
      start_y     = y_container[i],
      left_x      = left_x,
      bot_y       = bot_y,
      resolution  = resolution,
      x_dim_range = x_dim_range,
      y_dim_range = y_dim_range,
      flow_field  = flow_field,
      step_length = step_length
    )
    
    x_container[i+1] <- next_step$x
    y_container[i+1] <- next_step$y
    
  }
  
  tibble::tibble(
    x = x_container,
    y = y_container,
    row_num = row_num 
  ) %>%               
    dplyr::mutate(plot_order = dplyr::row_number())  
}

step_into_next_curve_segment <- function(start_x, 
                                         start_y,
                                         left_x,
                                         bot_y,
                                         resolution,
                                         x_dim_range,
                                         y_dim_range,
                                         flow_field,
                                         step_length) 
{
  # Get the current x/y position (in relation to grid size)
  x_offset <- start_x - left_x
  y_offset <- start_y - bot_y
  
  # Scale it down, to match grid dimension
  curr_x_index <- round(x_offset / resolution, digits = 0)
  curr_y_index <- round(y_offset / resolution, digits = 0)
  
  # Find the closest point on the grid at each x/y 
  closest_x_index <- which(abs(x_dim_range - curr_x_index) == min(abs(x_dim_range - curr_x_index)))[[1]]
  closest_y_index <- which(abs(y_dim_range - curr_y_index) == min(abs(y_dim_range - curr_y_index)))[[1]]
  
  # Grab that angle
  closest_angle <- flow_field[[closest_y_index, closest_x_index]]
  
  # Extend the current line into that angle (scale it up again)
  x_step  <- step_length * cos(closest_angle) * resolution
  y_step  <- step_length * sin(closest_angle) * resolution
  res_x <- start_x + x_step
  res_y <- start_y + y_step
  
  list(x = res_x, y = res_y)
  
}

Final touch - colours

We’re almost there! Hear me out for a second while I put a finishing touch to our art piece with some colour work.

If you’ve noticed so far, I’ve been mixing in 3-4 different colours.

• Background
• Circle (sometimes same as background)
• 2-colour gradient to fill in the lines.

To make the 2-colour gradient work, I filled every single line segment (of length step_length) separately, by sampling 2 colours with weights based on y-location. (one colour is more dominant at the top) Like so:

But here’s the catch. Remember the awkward wording I had on groupings in function #3, draw_curve?

Notice the return value of this function has two different id columns, row_num & plot_order, for line-specific & segment-of-a-line-specific groupings. We’ll use this for colours later.

Using these id columns, I can apply my colour palettes at either line or segment level. So far, I’ve been mostly doing segment colouring, but there are 2 line colouring methods that I explored. (weighted on mean y of line vs starting y of line)

Left-to-right: segment, line-mean, line-start

The difference between 2 line methods is subtle. You’ll notice that there’s more blue flowing into the bottom right corner, because those lines started in the upper half of the picture.

Conclusion

Hope you enjoyed this tutorial! I absolutely loved working on this, and writing this blog post really took my understanding of this concept to a new level. If you’ve read this far, you can do everything I’ve shown here, without a doubt. There’s a ton of things you can do with this concept, and I encourage you to explore all the possibilities!