Creating a mostly-random color generator

Picking a color representation

There are a few different ways to describe colors in RGB colorspace, providing us with different approaches on how to restrict the available portion to select colors randomly from:

• RGB: Red, Green and Blue values — A direct representation of the intensity of each of the color components.
• HSV: Hue, Saturation, Value (brightness) — A cylindrical color mapping, common in color wheels in various graphics programs
• HSL: Hue, Saturation and Lightness — Another cylindrical color mapping, similar to HSV but with a few different behaviors which we’ll discuss in a moment

Any of the above could be used, and all three have potentially interesting behavior when certain values are kept constant, or only allowed to vary by a small amount. If we would like a behavior where we can restrict the hue of the color but have full variation in lightness and color intensity, the direct RGB mode is ruled out.

The choice between HSV and HSL mostly comes down to a matter of taste. Intuitively, when I read a color where all three channels are maxed, I would expect that to be a fully saturated and maximally intense color. HSV gives us that result, where HSL gives us full white (the maximum chroma is achieved at L=0.5). For this reason, let’s take HSV as our color coordinate system.

HSV to RGB in Python

Conveniently, Python comes with a library that does transitions between different color coordinate mappings of RGB. The colorsys library contains a pair of functions to convert between RGB and HSV (as well as HSL and YIQ). There is a small catch though: all inputs and outputs are floating point numbers between 0 and 1, rather than the 0-255 integers we typically see for RGB.

This is simply because there is nothing restricting RGB to exactly eight bits per channel. In the 90’s, 16-bit color modes were common, where red, green and blue were represented by 5, 6, and 5 bits respectively. And on the other end of the spectrum, digital camera RAW output typically contains 12 or 14 bits per channel worth of color information [1]. This is also known as the dynamic range of the colors.

The typical dynamic range for computer monitors, and consequently for most image formats, is the aforementioned eight bits. PIL (and with it, aggdraw) accepts color channel values in an 8-bit range, so we need need to map the 0-1 floating point output to a 0-255 integer range and vice-versa.

import colorsys

def to_float(value, domain=255):
  return float(value) / domain

def from_float(value, domain=255):
  return int(round(value * domain))

rgb = 10, 150, 255
hsv = colorsys.rgb_to_hsv(*map(to_float, rgb))
print hsv  # (0.5714285714285715, 0.9607843137254902, 1.0)
rgb = map(from_float, colorsys.hsv_to_rgb(*hsv))
print rgb  # [10, 150, 255]

Building the randomizer

Let’s build a simple randomizing function where can lock down the hue. To make the function slightly friendlier to our human inputs, we’ll accept hue inputs as degrees, mimicking the color circle as commonly seen in image editing software.

import colorsys
import random

def random_color(hue=None, sat=None, val=None):
  hue = hue / 360.0 if hue is not None else random.random()
  sat = sat if sat is not None else random.random()
  val = val if val is not None else random.random()
  to_eightbit = lambda value: int(round(value * 255))
  return map(to_eightbit, colorsys.hsv_to_rgb(hue, sat, val))

random_color(hue=0)    # something red:  [186, 98, 98]
random_color(sat=0)    # something gray: [134, 134, 134]
random_color(sat=1, val=1) # max chroma: [36, 0, 255]

random_color(hue=0)

Coloring of uniform hue and variable saturation & brightness.

def channel_picker(value):
  if value is None:
    return random.random
  if isinstance(value, tuple):
    start, stop = value
    return lambda: random.random() * (stop - start) + start
  return lambda: value

>>> rand = channel_picker((0.4, 0.6))  # Randoms in given range
>>> [rand() for _ in range(3)]
[0.4785833631009269, 0.4449304246805125, 0.5504729222480945]
>>> rand = channel_picker(0.76)        # Constant values
>>> [rand() for _ in range(3)]
[0.76, 0.76, 0.76]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import colorsys
import random

class HsvColorGenerator(object):
  def __init__(self, hue=None, saturation=None, value=None):
    self.h_func = self._channel_picker(hue, scale=360)
    self.s_func = self._channel_picker(saturation)
    self.v_func = self._channel_picker(value)

  def __call__(self):
    """Returns a random color based on configured functions."""
    hsv = self.h_func(), self.s_func(), self.v_func()
    expander = lambda value: int(round(value * 255))
    return tuple(map(expander, colorsys.hsv_to_rgb(*hsv)))

  def _channel_picker(self, value, scale=1):
    """Returns a function to create (restricted) random values."""
    if value is None:
      return random.random
    scaler = self._scale_input(scale)
    if isinstance(value, tuple):
      start, stop = map(scaler, value)
      return lambda: random.random() * (stop - start) + start
    else:
      value = scaler(value)
      return lambda: value

  def _scale_input(self, scale_max):
    """Creates a function that compresses an range to [0-1]."""
    scale_max = float(scale_max)
    return lambda num: num / scale_max

Examples in blue

In the last code example, we update the tiling creator from the last post to use an externally supplied random color generator, and supply it with instances of the HsvColorGenerator. We run the creator function several times, each time with a different random color generator. We start off with a grayscale variant and increase color and tint ranges with every iteration.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

def draw_tiling(repetitions, edge_length, color_func):
  hexagon = HexagonGenerator(edge_length)
  canvas = create_canvas(hexagon.pattern_size, repetitions)
  draw = Draw(canvas)
  for row in range(hexagon.rows(canvas.size[1])):
    colors = [color_func() 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()
  canvas.show()

def random_blues():
  # Plain grayscale to start off with
  yield HsvColorGenerator(saturation=0, value=(.1, .9))
  # Monochrome blue with brightness variation
  yield HsvColorGenerator(hue=220, saturation=.4, value=(.1, .9))
  # Wider chroma with a fixed saturation
  yield HsvColorGenerator(hue=(180, 220), value=(.1, .9), saturation=.4)
  # Removed fixed saturation for a more lively image
  yield HsvColorGenerator(hue=(180, 220), value=(.1, .9))

def main():
  for color_func in random_blues():
    draw_tiling(12, 5, func)

Some results of the above script.

And that is it for this short series on creating hexagon tilings and coloring them. An idea that got sparked by some random website, explored on a delayed and detoured train ride home, and put into words over the span of a fortnight. And it resulted in a less boring blog theme to boot! If you’ve made something similar, more awesome, derived from this, or a suggestion on where to take this, let me know with a comment.

Footnotes