The algorithm starts with a horizontal line on the interval $[-1,1]$. Each iteration adds new shortened lines to the ends of the existing lines. The first iteration results in a shape that resembles the letter H. After that, the direction of the lines switches at each iteration from horizontal to vertical.

If the number of iterations of the fractal is $p$, then each iteration adds $2^p$ lines to the tree, and the total number of lines in the fractal is $2^{p+1} + 1$.

The new lines are shortened by a factor, which is set at $\frac{1}{\sqrt{2}}$. If you set it any higher, the lines will overlap—a lower value results in a more sparse design.

The code below starts with setting the initial variables and defines the first line in a data frame. The data frame holds the start and end coordinates and the iteration number.

  library(ggplot2)
  ## H-Fractal Parameters
  p <- 8 ## Number of iterations
  a <- 1 / sqrt(2) ## Shortening parameter
  
  ## Define horizontal starting line
  h_fractal <- data.frame(x1 = -1,
                          y1 = 0,
                          x2 = 1,
                          y2 = 0,
                          m = 0)

The loop defines the iterations and adds a new row to the data frame for each line. First, the direction flips by setting the dx and dy values to either 0 or 1. The second part defines the row numbers for the previously defined lines and the new lines. The code then calculates the coordinates for the new line segments.

  # Generate coordinates (each line on a row)
  for (m in 1:p) {
    ## Flip direction
    dx <- (m - 1) %% 2
    dy <- m %% 2
    # Previous and current line numbers
    i <- (2^(m - 1)):(2^m - 1)
    j <- (2^m):(2^(m + 1) - 1)
    ## Calculate coordinates
    h_fractal[j, "x1"] <- c(h_fractal[i, "x1"] - dx * a^m, h_fractal[i, "x2"] - dx * a^m)
    h_fractal[j, "x2"] <- c(h_fractal[i, "x1"] + dx * a^m, h_fractal[i, "x2"] + dx * a^m)
    h_fractal[j, "y1"] <- c(h_fractal[i, "y1"] - dy * a^m, h_fractal[i, "y2"] - dy * a^m)
    h_fractal[j, "y2"] <- c(h_fractal[i, "y1"] + dy * a^m, h_fractal[i, "y2"] + dy * a^m)
    ## Set line property
    h_fractal[j, "m"] <- m
  }

Lastly, The fractal is visualised with ggplot and the line segment geometry. The colour of the line slowly fades by setting it to the iteration number.

    ## Visualise
  ggplot(h_fractal) + 
    aes(x = x1, y = y1, xend = x2, yend = y2,
        col = m) +
    geom_segment(size = .5) +
    scale_size(guide = NULL) +
    scale_colour_gradientn(colours = gray.colors(p), guide = NULL) + 
    theme_void()

You can find the code for this series of articles on my GitHub page.

Download from GitHub

Besides changing the number of iterations and the shortening factor, you can also play with line thickness, colours, and the lines’ direction. This Shiny application lets you play with all variables in this algorithm to generate

As seen on R Bloggers