Hexagon tilings with Python - Part 2

Iteration variations

What becomes clear upon inspection of the result is how the overlapping lines are drawn. The first hexagon, drawn in red, has its lower right line drawn over in green by the next rows’ hexagon. The exact order in which this occurs can be influenced by changing the order in which iteration happens:

• Sequential row -> column iteration
• Sequential column -> row iteration
• Random row -> column iteration
• Iteration that draws in inward/outward hexagonal patterns

Generating these different iteration patterns is outside the scope of this post, but may prove an interesting thing to play with for certain projects.

Delegating image creation

In the previous examples we’ve done a fair bit of hand-waving when it comes to determining the size of the canvas. By now, with the canvas creation becoming more involved, it makes sense to take another good look at the requirements and create a new function that satisfies these.

The function should accept a 2-tuple that contains the size of the pattern, and the desired number of repetitions. From this, a canvas should be created that is as close to square as possible. The returned value shall be an instance of class Image:

1
2
3
4
5
6

def create_canvas(pattern_size, repetitions):
  """Returns an Image that fits the given number of pattern repetitions."""
  width, height = pattern_size
  canvas_width = int(repetitions * width)
  canvas_height = int(round(canvas_width / height) * height)
  return Image.new('RGB', (canvas_width, canvas_height), 'white')

For this use-case, the pattern will always be wider than taller, so the canvas size is determined by the number of horizontal repetitions. Once that is determined, the height is chosen as the number of repetitions that brings the resulting canvas closest to a square.

Extending the function to work with patterns of different aspect ratio is left as an exercise for the reader.

How many rows to fill a canvas

Put simply, we need a convenience function to determine the number of rows that fit the created canvas. The canvas creation function knows the number of pattern repetitions that fit, from which we can derive the number of rows needed to fill the image. However, it would add a secondary purpose to that function, which is not ideal. Adding a method to the class HexagonGenerator that returns how many rows fit a given dimension seems like the way forward:

1
2
3
4
5

class HexagonGenerator(object):
  # Rest of class as previously defined
  def rows(self, canvas_height):
    """Returns the number of rows required to fill the canvas height."""
    return int(math.ceil(canvas_height / self.row_height))

The number of rows returned is rounded up, to make up for the integer truncation that happens in the create_canvas() function. As such, the number returned is the number of rows required to fill the image without leaving a single open line.

Wrapping stage one: horizontal

To create an image that can be tiled, the empty sections along the left edge need to be of the same colors as the empty sections along the right. And the same goes for the top and bottom. Obviously, we cannot do this by simply relying on luck when we get a random color.

The simplest solution is to generate a full row’s worth of colors ahead of time. Coloring the hexagons in the row is then a matter of iterating over this list of colors, painting hexagons from left to right. After all colors in the list are used, the hexagon that sits on (or over) the right edge is drawn using the color from the 0th position of the list. This way, the two will always match up:

colors = [random_color() for _ in range(repetitions)]
for column, color in enumerate(colors):
  draw.polygon(list(hexagon(row, column)), Brush(color))
draw.polygon(list(hexagon(row, repetitions)), Brush(colors[0]))

The special case can be made part of the general loop if the colors list is not enumerated but indexed, and the number of columns iterated is one extra. The index on the colors list has to be kept within bounds, which is where the modulo operator comes in handy:

colors = [random_color() for _ in range(repetitions)]
for column in range(repetitions + 1):
  color = colors[column % repetitions]
  draw.polygon(list(hexagon(row, column)), Brush(color))

Wrapping stage two: vertical

The vertical wrapping is conceptually similar to the horizontal wrapping, but requires a slightly different approach. After performing the number of iterations as instructed by the HexagonGenerator.rows() method, the last row consists of polygons that are cut in half by the lower edge of the canvas. Because of Python’s variable scope behavior [1], the list of colors that was created and used for that last row is still available after the main drawing loop has concluded.

All we need to do to achieve color wrapping is to draw hexagons along the top half-row, which is easily done by proving row=-1.

Putting it all together

The final version of the script combines the code from the previous three sections to create a tileable covering of the canvas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

def main(repetitions=2):
  hexagon = HexagonGenerator(40)
  image = create_canvas(hexagon.pattern_size, repetitions)
  draw = Draw(image)
  for row in range(hexagon.rows(image.size[1])):
    colors = [random_color() for _ in range(repetitions)]
    for column in range(repetitions + 1):
      color = colors[column % repetitions]
      draw.polygon(list(hexagon(row, column)), Brush(color))
  for column, color in enumerate(colors):
    draw.polygon(list(hexagon(-1, column)), Brush(color))
  draw.flush()
  image.show()