Convert RGB array to HSL

# -*- coding: utf-8 -*-
# @File    : rgb2hls.py
# @Info    : @ TSMC
# @Desc    :


import colorsys

import numpy as np
import scipy.misc
import tensorflow as tf
from PIL import Image


def rgb2hls(img):
    """ note: elements in img is a float number less than 1.0 and greater than 0.
    :param img: an numpy ndarray with shape NHWC
    :return:
    """
    assert len(img.shape) == 3
    hue = np.zeros_like(img[:, :, 0])
    luminance = np.zeros_like(img[:, :, 0])
    saturation = np.zeros_like(img[:, :, 0])
    for x in range(height):
        for y in range(width):
            r, g, b = img[x, y]
            h, l, s = colorsys.rgb_to_hls(r, g, b)
            hue[x, y] = h
            luminance[x, y] = l
            saturation[x, y] = s
    return hue, luminance, saturation


def np_rgb2hls(img):
    r, g, b = img[:, :, 0], img[:, :, 1], img[:, :, 2]

    maxc = np.max(img, -1)
    minc = np.min(img, -1)
    l = (minc + maxc) / 2.0
    if np.array_equal(minc, maxc):
        return np.zeros_like(l), l, np.zeros_like(l)
    smask = np.greater(l, 0.5).astype(np.float32)

    s = (1.0 - smask) * ((maxc - minc) / (maxc + minc)) + smask * ((maxc - minc) / (2.001 - maxc - minc))
    rc = (maxc - r) / (maxc - minc + 0.001)
    gc = (maxc - g) / (maxc - minc + 0.001)
    bc = (maxc - b) / (maxc - minc + 0.001)

    rmask = np.equal(r, maxc).astype(np.float32)
    gmask = np.equal(g, maxc).astype(np.float32)
    rgmask = np.logical_or(rmask, gmask).astype(np.float32)

    h = rmask * (bc - gc) + gmask * (2.0 + rc - bc) + (1.0 - rgmask) * (4.0 + gc - rc)
    h = np.remainder(h / 6.0, 1.0)
    return h, l, s


def tf_rgb2hls(img):
    """ note: elements in img all in [0,1]
    :param img: a tensor with shape NHWC
    :return:
    """
    assert img.get_shape()[-1] == 3
    r, g, b = img[:, :, 0], img[:, :, 1], img[:, :, 2]
    maxc = tf.reduce_max(img, -1)
    minc = tf.reduce_min(img, -1)

    l = (minc + maxc) / 2.0

    # if tf.reduce_all(tf.equal(minc, maxc)):
    #     return tf.zeros_like(l), l, tf.zeros_like(l)
    smask = tf.cast(tf.greater(l, 0.5), tf.float32)

    s = (1.0 - smask) * ((maxc - minc) / (maxc + minc)) + smask * ((maxc - minc) / (2.001 - maxc - minc))
    rc = (maxc - r) / (maxc - minc + 0.001)
    gc = (maxc - g) / (maxc - minc + 0.001)
    bc = (maxc - b) / (maxc - minc + 0.001)

    rmask = tf.equal(r, maxc)
    gmask = tf.equal(g, maxc)
    rgmask = tf.cast(tf.logical_or(rmask, gmask), tf.float32)
    rmask = tf.cast(rmask, tf.float32)
    gmask = tf.cast(gmask, tf.float32)

    h = rmask * (bc - gc) + gmask * (2.0 + rc - bc) + (1.0 - rgmask) * (4.0 + gc - rc)
    h = tf.mod(h / 6.0, 1.0)

    h = tf.expand_dims(h, -1)
    l = tf.expand_dims(l, -1)
    s = tf.expand_dims(s, -1)

    x = tf.concat([tf.zeros_like(l), l, tf.zeros_like(l)], -1)
    y = tf.concat([h, l, s], -1)

    return tf.where(condition=tf.reduce_all(tf.equal(minc, maxc)), x=x, y=y)


if __name__ == '__main__':
    """
    HLS: Hue, Luminance, Saturation
    H: position in the spectrum
    L: color lightness
    S: color saturation
    """
    avatar = Image.open("hue.jpg")
    width, height = avatar.size
    print("width: {}, height: {}".format(width, height))
    img = np.array(avatar)
    img = img / 255.0
    print(img.shape)

    # # hue, luminance, saturation = rgb2hls(img)
    # hue, luminance, saturation = np_rgb2hls(img)

    img_tensor = tf.convert_to_tensor(img, tf.float32)
    hls = tf_rgb2hls(img_tensor)
    h, l, s = hls[:, :, 0], hls[:, :, 1], hls[:, :, 2]

    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        hue, luminance, saturation = sess.run([h, l, s])
        scipy.misc.imsave("hls_h_.jpg", hue)
        scipy.misc.imsave("hls_l_.jpg", luminance)
        scipy.misc.imsave("hls_s_.jpg", saturation)

In case someone is looking for a self-contained solution (I really didn't want to add OpenCV as a dependency), I rewrote the official python colorsys rgb_to_hls() and hls_to_rgb() functions to be usable for numpy:

import numpy as np

def rgb_to_hls(rgb_array: np.ndarray) -> np.ndarray:
    """
    Expects an array of shape (X, 3), each row being RGB colours.
    Returns an array of same size, each row being HLS colours.
    Like `colorsys` python module, all values are between 0 and 1.

    NOTE: like `colorsys`, this uses HLS rather than the more usual HSL
    """
    assert rgb_array.ndim == 2
    assert rgb_array.shape[1] == 3
    assert np.max(rgb_array) <= 1
    assert np.min(rgb_array) >= 0

    r, g, b = rgb_array.T.reshape((3, -1, 1))
    maxc = np.max(rgb_array, axis=1).reshape((-1, 1))
    minc = np.min(rgb_array, axis=1).reshape((-1, 1))

    sumc = (maxc+minc)
    rangec = (maxc-minc)

    with np.errstate(divide='ignore', invalid='ignore'):
        rgb_c = (maxc - rgb_array) / rangec
    rc, gc, bc = rgb_c.T.reshape((3, -1, 1))

    h = (np.where(minc == maxc, 0, np.where(r == maxc, bc - gc, np.where(g == maxc, 2.0+rc-bc, 4.0+gc-rc)))
         / 6) % 1
    l = sumc/2.0
    with np.errstate(divide='ignore', invalid='ignore'):
        s = np.where(minc == maxc, 0,
                     np.where(l < 0.5, rangec / sumc, rangec / (2.0-sumc)))

    return np.concatenate((h, l, s), axis=1)


def hls_to_rgb(hls_array: np.ndarray) -> np.ndarray:
    """
    Expects an array of shape (X, 3), each row being HLS colours.
    Returns an array of same size, each row being RGB colours.
    Like `colorsys` python module, all values are between 0 and 1.

    NOTE: like `colorsys`, this uses HLS rather than the more usual HSL
    """
    ONE_THIRD = 1 / 3
    TWO_THIRD = 2 / 3
    ONE_SIXTH = 1 / 6

    def _v(m1, m2, h):
        h = h % 1.0
        return np.where(h < ONE_SIXTH, m1 + (m2 - m1) * h * 6,
                        np.where(h < .5, m2,
                                 np.where(h < TWO_THIRD, m1 + (m2 - m1) * (TWO_THIRD - h) * 6,
                                          m1)))


    assert hls_array.ndim == 2
    assert hls_array.shape[1] == 3
    assert np.max(hls_array) <= 1
    assert np.min(hls_array) >= 0

    h, l, s = hls_array.T.reshape((3, -1, 1))
    m2 = np.where(l < 0.5, l * (1 + s), l + s - (l * s))
    m1 = 2 * l - m2

    r = np.where(s == 0, l, _v(m1, m2, h + ONE_THIRD))
    g = np.where(s == 0, l, _v(m1, m2, h))
    b = np.where(s == 0, l, _v(m1, m2, h - ONE_THIRD))

    return np.concatenate((r, g, b), axis=1)


def _test1():
    import colorsys
    rgb_array = np.array([[.5, .5, .8], [.3, .7, 1], [0, 0, 0], [1, 1, 1], [.5, .5, .5]])
    hls_array = rgb_to_hls(rgb_array)
    for rgb, hls in zip(rgb_array, hls_array):
        assert np.all(abs(np.array(colorsys.rgb_to_hls(*rgb) - hls) < 0.001))
    new_rgb_array = hls_to_rgb(hls_array)
    for hls, rgb in zip(hls_array, new_rgb_array):
        assert np.all(abs(np.array(colorsys.hls_to_rgb(*hls) - rgb) < 0.001))
    assert np.all(abs(rgb_array - new_rgb_array) < 0.001)
    print("tests part 1 done")

def _test2():
    import colorsys
    hls_array = np.array([[0.6456692913385826, 0.14960629921259844, 0.7480314960629921], [.3, .7, 1], [0, 0, 0], [0, 1, 0], [.5, .5, .5]])
    rgb_array = hls_to_rgb(hls_array)
    for hls, rgb in zip(hls_array, rgb_array):
        assert np.all(abs(np.array(colorsys.hls_to_rgb(*hls) - rgb) < 0.001))
    new_hls_array = rgb_to_hls(rgb_array)
    for rgb, hls in zip(rgb_array, new_hls_array):
        assert np.all(abs(np.array(colorsys.rgb_to_hls(*rgb) - hls) < 0.001))
    assert np.all(abs(hls_array - new_hls_array) < 0.001)
    print("All tests done")

def _test():
    _test1()
    _test2()

if __name__ == "__main__":
    _test()

(see gist)

(off topic: converting the other functions in the same way is actually a great training for someone wanting to get their hands dirty with numpy (or other SIMD / GPU) programming). Let me know if you do so :)

edit: rgb_to_hsv and hsv_to_rgb now also in the gist.