Newer
Older
kotlin-webgl-test / src / main / kotlin / games / perses / color / Color.kt
package games.perses.color

/**
 * User: rnentjes
 * Date: 8-2-17
 * Time: 12:28
 *
 * Taken from (java version): http://stackoverflow.com/questions/2353211/hsl-to-rgb-color-conversion
 */

object Color {

    /**
     * Converts an HSL color value to RGB. Conversion formula
     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
     * Assumes h, s, and l are contained in the set [0, 1] and
     * returns r, g, and b in the set [0, 255].

     * @param h       The hue
     * *
     * @param s       The saturation
     * *
     * @param l       The lightness
     * *
     * @return int array, the RGB representation
     */
    fun hslToRgb(h: Float, s: Float, l: Float): IntArray {
        val r: Float
        val g: Float
        val b: Float

        if (s == 0f) {
            b = l
            g = b
            r = g // achromatic
        } else {
            val q = if (l < 0.5f) l * (1 + s) else l + s - l * s
            val p = 2 * l - q
            r = hueToRgb(p, q, h + 1f / 3f)
            g = hueToRgb(p, q, h)
            b = hueToRgb(p, q, h - 1f / 3f)
        }
        val rgb = intArrayOf((r * 255).toInt(), (g * 255).toInt(), (b * 255).toInt())

        return rgb
    }

    /** Helper method that converts hue to rgb  */
    fun hueToRgb(p: Float, q: Float, t: Float): Float {
        var lt = t
        if (lt < 0f) {
            lt += 1f
        }
        if (lt > 1f) {
            lt -= 1f
        }
        if (lt < 1f / 6f) {
            return p + (q - p) * 6f * lt
        }
        if (lt < 1f / 2f) {
            return q
        }
        if (lt < 2f / 3f) {
            return p + (q - p) * (2f / 3f - lt) * 6f
        }
        return p
    }

    /**
     * Converts an RGB color value to HSL. Conversion formula
     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
     * Assumes pR, pG, and bpBare contained in the set [0, 255] and
     * returns h, s, and l in the set [0, 1].

     * @param pR       The red color value
     * *
     * @param pG       The green color value
     * *
     * @param pB       The blue color value
     * *
     * @return float array, the HSL representation
     */
    fun rgbToHsl(pR: Int, pG: Int, pB: Int): FloatArray {
        val r = pR / 255f
        val g = pG / 255f
        val b = pB / 255f

        val max = if (r > g && r > b) r else if (g > b) g else b
        val min = if (r < g && r < b) r else if (g < b) g else b

        var h: Float
        val s: Float
        val l: Float
        l = (max + min) / 2.0f

        if (max == min) {
            s = 0.0f
            h = s
        } else {
            val d = max - min
            s = if (l > 0.5f) d / (2.0f - max - min) else d / (max + min)

            if (r > g && r > b)
                h = (g - b) / d + (if (g < b) 6.0f else 0.0f)
            else if (g > b)
                h = (b - r) / d + 2.0f
            else
                h = (r - g) / d + 4.0f

            h /= 6.0f
        }

        val hsl = floatArrayOf(h, s, l)
        return hsl
    }
}